E-Sources Informatics

1	andy = 25;
2	fred = andy;

3	ted = &andy;

andy = 25; ted = &andy;   Right after these two statements, all of the following expressions would give true as result: 1 andy == 25 &andy == 1776 ted == 1776 *ted == 25

The first expression is quite clear considering that the assignment operation performed on andy was andy=25. The second one uses the reference operator (&), which returns the address of variable andy, which we assumed it to have a value of 1776. The third one is somewhat obvious since the second expression was true and the assignment operation performed on ted was ted=&andy. The fourth expression uses the dereference operator (*) that, as we have just seen, can be read as “value pointed by”, and the value pointed by ted is indeed 25.
So, after all that, you may also infer that for as long as the address pointed by ted remains unchanged the following expression will also be true:
*ted == andy
Declaring variables of pointer types
Due to the ability of a pointer to directly refer to the value that it points to, it becomes necessary to specify in its declaration which data type a pointer is going point to. It is not the same thing to point to a char than to point to an int or a float.
The declaration of pointers follows this format:
type * name;
where type is the data type of the value that the pointer is intended to point to. This type is not the type of the pointer itself! but the type of the data the pointer points to. For example:
1 int * number;
2 char * character;
3 float * greatnumber;
These are three declarations of pointers. Each one is intended to point to a different data type, but in fact all of them are pointers and all of them will occupy the same amount of space in memory (the size in memory of a pointer depends on the platform where the code is going to run). Nevertheless, the data to which they point to do not occupy the same amount of space nor are of the same type: the first one points to an int, the second one to a char and the last one to a float. Therefore, although these three example variables are all of them pointers which occupy the same size in memory, they are said to have different types: int*, char* and float* respectively, depending on the type they point to.
I want to emphasize that the asterisk sign (*) that we use when declaring a pointer only means that it is a pointer (it is part of its type compound specifier), and should not be confused with the dereference operator that we have seen a bit earlier, but which is also written with an asterisk (*). They are simply two different things represented with the same sign.

Now have a look at this code:

01	// my first pointer
02	#include <iostream>

03	using namespace std;
04

05	int main ()
06	{

07	int firstvalue, secondvalue;
08	int * mypointer;

09
10	mypointer = &firstvalue;

11	*mypointer = 10;
12	mypointer = &secondvalue;

13	*mypointer = 20;
14	cout << "firstvalue is " << firstvalue << endl;

15	cout << "secondvalue is " << secondvalue << endl;
16	return 0;

17

}

 

// more pointers #include <iostream> using namespace std;   int main () {   int firstvalue = 5, secondvalue = 15;   int * p1, * p2;     p1 = &firstvalue;  // p1 = address of firstvalue   p2 = &secondvalue; // p2 = address of secondvalue   *p1 = 10;          // value pointed by p1 = 10   *p2 = *p1;         // value pointed by p2 = value pointed by p1   p1 = p2;           // p1 = p2 (value of pointer is copied)   *p1 = 20;          // value pointed by p1 = 20     cout << "firstvalue is " << firstvalue << endl;   cout << "secondvalue is " << secondvalue << endl;   return 0; }

firstvalue is 10
secondvalue is 20
I have included as a comment on each line how the code can be read: ampersand (&) as “address of” and asterisk (*) as “value pointed by”.
Notice that there are expressions with pointers p1 and p2, both with and without dereference operator (*). The meaning of an expression using the dereference operator (*) is very different from one that does not: When this operator precedes the pointer name, the expression refers to the value being pointed, while when a pointer name appears without this operator, it refers to the value of the pointer itself (i.e. the address of what the pointer is pointing to).
Another thing that may call your attention is the line:
int * p1, * p2;
This declares the two pointers used in the previous example. But notice that there is an asterisk (*) for each pointer, in order for both to have type int* (pointer to int).
Otherwise, the type for the second variable declared in that line would have been int (and not int*) because of precedence relationships. If we had written:

int * p1, p2;   p1 would indeed have int* type, but p2 would have type int (spaces do not matter at all for this purpose). This is due to operator precedence rules. But anyway, simply remembering that you have to put one asterisk per pointer is enough for most pointer users.   Pointers and arrays The concept of array is very much bound to the one of pointer. In fact, the identifier of an array is equivalent to the address of its first element, as a pointer is equivalent to the address of the first element that it points to, so in fact they are the same concept. For example, supposing these two declarations: 1 int numbers [20]; int * p;   The following assignment operation would be valid:   p = numbers;   After that, p and numbers would be equivalent and would have the same properties. The only difference is that we could change the value of pointer p by another one, whereas numbers will always point to the first of the 20 elements of type int with which it was defined. Therefore, unlike p, which is an ordinary pointer, numbers is an array, and an array can be considered a constant pointer. Therefore, the following allocation would not be valid:   numbers = p;   Because numbers is an array, so it operates as a constant pointer, and we cannot assign values to constants.   Due to the characteristics of variables, all expressions that include pointers in the following example are perfectly valid: 1 // more pointers #include <iostream> using namespace std;   int main () {   int numbers[5];   int * p;   p = numbers;  *p = 10;   p++;  *p = 20;   p = &numbers[2];  *p = 30;   p = numbers + 3;  *p = 40;   p = numbers;  *(p+4) = 50;   for (int n=0; n<5; n++)     cout << numbers[n] << ", ";   return 0; }

10, 20, 30, 40, 50,
In the chapter about arrays we used brackets ([]) several times in order to specify the index of an element of the array to which we wanted to refer. Well, these bracket sign operators [] are also a dereference operator known as offset operator. They dereference the variable they follow just as * does, but they also add the number between brackets to the address being dereferenced. For example:

a[5] = 0;       // a [offset of 5] = 0 *(a+5) = 0;     // pointed by (a+5) = 0   These two expressions are equivalent and valid both if a is a pointer or if a is an array. Pointer initialization When declaring pointers we may want to explicitly specify which variable we want them to point to: 1 int number; int *tommy = &number;   The behavior of this code is equivalent to: 1 int number; int *tommy; tommy = &number;   When a pointer initialization takes place we are always assigning the reference value to where the pointer points (tommy), never the value being pointed (*tommy). You must consider that at the moment of declaring a pointer, the asterisk (*) indicates only that it is a pointer, it is not the dereference operator (although both use the same sign: *). Remember, they are two different functions of one sign. Thus, we must take care not to confuse the previous code with: 1 int number; int *tommy; *tommy = &number;

that is incorrect, and anyway would not have much sense in this case if you think about it.
As in the case of arrays, the compiler allows the special case that we want to initialize the content at which the pointer points with constants at the same moment the pointer is declared:

char * terry = "hello";   In this case, memory space is reserved to contain "hello" and then a pointer to the first character of this memory block is assigned to terry. If we imagine that "hello" is stored at the memory locations that start at addresses 1702, we can represent the previous declaration as:   It is important to indicate that terry contains the value 1702, and not 'h' nor "hello", although 1702 indeed is the address of both of these.   The pointer terry points to a sequence of characters and can be read as if it was an array (remember that an array is just like a constant pointer). For example, we can access the fifth element of the array with any of these two expression: 1 *(terry+4) terry[4]

1	char *mychar;
2	short *myshort;

3	long *mylong;

1	mychar++;
2	myshort++;

3

mylong++;

1	mychar = mychar + 1;
2	myshort = myshort + 1;

3	mylong = mylong + 1;

1

*p++

1

(*p)++

1	If we write:
2

3	*p++ = *q++;

1	*p = *q;
2	++p;

3

++q;

1	char a;
2	char * b;

3	char ** c;
4	a = 'z';

5	b = &a;
6	c = &b;

1	c has type char** and a value of 8092
2	*c has type char* and a value of 7230

3	**c has type char and a value of 'z'

// increaser #include <iostream> using namespace std;   void increase (void* data, int psize) {   if ( psize == sizeof(char) )   { char* pchar; pchar=(char*)data; ++(*pchar); }   else if (psize == sizeof(int) )   { int* pint; pint=(int*)data; ++(*pint); } }   int main () {   char a = 'x';   int b = 1602;   increase (&a,sizeof(a));   increase (&b,sizeof(b));   cout << a << ", " << b << endl;   return 0; }

1	int * p;
2	p = 0;     // p has a null pointer value

// pointer to functions #include <iostream> using namespace std;   int addition (int a, int b) { return (a+b); }   int subtraction (int a, int b) { return (a-b); }   int operation (int x, int y, int (*functocall)(int,int)) {   int g;   g = (*functocall)(x,y);   return (g); }   int main () {   int m,n;   int (*minus)(int,int) = subtraction;     m = operation (7, 5, addition);   n = operation (20, m, minus);   cout <<n;   return 0; }

In the example, minus is a pointer to a function that has two parameters of type int. It is immediately assigned to point to the function subtraction, all in a single line:
int (* minus)(int,int) = subtraction;