References, Pointers and Constants
Simple C++ Data Types
C++ code | What it means | When to use it |
---|---|---|
char |
Single (scalar) value (character, integer, floating point number) |
To store data |
const char |
Constant value |
To declare a constant -- a value that cannot be changed |
char [] |
Array (vector) of values |
To store the same type of data together |
const char [] |
Constant array of values |
To declare an array of constant values (no element in the array can be changed) |
char * |
Pointer to a single value or an array of values |
To store a string (char *) |
const char * |
Pointer to a constant value |
When you don't want the value at the pointer to be changed, but you can still change the pointer |
char & |
Reference to a value |
To pass a value to a function which will be set by the function (without using a pointer) |
char * & |
Reference to a pointer |
To pass a pointer to a function where the function will set the pointer (either by calling new or by assigning to the pointer |
char * const |
Constant pointer |
When you want to point to a specific value. Allows to you to change the data that is pointed to, but you can't change the pointer |
C++Structures
C++ code | What it means | When to use it |
---|---|---|
struct somestruct |
Data structure (user-defined) |
To store different types of data together |
struct somestruct |
Data structure value |
To store values in a data structure |
const struct somestruct |
Constant data structure value |
When you don't want of the member data values to be changed |
struct somestruct & |
Reference to a data structure value |
To pass a data structure to a function where the function will change some data members of that structure |
const struct somestruct & |
Constant reference to a data structure value |
To pass a data structure to a function where the function will not or cannot change any data members of that structure |
struct somestruct [] |
Array of data structure values |
Used to group several identical data structures (with different values) together |
const struct somestruct [] |
Array of constant data structure values |
When you don't want code to be able to change any data structure values in the array |
struct somestruct * |
Pointer to a data structure value |
When you want to allocate a single data structure or an array of data structures using new |
const struct somestruct * |
Constant pointer to a data structure value |
Same as above, but when you don't want the function that gets called, or the code that called the function, to change any values in any data structure |
struct somestruct * & |
Reference to a pointer to a data structure value |
When the calling function will be allocating the pointer using new or assigning to the pointer |
Using The References and Pointers: * & . and ->
If & is used in a declaration, then it is defining a reference to a value:
- data-type & variable-name Reference to a value
- const data-type & variable-name Constant reference to a value
If & is used in a statement, then it is behaving as the address-of operator, and creating a pointer to a value:
- &variable-name
If * is used between two variables or constants of type int or double, then it is behaving as the multiplication operator:
- variable-name1 * variable-name2
- constant * variable-name
- variable-name * constant
- constant1 * constant2
If * is used in a declaration, then it is defining a pointer:
- data-type * variable-name Pointer to a value
- const data-type * variable-name Pointer to a constant value
- data-type * const variable-name Constant pointer to a value
- const data-type * const variable-name Constant pointer to a constant value
If * is used in a statement, then it is behaving as the dereferencing operator, and creating a value from a pointer:
- *pointer-variable-name
Using Pointers and References To Structures
If we have a data structure:
<source lang="cpp"> struct somestruct {
char * string_member; int int_member; double floating_point_member;
}; </source>
We can declare an instance of that structure and initialize (assign values to each member of) the instance: <source lang="cpp"> somestruct aStruct = { "somestring", 1, 3.14159265 }; </source>
We can declare a pointer to a somestruct by declaring a pointer variable and taking the address of the instance: <source lang="cpp"> somestruct * pStruct = &aStruct; </source>
or we can declare a reference to a somestruct by creating a reference variable: <source lang="cpp"> somestruct & refStruct = aStruct; </source>
or a constant reference: <source lang="cpp"> const somestruct & crefStruct = aStruct; </source>
or a pointer to a constant somestruct: <source lang="cpp"> const somestruct * cpStruct = &aStruct; </source>
or a constant pointer to somestruct: <source lang="cpp"> somestruct * const pcStruct = &aStruct; </source>
Using any pointer to somestruct (constant or otherwise), to access a member, use the indirect reference operator, ->: <source lang="cpp"> // read a data member cout << pcStruct->string_member << endl; cout << cpStruct->int_member << endl; cout << pStruct->floating_point_member << endl;
// write to a data member pcStruct->string_member = "Test"; // ^^^^^ OK, only the pointer is constant, not what it points to.
// cpStruct->int_member++; // ^^^^^^^ Not allowed! cpStruct is a pointer to a constant somestruct.
pStruct->double_member = 2.0 * PI * radius; // ^^^^^ OK, neither the pointer nor what it points to is constant. </source>
We can even declare a reference to a somestruct through a pointer:
<source lang="cpp"> somestruct & refStruct2 = *pcStruct; // dereference the pointers somestruct & refStruct3 = *pStruct; const somestruct & refStruct4 = *cpStruct; // must be constant reference </source>