References, Pointers and Constants

From Yggenyk
Jump to: navigation, search

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

id=siteTree