C++ Declarations

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

Download an example program for simple C++ data types

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.

Download an example program for C++ structures

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

Download an example program

Back to the COMP435 page