(type char * = address of a value that has a character) int* p Even further, in the case I just made up above, the compiler is expecting the address to hold a character value, not a number. We give it this by using a reference operator, alos called the address-of operator ' & ' before a variable. In that case, when the * is after a type (int, char, etc.) the compiler is expecting a variable's address. So, in the context of declaring a type such as int or char, we would use the dereferencer ' * ' to actually mean the reference (the address), which makes it confusing if you see an error message from the compiler saying: 'expecting char*' which is asking for an address. (context here being the declaration of a 'prototype'.)Р”Р‡unction(&var) // we are giving the function a 'reference', we are giving it an 'address' even though the symbol ' * ' is typically used to mean 'dereferenced variable'(meaning: to use the value at the address of a variable)-despite it's common use, in this case, the symbol means a 'reference', again, in THIS context. When I 'call'(use) this function later, I better give it a variable-address! So instead of var, or q, or w, or p, I give it the address of var so &var, or &q, or &w, or &p. Int function(int*) // This function is being declared as a function that takes in an 'address' that holds a number (so int*), it's asking for a 'reference', interchangeably called 'address'. The context that * is in, confuses the meaning sometimes. The dereference operator * is also called the indirection operator. * is the dereference operator and can be read as РІР‚Сљvalue pointed byРІР‚Сњ. & is the reference operator and can be read as РІР‚Сљaddress ofРІР‚Сњ. Invalid referencing is more likely to cause compiler errors than crashes, but it's not a good idea to rely on the compiler for this.

Dereferencing a pointer to a variable that has since gone out of scope can also cause a crash.

Dereferencing a pointer to a variable that was dynamically allocated and was subsequently de-allocated can cause a crash.

Dereferencing with an invalid type cast will have the potential to cause a crash.

Dereferencing an uninitialized pointer can cause a crash.

Invalid dereferencing may or may not cause crashes: The type of variable the pointer points to is the type less the outermost asterisk.

NOTE: The value stored at the address of the pointer must be a value OF THE SAME TYPE as the type of variable the pointer 'points' to, but there is no guarantee this is the case unless the pointer was set correctly.

In order to be valid, a pointer has to be set to the address of a variable of the same type as the pointer, without the asterisk: int c1 Р”Вereferencing a pointer means using the * operator (asterisk character) to retrieve the value from the memory address that is pointed by the pointer: Referencing means taking the address of an existing variable (using &) to set a pointer variable.

Reference meaning