Table of Content

0.1 Goal

0.1 Prerequisites

0.1 Programming Environment

1 Terminology

0.1 Variables

0.1 Pointers

0.1 Operators

0.0.1 Reference Operator (&) - an Address of

0.0.1 De-reference Operator (*) - a Value Pointed by

0.0.1 Offset Operator ([]) - a Special Version of a De-reference Operator

1 Operators in Action

0.1 What Can Be Done (and Why)

0.1 Pointer Arithmetic

0.1 Functions and Parameter Passing

1 Extras (Speacials Which Might Be Handy)

0.1 Constant Pointers

0.1 Void Pointers

0.1 Pointers to Pointers

0.1 Pointers to Functions

1 Few Bits on Dynamic Memory

0.1 Operators

0.0.1 New and Delete

0.0.1 Member Access from an Object (.)

0.0.1 Member Access from a Pointer (->)

1 Good Habits

1 Useful Notes

1.1 sizeof()

0.1 Casting

cout << (int) *pointer2 << endl;

1 Links

0.1 Detailed

0.1 Really for Dummies

0.1 Additional

Hands-on C++ Tutorial: Pointers, References, Memory, and Segfaults

Table of Content

Goal

Prerequisites

Programming Environment

Terminology

Variables

Pointers

Operators

Reference Operator (&) - an Address of

De-reference Operator (*) - a Value Pointed by

Offset Operator ([]) - a Special Version of a De-reference Operator

Operators in Action

What Can Be Done (and Why)

Pointer Arithmetic

Functions and Parameter Passing

Extras (Speacials Which Might Be Handy)

Constant Pointers

Void Pointers

Pointers to Pointers

Pointers to Functions

Few Bits on Dynamic Memory

Operators

New and Delete

Member Access from an Object (.)

Member Access from a Pointer (->)

Good Habits

Useful Notes

sizeof()

Casting

Links

Detailed

Really for Dummies

Additional

ROOT is a physics analysis framework, you can get it here: http://ROOT.cern.ch/, it is very easy to install, do not worry and get scared by title page. This tutorial will only use a tiny bit of it, and it is worth it, trust me.

Note 1: Both: int* pointer1, int *pointer1; will work as well, spaces are not important;

De-reference operator (*) - a value pointed by

Offset operator ([]) - a special version of a de-reference operator

... and get the addresses (using the reference operator):

Next, try this:

• Function cannot change the value of input parameters (safe).
• Only data structures, which are copyable can be passed.
• Function cannot return multiple values.
• Copying is slow.

Why to use all of this const mess? Please look at resource 6, I would attach my signature if that would be printed on a paper. To summarize - at a little expense of some extra thinking, you can write a code which is less prone to incidental errors, easier to debug, and easier to optimize. Especially function parameters should be declared as constant if they are not changed inside the function, this can speed up the code a big bit.

Void Pointers

The void type pointer has no type, surprisingly. Void pointers point to a value that has no type (and thus also an undetermined length and undetermined de-reference properties). Therefore they cannot be de-referenced without being properly type cast first. On the other hand, they can point to any data type, from an integer value or a float, to an object or a string of characters.

void * void_pointer;

They are useful for input or output values of functions where they provide no limitations on data types. On the other hand, user must be told what to expect and what to cast the pointer to. Using them is like balancing on the edge. It is easy to fall and segfault. Do not use them unless you have to.

Pointers to pointers

... and:

cout << "pointer1 points to a content: " <<  *pointer1  << ", and has itself an address: " << hex << (int) &pointer1 << endl;
cout << "pointer_to_pointer points to content: " << dec << **pointer_to_pointer << " << cout;
cout << "pointer_to_pointer points to an address: " <<  hex << (int) *pointer_to_pointer << ", and has itself an address of: " << (int) &pointer_to_pointer << endl;

Quite logical I assume. Why to use it? It might not make sense directly, but it can be useful if you already have several versions of content referenced by several pointers and you need to pick one and pass it.

Pointers to Functions

Yes, it can be done, you can point to function. Typical use of this is to pass a function as an argument to another function or an object - to an iterator for example. You declare it like the prototype of a function, enclose the name in parentheses () and add an asterisk.

Create a function pointer (note: no quotes around function name):

Note: sqrt is ROOT name for square root function.

double (*function_pointer)(int) = sqrt;

Call a function in a pointer (works in ROOT):

(*function_pointer)(25);

And output is: (const double)5.00000000000000000e+00 Correct!

Few Bits on Dynamic Memory

Operators

New and Delete

• new is typesafe. malloc() returns a void pointer which needs to be cast, but new returns an object of the specified type.
• malloc() only reserves memory, while new also calls a constructor on an object.

You actually have two versions of each, one for variables and one for arrays:

• new
• delete
• new[]
• delete[]

//remember int *pointer1;

Check it:

And always do not forget to clean your memory:

Member access from an object (.)

Member access from a pointer (->)

Lets create another item dynamically (use previous item struct definition):

item * dynamic_hammer = new item;
dynamic_hammer -> weight = 2;
dynamic_hammer -> price = 22.3;

//clean the mess, free memory and set pointer to point nowhere
delete dynamic_hammer;
dynamic_hammer = NULL;

... To be continued in C++ Objects and Dynamic Memory Tutorial

Good Habits

• Always initialize pointer variables, or set them to NULL.
• Do not forget, C strings (char arrays) have a terminating 0 so they are one byte longer.
• Check if new succeeded.
• Clean your memory after yourself!
• Set unused pointers to NULL.

Useful Notes

sizeof()

sizeof(char)
sizeof(short)
sizeof(int)
sizeof(long)
sizeof(Long64_t)

For more: List of ROOT data types

Casting

Links

Detailed

1. C++ : Documentation : C++ Language Tutorial : Pointers
2. C++ Tutorial - About Pointers

Really for dummies

1. Learning C++ Pointers for REAL Dummies

Additional

1. C++ Tutorial - Storage Specifiers
2. C++ Operator Precedence
3. Const Correctness in C++

Hands-on C++ Tutorial: Pointers, Dynamic Memory Allocation and Segfaults

Goal

Prerequisites

Programming Environment

Where to get Root?

Root is a physics analysis framework, you can get it here: http://root.cern.ch/, it is very easy to install, do not worry and get scared by title page. This tutorial will only use a tiny bit of it, but it is worth it, trust me.

Terminology

Variables

syntax: [const] type (identifier [= starting_value])*;

Example: (Type it into your Root command prompt, we will use it later. Of course, omit the root prompt, I will omit it in next examples as well.)

root [0]  int variable1 = 42, tmp_variable = 0; 

Declares a regular variable. It can store an integer value whose exact size depends on your system and current compiler. As soon as we declare a variable, the required amount of memory is reserved for it. We cannot choose a specific location, this is done solely by a compiler. Statically declared variables are usually on the same place during every run-time until you recompile your program.

Note: Statically declared variables are normally set to 0 upon declaration in Root. But do not count on it, it is not a standard behavior.

#define ARRAY_SIZE 5

Declares a constant. It is in fact a pre-compiler directive, which is expanded to its value before compilation itself. It is a good habit to have such constant in uppercase.

int array1[ARRAY_SIZE];

Declares an array of five integers - a continuous piece of memory of five consequent integer slots. array1 itself is in fact nothing more than just a plain pointer to the first slot which gets a special treatment by a compiler. We will return to this topic again later.

for (tmp_variable = 0; tmp_variable < ARRAY_SIZE; tmp_variable ++) array1[tmp_variable] = tmp_variable * tmp_variable;

Fill the array by some values (square of tmp_variable).

Note: Type this if you know it anyway, because it will be used later.

Pointers

syntax: [const] type ([const] \* name)*; //where name is a valid identifier, \* means asterisk character, not pattern repetition

For example:

int * pointer1 = NULL; 

Declares a pointer. Pointer is in fact a regular unsigned integer type (no matter whether it points to float, object, or char), but because its use is notably different, it is defined as a specific type.

Note 1: There is no pointer type, you need to use an asterisk for every pointer declaration, ie. int * p1, * p2;.

Note 2: NULL is a special value that indicates that pointer is not pointing to any valid reference or memory address, it is called a null pointer. This value is a result of type-casting an integer value of 0 to any pointer type. Many programming environments have a constant of this kind defined, Root uses NULL.

It is of course possible to declare an array of pointers.

int * pointer_array[ARRAY_SIZE];

Declares an array of 5 pointers, each to an int variable.

Operators

Reference operator (&) - an address of

"Tell me your address in memory."

Returns the address of a variable in a memory, which can be, for example, later saved as a pointer. Quite like this:

pointer1 = &variable1; //assuming we declared pointer1 before, as we did

Then we can do:

cout << "Address of variable1 is: " << &variable1 << endl;
cout << "Content of pointer1 is: " << pointer1 << endl;

Not surprisingly, results are the same, pointer1 point to the same place where variable 1 is.

However, this is not all. Check out this:

for (tmp_variable = 0; tmp_variable < ARRAY_SIZE; tmp_variable ++){
cout << "Address of an array slice " << tmp_variable << " is: " << &array1[tmp_variable] << endl;
}

You will get something like (addresses my differ):

Address of an array slice 0 is: 0x335f170
Address of an array slice 1 is: 0x335f174
Address of an array slice 2 is: 0x335f178
Address of an array slice 3 is: 0x335f17c
Address of an array slice 4 is: 0x335f180

Array slices are on consequent addresses and we see that an integer in our (mine) Root has 4 bytes.

De-reference operator (*) - "a value pointed by"

"Tell me what is on the place you point to."

Retrieves a content of a memory pointed by the pointer. The amount of memory read (or written) depends on the pointer type.

cout << "Content of variable1 is: " << variable1 << endl;
cout << "Value pointed by pointer1 is: " << *pointer1 << endl;

Not surprisingly, results are the same, pointer1 points to the very same place as where variable 1 is. We set it like this, remember?

To make the chapter complete, I briefly mention other operators, which will be then explained later.

Offset operator ([]) - A special version of a de-reference operator

It is a mere shortcut, it combines a de-reference operation and an offset calculation: "give me the content of a memory cell on the address of pointer plus an offset." It will be explained in detail in the sections Putting all operators together and Pointer Arithmetic.

Operators in Action

What Can Be Done (and Why)

We can also do the following:

int * pointer_to_array = array1;  

We are storing the address of the first element of an array to a pointer, it is actually quite same as: int * pointer_to_array = &array1[0];

Check it out:

cout << "Content of a pointer to array is: " << *pointer_to_array << endl;
cout << "Content of array1[0] is: " << array1[0] << endl;

... and the addresses (employ the reference operator):

cout << "Address of 0th element of an array1 is: " << &array1[0] << endl;
cout << "pointer_to_array points to: " << pointer_to_array << endl;

And try this:

cout << "Content of array1[1] is: " << array[1] << endl;
cout << "Content of pointer_to_array[1] is: " << pointer_to_array[1] << endl;

Both are 1, we stored there one, remember 1*1 = 1?

And how does compiler know that this is an array? It does not! This is just a language construct called de-referencing an address with an offset. I told ya.

Try this:

cout << "Content of array1[8] is: " << array1[8] << endl;

Ok, Root complains: Error: Array index out of range array1[8] -> [8]  valid upto array1[4], but normal compiler might not do so, depending on the error level setting and its cleverness. Normal compilers are usually not so clever as Root. Praise Root... But do not get used to it too much.

cout << "Content of array1[8] is: " << pointer_to_array[8] << endl;

Now we have cheated even Root and got a content of memory we have not initialized. Root is not so smart after all. Or we are doing too much magic with the memory.

Note: Valgrind can actually trace this issue, it is even smarter than Root. Keep that name in mind, it can save you from lot of sleepless nights.

cout << "Content of pointer1[3] is: " << pointer1[3] << endl;

4? What the hell? Maybe we have actually hit our own array1. So yes, the code will compile. But now you are really asking for trouble. If you will write to this place, strange things will happen - I mean: http://xkcd.com/371/.

However, we use this useful things too. Would you like a handy byte mask on our integer? Remember, it should be 4 byte (at least on my Root and my machine), but check it out.

cout << "sizeof(int) is:" << sizeof(int) << endl;
cout << "sizeof(char) is:" << sizeof(char) << endl;

Set its value to something big, like 1 167 291 123, and check it did fit:

variable1 = 1167291123;
cout << "variable1 is: " << variable1 << endl;

And now, are we a big-endian or a little-endian machine? Lets find out. Create a char pointer to our variable1:

char *pointer2 = &variable1;

And check (note: (int) means casting character to a number to allow proper printing, decribed more in depth later):

cout << "Slices of variable1 are: ";
for (tmp_variable = 0; tmp_variable < sizeof(int); tmp_variable ++)  cout << (int) (pointer2[tmp_variable]) << ", ";
cout << endl;

Now, we have just sliced our integer variable to a single bytes and printed their content. Number are a bit meaning less because of decimal notation, a little tweak can convert display to binary. This can be very handy if you need to manipulate with a bit stream. But be a good programmer, always comment what you are doing; such pieces of code can be a hell to decipher.

Pointer Arithmetic

Can you type pointer2++;?

Oh yes you can. But what happens? You do not increase the content of memory pointed but the pointer itself. Remember, pointer2 was a char type pointer pointing to the beginning of an int, so now it points to next byte.

Increments or decrements are always done by sizeof(pointer type).

In fact ptr[x] is a mere shortcut for *(ptr + x), so (remember: pointer_to_array = &array1;):

cout << "array1[2] is equal to: " << array1[2] << ", and *(pointer_to_array +2) is equal to: " <<  *(pointer_to_array +2)  << endl; 

Remember: The following assignment operation would be valid: pointer_to_array = array1; that's how close it is.

Keep in Mind: The increase (++) and decrease (--) operators have greater precedence than the de-reference operator (*). But there is a special behavior when they are used as suffix, the expression is evaluated with the value it had before changing. Do not be confused.

So

cout << *pointer2++ << endl;

would do: get pointer2 and increase it by one, and meanwhile print content of pointer2 old target, thus you get an old target value, but pointer is increased.

Of course only an addition and a subtraction with pointers is defined. You can add pointers together, but I cannot see any reasonable purpose for doing so, technically you will probably only add or subtract integers.

Functions and Parameter Passing

By default parameters to functions like this int add (int x, int y); are passed as copies, which results in following properties:

• function cannot change the value of input parameters (safe)
• only data structures which are copyable can be passed
• function cannot return multiple values
• copying is slow

There are two possibilities how to pass a parameter which can be modified:

Passing As Pointer

This is a classical C style: int add (int *x, int *y); function will get a regular pointer, it must be used as a pointer in its body: return = *x + *y; Memory for data objects must be allocated manually, if static variables should be passed, they must be referenced in a function call: result = add (&ax, &ay);.

Passing As Reference

This is a new feature of C++, int add (int &x, int &y); variables are passed as reference. They do not need to be referenced in a function call, result = add (xa, ya); will work, and can be used as a regular variable in function body return = x +y;=.

This is both much easier and safer and thus recommended way, it is fast as well.

Extras

Constant pointers

It is normal pointer. You just cannot change it once it is set, or you cannot change the location it points to, depending on where you put the const keyword, that is all folks.

Changeable pointer to constant int

Lets have:

const int const_integer1 = 42, const_integer2 = 666;
const int *not_so_const_pointer = &const_integer;

will work, and you can even do:

not_so_const_pointer = &const_integer2;

and you can actually do:

const int *const_pointer = &variable1; 

but typing

*const_pointer = 3;

will not work, as compiler assumes that target is a constant.

To summarize: having the const first makes a pointer which can be changed but points to a location which cannot be changed through this pointer. But it says nothing about location itself, keep that in mind, its content can be changed trough some other pointer for example.

Constant pointer to changeable int

int *const const_pointer = &variable1;

and you can:

*const const_pointer = 13;

but cannot:

const_pointer = & const_integer2;

So this pointer points to a defined unchangeble location whose content can be changed. Actually an array1 is internally exactly the same kind of thing.

cout << "variable1 is: " <<  *const_pointer  << endl;
<verbatim>

Try:

<verbatim>
const_pointer = &tmp_variable;
<verbatim>

...and compiler will complain.

*Const pointer to const int*

<verbatim>
const int* const totally_constant_pointer = &const_integer1;
</verbatim>

You cannot change neither pointer target nor the target content. There are ways how to trick it, but that's only asking for trouble.

Why to use all of this const mess? Please look at resource 6, I would attach my signature if that would be printed on a paper. To sumarize &#8211; at a little expense of some extra thinking, you write a code which is less prone to incidnetal errors, easier to debug, and easier to optimize.
Void Pointers
The void type pointer has no type, surprisingly. Void pointers point to a value that has no type (and thus also an undetermined length and undetermined dereference properties). Therefore they cannot be dereferenced without being properly type cast first. On the other hand, they can point to any data type, from an integer value or a float to an object or a string of characters. 
They are useful for input or output values of functions where they provide no limitations on data. On the other hand user must be told what to expect and what to cast to. Using them is like balancing on the edge. It is easy to fall and segfault&#8230; Do not use them unless you have to.
Pointers to pointers
We can have pointers, which point to pointers, pointing to point data (or even to other pointers). In order to do that, we only need to add an asterisk (*) for each level of reference in their declarations

So
int **pointer_to_pointer = & pointer1;
and
cout << "pointer1 points to a content: " <<  *pointer1  << ", and has itself an address: " << &pointer1 << endl;
cout << "pointer_to_pointer points to content: " <<  **pointer_to_pointer << ", pointer_to_pointer points to an address: " <<  *pointer_to_pointer << ", and has itself an address of: " << & pointer_to_pointer << endl;

Quite logical I assume. Why to use it? It might not be so usable directly, but it can be useful if you already have several versions of content referenced by several pointers and you need to pick one and pass it.
Pointers to Functions
Yes, it can be done, you can point to function. The typical use of this is for passing a function as an argument to another function or object &#8211; to an iterator for example.

You declare it like the prototype of the function and enclose the name in parentheses () and add an asterisk.

create a function pointer (note &#8211; no quotes around function name)
int (*function_pointer)(int,int) = sqrt;

call a function in pointer
int result = (*function_pointer)(25);
Dynamic Memory
Operators 
New and Delete
C++ integrates the operators new and delete. Why to use these instead of malloc()?
1.   new is typesafe. malloc() returns a void pointer which needs to be cast, but new returns an object of the specified type.
2.   malloc() only reserves memory, while new also calls a constructor on an object. 

&#8226;   new
&#8226;   delete
&#8226;   new[]
&#8226;   delete[]

Note: Rumors say that there is a version of new called placement new that creates a variable at given address. But I assume that if you are reading this tutorial you are not interested in such eccentric feature. You might use it when programming DMA for devices or that kind of thing.

If a new fails, an exception bad_alloc should be generated. This can by prevented by adding (nothrow) between new and the entity. Older C++ compilers may not accept (nothrow) and will return 0 if new fails.

//int *pointer1;
//char *pointer2;
pointer1 = new (nothrow) int; //you should check if pointer1 is != null
pointer2 = new char[10] ;
*pointer1 = 112;

cout << "Adress pointed by pointer1 is: " << pointer1 << ", and content is: " << pointer1 << endl;

delete pointer1;
delete[] pointer2;

Member access from an object (.)
Accesses a member of struct or class, either function, or variable.

struct item
{
   int weight;
   float price;
} hammer;
hammer.weight = 1;
hammer.price = 35.7;

Member access from a pointer (->)
This is nothing more than a mere shortcut for a notation "(*identifier).", which means: give me a member of an object pointed by the identifier. Because of operator precedence definition, brackets would be required making the notation awkward. But it is the same.




Good Habits
    * Always initialize pointer variables.
    * If you use C strings, never forget to include the terminating '\0' when calculating the storage size.
    * Check that new doesn't generate an exception or return 0.
    * For every new there is an equal and opposite delete()!
    * For arrays you must use the [] for both new and delete. Don't free with delete() something allocated with new()[] and vice versa.
* After you've deleted a pointer, set it to 0.





Useful Notes
sizeof 
An operator integrated in the C++ language that returns the size in bytes of its parameter, constant fo non-dynamic data types.
this
&#8226;   this pointer stores the address of the class instance, to enable pointer access of the members to the member functions of the class.
&#8226;   this pointer is not counted for calculating the size of the object.
&#8226;   this pointers are not accessible for static member functions.
&#8226;   this pointers are not modifiable. 
Casting
Casting means telling the compiler to use a variable like a specific type without regard it its original type. It can be very strong tool, but can lead to pesky problems, especially if you port your code between different machines or architectures.
 




-- FZU.TomasKubes - 29 Jul 2008</verbatim>
<nop>