C++ Pointers

CIS-60 Home: http://www.c-jump.com/CIS60/CIS60syllabus.htm

C++ Pointers

Properties of a C++ variable
Address of a C++ variable
Storing address of a variable
Pointer to a C++ variable
Pointer "vocalization"
Pointer is a also variable
Why use pointers?
Pointer dereference *ptr
Pointer syntax
Pointer summary
String literal
Pointer to character string
Pointer as function argument
Pointers and arrays
Arrays of pointers
Arrays of pointers example
Command-line arguments
Implementing swap( ) function

1. Properties of a C++ variable

Consider:


int main( )
{
    // Local variables:
    int x = 5;
    double d = 0.1;

    // Variable sizes:
    int x_bytes = sizeof( x );
    int d_bytes = sizeof( d );

    // What about variable addresses ?
    int x_addr = addressof( x );
    int d_addr = addressof( d );

    return 0;
}

Note: this sample will not yet compile because of the addressof.

What do we know about x and d?
- Types are int and double
- Operator sizeof returns sizes in bytes
- How about an address of a variable?

2. Address of a C++ variable

The ampersand operator & returns address of the variable:


#include <iostream>
using namespace std;
int main( )
{
    int x = 5;
    double d = 0.1;

    // Taking variable addresses:
    cout << &x << '\n';
    cout << &d << '\n';

    return 0;
}

/* Program might print something like this:
0012FF2C
0012FF1C
*/

expression &x returns address of x
expression &d returns address of d
In C++, taking address of a variable is so common, that a separate punctuation syntax was dedicated to this operation!

3. Storing address of a variable

Could we store an addresses of variables in our program?


int main( )
{
    int x = 5;
    double d = 0.1;

    // Variable sizes:
    int x_bytes = sizeof( x );
    int d_bytes = sizeof( d );

    // Take and store variable addresses:
    int x_addr = &x;
    int d_addr = &d;

    return 0;
}

But why the code does not compile?..
- ...because an address needs a special type of storage!

4. Pointer to a C++ variable

Solution:


int main( )
{
    int x = 5;
    double d = 0.1;

    // Variable sizes:
    int x_bytes = sizeof( x );
    int d_bytes = sizeof( d );

    // We need pointers to store addresses:
    int* x_ptr = &x;
    double* d_ptr = &d;

    return 0;
}

Simply taking an address of a variable would be meaningless!
In addition to address, we must recognize the object type.
Therefore, we need a special variable to accommodate both type and address.
Declaration statement
```
    int* x_ptr = &x;
```
instantiates a pointer variable named x_ptr, initialized by the address of variable x.

5. Pointer "vocalization"

How could this be pronounced in plain English?
```
    int* ptr;
```
The pointer declaration int* ptr; can be vocalized backwards:
- ptr; "ptr is..."
- * "...a pointer to..."
- int "...an integer."

6. Pointer is a also variable


    int main( )
    {
        int x = 1;  // x is an integer
        int y = 2;  // y is another integer
        int* ptr;   // ptr is a pointer to integer
        ptr = &x;   // store the address of x in ptr
        ptr = &y;   // store the address of y in ptr
        return 0;
    }

7. Why use pointers?

The pointers provide indirect access to our variables. For example,


    int main( )
    {
        // Local variables:
        int x = 5;
        double d = 0.1;

        // We need pointers to store addresses:
        int* x_ptr = &x;
        double* d_ptr = &d;

        // Use pointers to modify variables:
        *x_ptr = 10;  // same as x = 10;
        *d_ptr = 0.2; // same as d = 0.2;

        return 0;
    }

But what is the asterisk * doing in front of the pointer???

8. Pointer dereference *ptr

Dereference operator,

*ptr

provides access to the variable pointed by the address:


  x = *ptr; // fetch the value at the address specified by ptr
  *ptr = 5; // store new value at the address specified by ptr

9. Pointer syntax


int main( )
{
    int x = 1;
    int* ptr;   // (1) ptr is a pointer to an integer
    ptr = &x;   // (2) store address of x in ptr
    *ptr = 100; // (3) store new value at the address pointed by ptr
    return 0;
}

Here, the asterisk * is a type modifier, not a dereference.
Ampersand & operator returns an address of a variable: ptr = &x;
Finally, an asterisk *ptr dereferences the pointer, providing access to the variable in memory:
- *ptr = 100;
Dereference operator *ptr is also known as indirection operator.

10. Pointer summary

An address &x tells where the variable is located in memory.
Pointer points to a variable by remembering its address:
- ptr = &x;
Pointers are variables and must be declared:
```
    double* d_ptr;
```
Here, asterisk * identifies d_ptr as a pointer variable.
The phrase "variable pointed to by pointer ptr" is translated into C++ as
- *ptr
where * is the dereference operator.

11. String literal

Consider
```
    std::cout << "HELLO";
```
Literal "HELLO" is stored in memory as a sequence of bytes:

String literals are said to be zero-terminated: the sequence is terminated by null character '\0'.

Programs can easily find the end of the string by looking for '\0'.

12. Pointer to character string

String literal returns back the address of the first character in memory:

Address
00476FEC:	H	E	L	L	O	\0

A pointer can be assigned to keep the address of the character string:
```
    char* phello = "HELLO";
```
Pointer variable phello stores physical address of the first character in the string, which is 'H' in our example.

13. Pointer as function argument


#include <iostream>
using namespace std;

void print( char* message )
{
    cout << message << '\n';
}

int main( )
{
    char* phello = "Hello";
    print( phello );
    print( "World" );
    return 0;
};

/* Program output:
Hello
World
*/

14. Pointers and arrays

Pointers and arrays are closely related. For example,


   char* ptr = "hello";  // pointer
   char arr[] = "hello"; // array

Null character is also included in the array, so sizeof(arr) returns 6:

arr[0]	arr[1]	arr[2]	arr[3]	arr[4]	arr[5]
H	E	L	L	O	\0

15. Arrays of pointers

Construction of the arrays of pointers is also allowed.
Most frequent use of arrays of pointers is to store character strings of variable lengths:
```
   char* months[] = { "Illegal", "Jan", "Feb", "Mar" };
```

months[ 0 ] = 00476FEC :	I	l	l	e	g	a	l	\0
months[ 1 ] = 00476FF4 :	J	a	n	\0
months[ 2 ] = 00476FF8 :	F	e	b	\0
months[ 3 ] = 00476FFC :	M	a	r	\0

16. Arrays of pointers example


#include <iostream>
using namespace std;
int main( )
{
    char* months[] = { "Illegal", "Jan", "Feb", "Mar" };

    // Each array element keeps address of a character string:
    cout << months[ 0 ] << '\n';
    cout << months[ 1 ] << '\n';
    cout << months[ 2 ] << '\n';
    cout << months[ 3 ] << '\n';

    return 0;
}

/* Program output:
Illegal
Jan
Feb
Mar
*/

17. Command-line arguments

A program gains access to its command-line arguments as follows:


#include <iostream>
using namespace std;

int main( int argc, char* argv[] )
{
    int idx;
    for ( idx = 1; i < argc; ++idx ) {
        cout << argv[ idx ] << '\n';
    }
    return 0;
}

Note that the loop begins at index 1, thus skipping the name of the program.

argc is the argument counter
argv[ ] is the array of pointers to strings

If command line was

    C:\>prog Hello World

then argc is set to 3, and argv is organized like this:

argv[0]	p	r	o	g	\0
argv[1]	H	e	l	l	o	\0
argv[2]	W	o	r	l	d	\0
argv[3]	NULL

18. Implementing swap( ) function

swap( ) is a function that swaps values of two integer variables:


    void swap( int* px, int* py )
    {
        int temp = *px;
        *px = *py;
        *py = temp;
    }

    int main( )
    {
        int x = 5;
        int y = 10;
        swap( x, y );   // Error: must take address
        swap( &x, &y ); // Correct
        return 0;
    }