To declare a pointer in C++, use the indirection operator (*) before the identifier:
data_type *pointer_name; int *i; /* pointer to an int */
To initialize the pointer in C++, you have to use the reference operator (&). Here's how you can declare and automatically initialize a pointer in C++:
int n = 20; int *i = &n; /* point to "n" */
If you want, you can initialize a pointer to point to nothing. In Delphi, you would use nil for this, but in C++, you use the NULL constant (since C++ is case sensitive, always write NULL):
int *p = NULL;
You use pointers in C++ the same way as in Delphi. To access the pointer's address, use the pointer name without additional operators, and to access the value to which it points, write the indirection operator (*) before the pointer's name (see Listing 9-7).
Listing 9-7: Pointer basics
#include <iostream.h> #include <conio.h> #pragma hdrstop #pragma argsused int main(int argc, char* argv[]) { int n = 20; int *i = &n; /* point to "n" */ cout << i << endl; // display the pointer's address cout << *i << endl; // display the value of the n variable getch(); return 0; }
Pointers of type void are the C++ equivalent of Delphi's Pointer type, which means that a void pointer is untyped and can be used to point to a variable of any data type. The void pointer in C++ has the same "limitation" the Pointer type in Delphi has: To access the value to which it points, you must first type- cast it to a typed pointer type and dereference it. To do this, use the following syntax:
*(typed_pointer)void_pointer_name
Listing 9-8 illustrates how to work with void pointers.
Listing 9-8: Void pointers
#include <iostream.h> #include <conio.h> #pragma hdrstop #pragma argsused int main(int argc, char* argv[]) { int n = 20; char c = 'A'; float f = 1.45; void *ptr = &n; // declare the pointer and point it to "n" cout << *(int *)ptr << endl; ptr = &c; // point to the "c" variable" cout << *(char *)ptr << endl; // display A ptr = &f; // point to "f" cout << *(float *)ptr << endl; getch(); return 0; }
To access an array through a pointer, you need to make the pointer point to an element in the array, usually the first one. To get the address of the first element in an array, simply assign the array's name to the pointer:
pointer = array;
To move to another element in an array, use the ++ or -- operators:
pointer++; // move to the next element
The following listing illustrates how to access array elements through a pointer.
Listing 9-9: Accessing array elements through a pointer
#include <iostream.h> #include <conio.h> #pragma hdrstop #pragma argsused int main(int argc, char* argv[]) { int arr[5] = {1, 2, 3, 4, 5}; int *p; p = arr; // point to the first element in the array cout << *p << endl; p = &arr[0]; // this is the same as p = arr; cout << *p << endl; p++; // move to the 2nd element cout << *p << endl; p +=2; // move to the 4th element cout << *p << endl; getch(); return 0; }
When you declare a pointer to a structure, you can no longer access the fields using the simple dot syntax (the direct member selector). To access fields in a structure pointed to by a pointer, you have to write this:
(*pointer_name).field_name
Although you can use the above syntax to access fields in pointers to structures, it is much better to use the indirect member selector, or the -> operator, because it is used in object-oriented programming to access object fields:
pointer_name->field_name
The following listing shows how to access fields in a structure through a pointer. The example illustrates both ways of accessing fields indirectly.
Listing 9-10: Accessing structure fields through a pointer
#include <iostream.h> #include <conio.h> #include <string.h> #pragma hdrstop struct TBook { char Title[50]; int PageCount; char Authors[4][40]; }; #pragma argsused int main(int argc, char* argv[]) { TBook book; TBook* bookPtr = &book; // access the book structure through the pointer strcpy((*bookPtr).Title, "The ANSI C Programming Language"); // display data by accessing the book structure directly cout << "Title: " << book.Title << endl; strcpy(bookPtr->Authors[0], "Brian W. Kernighan"); cout <<"Author: " << book.Authors[0] << endl; strcpy(bookPtr->Authors[1], "Dennis M. Ritchie"); cout <<"Author: " << book.Authors[1] << endl; (*bookPtr).PageCount = 238; cout << "Page Count: " << book.PageCount << endl; getch(); return 0; }
You create and use dynamic variables the same way in Delphi and C++; the only difference lies in syntax.
To create a new dynamic variable in C++, you need to declare a pointer and allocate it on the heap using the new operator:
data_type *pointer_name = new data_type; int *p = new int;
You can also automatically initialize a dynamic variable by including a pair of parentheses containing the initial value of the variable:
data_type *pointer_name = new data_type(initial_value); int *p = new int(1001);
When you're done with the dynamic variable, you must release it from memory if you don't want to leak memory. To remove a dynamic variable from memory, use the delete operator:
delete pointer_name; delete p;
The short example in Listing 9-11 illustrates how to use a dynamic variable.
Listing 9-11: Dynamic variables in C++
#include <iostream.h> #include <conio.h> #pragma hdrstop #pragma argsused int main(int argc, char* argv[]) { int *p = new int(1001); // create & initialize the dynamic var cout << *p << endl; // use the variable delete p; // remove the var from memory getch(); return 0; }
The new operator is used to create both dynamic variables and dynamic arrays. When you want to create a dynamic array, use the following syntax:
data_type *array_name = new data_type[num_of_elements];
Removing a dynamic variable and a dynamic array from memory is done using the delete operator. The only difference is that when you want to delete an array, you have to use the delete [] syntax:
int *dyn_var = new int; int *dyn_array = new int[20]; delete dyn_var; // delete one variable delete [] dyn_array; // delete an entire array
Now that you know more about pointers, you can start declaring strings using the following syntax:
char * string_name;
The difference between char[] and char* is that a char[] string is stored on the stack and the char* string is stored in the heap. Actually, the char* pointer (4 bytes) is stored on the stack and the string's data is stored on the heap.