TOPIC 10.1.1
Pointers

Intializing Pointers

• Declare pointers before use, as with other variables.
• Each variable being declared as a pointer must be preceded by an asterisk (*).
• Initialize pointers before use to a 0, NULL or an address to prevent unexpected results.
• Example:

  int *countPtr;          // Pointer declaration

• Example:

  // A pointer as a parameter
  

  #include 
  
  void f(int *);		// This function has a pointer as a parameter
  
  main()
  {
     int y;
  
     f(&y);		// Pass an address into the function
     return 0;
  }
  
  void f(int *xPtr))	// xPtr will hold the address of y
  {
     *xPtr = 100;
  }
  

Pointer Operators

• & is the address operator which returns the address of its operand
• * is the indirection operator or dereferencing operator and returns the value to which the operand (pointer) points.
• sizeof - used to determine the size of an array during program compiliation
• Example:

  // Attempting to modify data through a
  // non-constant pointer to constant data.
  #include 
  
  void f(const int *);
  
  main()
  {
     int y;
  
     f(&y);     // f attempts illegal modification
  
     return 0;
  }
  
  // In f, xPtr is a pointer to an integer constant
  void f(const int *xPtr)
  {
     *xPtr = 100;  // cannot modify a const object
  }
  

Passing pointers to functions

4 Methods:

1. Non constant pointer to non constant data

• Data and pointer can both be modified
• Example:

  // Non-constant pointer to non-constant data
  #include 
  
  void f(int *);		// This function has a pointer as a parameter
  
  main()
  {
     int y;
  
     f(&y);		// Pass an address into the function
     return 0;
  }
  
  void f(int *xPtr))	// xPtr will hold the address of y
  {
     *xPtr = 100;
  }
  

2. Non constant pointer to constant data

• Pointer can be modified to point to other data.
• Data connot change.
• Example:

  // Attempting to modify data through a
  // non-constant pointer to constant data.
  #include 
  
  void f(const int *);
  
  main()
  {
     int y;
  
     f(&y);     // f attempts illegal modification
  
     return 0;
  }
  
  // In f, xPtr is a pointer to an integer constant
  void f(const int *xPtr)
  {
     *xPtr = 100;  // cannot modify a const object
  }
  

3. Constant pointer to non constant data (the default for an array)

• Pointer cannot be modified.
• Data to which pointer points can be modified.
• Example:

  // Attempting to modify a constant pointer to
  // non-constant data
  #include 
  
  main()
  {
     int x, y;
  
     int * const ptr = &x;  // ptr is a constant pointer to an 
                            // integer. An integer can be modified
                            // through ptr, but ptr always points 
                            // to the same memory location.
     *ptr = 7;
     ptr = &y;	// illegal modification of a constant pointer
  
     return 0;
  }
  

4. Constant pointer to constant data

• No modifications.
• An array passed using array subscript is an example.
• Example:

  // Attempting to modify a constant pointer to
  // constant data.
  #include 
  
  main()
  {
     int x = 5, y;
  
     const int *const ptr = &x;  // ptr is a constant pointer to a 
                                 // constant integer. ptr always 
                                 // points to the same location and
                                 // the integer at that location
                                 // cannot be modified.
     cout << *ptr << endl;
     *ptr = 7;		// illegal modification of a constant integer
     ptr = &y;		// illegal modification of a constant pointer
  
     return 0;
  }
  

Relationship between Pointer and Arrays

int b[5] = {1,2,3}, *bPtr;

bPtr = b;

• b[3] is the same as *(bPtr + 3) (Pointer offset notation which refers to memory locations).
• NOTE:  *bPtr + 3 (with no parenthesis) woudl add 3 to the value at b[0].

Arrays of Pointers

• Arrays may contain pointers.
• A data structure commonly used to form an array of strings is a string array.
• Each entry in the array is a pointer to the first character in a string.
• Each string stores the number of characters plus the null character.
• The array is still fixed in size but the use of pointers allows access to strings of varying lengths.
• Example:

  char *employee_lastname[100] = {"Webb", Smith", "Zhang", "Lo", "Pena"}

Function Pointers

• A pointer can point to a function.
• Functions are strored in contiguous memory locations.
• A pointer to a function contains the address of the first element of the function.
• Pointers to functions can be passed to functions.
• Pointers fo functions can be returned from functions.
• Pointer to functions can be stored in arrays.
• Pointers to functions can be assigned to other function pointers.
• Example:

  // Function pointers
  #include 
  
  main ()
  {
     void (*f[3])(int) = {f1, f2, f3};
     
     *f[0];  //calls f1
     *f[1];  //calls f2
     *f[2];  //calls f3
  
     return 0;
  }
  
  void f1()
  {
     return;
  }
  
  void f2()
  {
     return;
  }
  
  void f3()
  {
     return;
  }