References, Pointers and Constants

Simple C++ Data Types

C++ code	What it means	When to use it
char int double	Single (scalar) value (character, integer, floating point number)	To store data To pass data to a function by value To return data by value
const char const int const double	Constant value	To declare a constant -- a value that cannot be changed Has no effect for passing values to a function or from returning values from a function
char [] int [] double []	Array (vector) of values (char [] is a string)	To store the same type of data together To pass an array to a function
const char [] const int [] const double []	Constant array of values (const char [] is a string constant)	To declare an array of constant values (no element in the array can be changed) const char [] is used to declare a string constant
char * int * double *	Pointer to a single value or an array of values	To store a string (char *) To store an array of values when you have to allocate the memory dynamically (using new) To pass an array to a function To pass a value to a function which the function will set (passing by reference) To return a dynamically-allocated array from a function.
const char * const int * const double *	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 To return a pointer to a constant value To pass a pointer to a constant value to a function
char & int & double &	Reference to a value	To pass a value to a function which will be set by the function (without using a pointer)
char * & int * & double * &	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 int * const double * 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 (struct is optional)	Data structure value	To store values in a data structure Not to be used to pass structures to a function or to return structures from a function (inefficient!)
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 When you want to pass a single data structure or an array of data structures to a function, or to return same from a function
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:

struct somestruct

{

char * string_member;

int int_member;

double floating_point_member;

};

We can declare an instance of that structure and initialize (assign values to each member of) the instance:

somestruct aStruct = { "somestring", 1, 3.14159265 };

We can declare a pointer to a somestruct by declaring a pointer variable and taking the address of the instance:

somestruct * pStruct = &aStruct;

or we can declare a reference to a somestruct by creating a reference variable:

somestruct & refStruct = aStruct;

or a constant reference:

const somestruct & crefStruct = aStruct;

or a pointer to a constant somestruct:

const somestruct * cpStruct = &aStruct;

or a constant pointer to somestruct:

somestruct * const pcStruct = &aStruct;

Using any pointer to somestruct (constant or otherwise), to access a member, use the indirect reference operator, ->:

// 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.

We can even declare a reference to a somestruct through a pointer:

somestruct & refStruct2 = *pcStruct; // dereference the pointers

somestruct & refStruct3 = *pStruct;

const somestruct & refStruct4 = *cpStruct; // must be constant reference