Pointers and Addresses in C++

Introduction

• A pointer contais the memory address of a variable.
• The address contains a specific value.
• A variable name directly references value.
• A pointer indirectly references a value.

Declaring Pointers

• int* countPtr, count; declares countPtr to be of type int*, a pointer to an int.
• countPtr is a pointer to an int.
• count is an int, not a pointer to an int.
• The * applies only to countPtr.
• Each variable declared as a pointer must have a preceding *.
• When * appears in a declaration its not an operator and indicates that the variable is a pointer
• Pointers can be declared to point to an object of any data type.

Address & Operator

• The address operator & is a unary operator that obtains the memory address of it's operand
• int y{5}; is how to declare variable y
• int* yPtr = &y; declares a pointer variable and assigns the address of y to yPtr.

Dereferencing

• The unary * operator is commonly referred to as the indirection operator or dereferencing operator.
• It returns an lvalue representing the object to which its pointer operand points.
• If int y{5}; and int* yPtr = &y;, then cout << *yPtr; dereferences the pointer
• The above displays the value of whatever yPtr is pointing to which in this case will print 5.

Null Pointers

• Pointers should be initialized to nullptr (new in C++11) or to a memory address either when they're declared or in an assignment.
• A pointer with the value nullptr "points to nothing" and is known as a null pointer.
• In C++ versions before C++11, the value specified for a null pointer was 0 or NULL.
• NULL is defined in library headers to represent the value 0.

Pass-by-Reference with Pointers

• Three ways to pass arguments to a function
  • Pass-by-value
  • Pass-by-reference with reference arguments
  • Pass-by-reference with pointer arguments
• Pointers can modify multiple variables or pass pointers to large data objects, avoiding overhead.
• Pointers and the indirection operator accomplish pass-by-reference.
• When calling a function with an argument for modification, the address of the argument is passed.

Built-in Arrays

• Arrays specify the type of the elements and the number of elements an array requires with type arrayName[arraySize];
• The compiler reserves the memory.
• arraySize must be an integer constant greater than zero.
• To reserve 12 elements for a built-in array of ints named c, the declaration is int c[12]
• Elements of a built-in array are accessed using the subscript [] operator

Initializing Built-in Arrays

• Array elements initialized using an initializer list like int n[5]{50, 20, 30, 10, 40};
• A built-in array of 5 ints is created and initialized with the specified values.
• With fewer initializers, the remaining elements are value-initialized. numeric types are set to 0, bools to false, pointers to nullptr
• Too many initializers results in a compilation error.
• When a built-in array's size is omitted, the compiler sizes it to the number of elements in the list.
• int n[]{50, 20, 30, 10, 40}; creates a five-element array.

Passing Built-in Arrays to Functions

• The value of a built-in array's name is implicitly convertible to the address of the built-in array's first element.
• arrayName is converted to &arrayName[0]
• Do not take the address & of a built-in array to pass, simply pass the array's name.
• The called funtion can modify all the elements of a built-in array in the caller, unless the function is const.
• Built-in array parameter can be declared in a function header as int sum(const int values[], const size_t numberOfElements)
• The above header can be written as int sum(const int* values, const size_t numberOfElements)

Built-In Array Limitations

• Arrays can not be sorted with relational and equality operators which must loops be compared element by element usingif (a1 < a2); //illegal
• Arrays cannot be assigned as a1 = a2; //illegal
• Arrays do not track their size, functions processing arrays require both the array's name and size as arugments
• Arrays do not have automatic bounds checking. Code must ensure array-access expressions use subscripts within the array's bounds.

Pointer Expressions and Pointer Arithmetic

• Pointers are valid operands in arithmetic, assignment, and comparison expressions.
• C++ enables pointer arithmetic with these operations
  • increment ++
  • decrement --
  • integer added to a pointer + or +=
  • integer subtracted from a pointer - or -=
  • one pointer subtracted from another. This is appropriate only for pointers that point to elements of the same built-in array.

Pointer Expressions and Pointer Arithmetic - Example

• If int v[5] has been declared and the first element is at memory location 3000, and pointer vPtr is initialized to point to v[0], then the value of vPtr is 3000.
• For a machine using four-byte integers:
  • Variable vPtr can be initialized to point to v with int* vPtr{v}; or int* vPtr{&v[0]};
  • When an integer is added to or subtracted from a pointer, the pointer is incremented or decremented by that integer * the size of the memory object to which the pointer refers.
  • vPtr += 2; produces 3008 = from 3000 + 2 * 4
  • In the built-in array v, vPtr now points to v[2].

Some Pointer Properties

• A pointer can be assigned to another pointer if both pointers are of the same type.
• A void* pointer cannot be dereferenced.
• The compiler knows an int* points to four bytes of memory (on a 4-byte machine) and dereferencing it creates an lvalue that is an alias for the int's four bytes.
• A void* simply contains a memory address for an unknown data type.
  • One cannot dereference a void* because the compiler does not know the type or number of bytes.
• Pointers can be compared using equality and relational operators.
  • Comparisons using relational operators are meaningless unless the pointers point to the same built-in array.
  • Pointer comparisons compare the addresses stored in the pointers.

Relationship Between Pointer and Built-in Arrays

• Given int b[5] creates a 5-element int array b, where b is a const pointer, and given that int* bPtr creates an int pointer bPtr, which isn't a const pointer.
• Set bPtr to the address of the first element in the built-in array b with: bPtr = b;
• The above is equivalent to assigning the address of the first element as follows: bPtr = &b[0];

Relationship between Pointer and Built-in Arrays: Array Elements

• Built-in array element b[3] can alternatively be referenced with the pointer expression *(bPtr + 3)
  • The 3 is the offset to the pointer.
  • The parentheses are necessary because the precedence of * is higher than that of +.
• Just as the built-in array element can be referenced with a pointer expression, the address &b[3] can be written with the pointer expression bPtr + 3.
• The built-in array name can be treated as a pointer and used in pointer arithmetic.
  • The expression *(b + 3) refers to the element b[3].
• All subscripted built-in array expressions can be written with a pointer and an offset.
• Pointers can be subscripted exactly as built-in arrays.
  • The expression bPtr[1] refers to b[1].

Pointer Based Strings

• A string is a series of characters treated as a single unit including letters, digits and special characters such as +, -, *, / and $.
• A pointer-based string is a built-in array of characters ending with a null character \0.
• Access a string via a pointer to its first character.
• String literals may initialize built-in char arrays or const char* variables.
• The built-in array of chars containing a string needs enough space for the string and its null terminator.
• It is better use to strings from <string> than pointer-based strings.

Pointers vs References

• References requires one step initialization.

int a{10}, b{20};
int *p;
p=&a;
int &r; // this is incorrect should declare and initialize reference at same step
r= a; // this is incorrect should declare and initialize reference at same step int &r=a

• Pointers can be declared and initialized to Null, but a reference cannot
• Memory distinctions:
• Pointers have their own memory address and size in memory
• References share the memory address of its object

Cout<<&a<<" "<<&p<<" "<<&r<<endl; // a and r have the same address but p has a distinct address

Pointers vs References (contd)

• Reassignment differences

p=&b; // this is allowed for pointers
r=b // reassignment not allowed with references

• Multiple indirection levels
  • Pointers can can be a pointer to pointer (Int **pp=&p; // ok)
  • References will give an error when using multiple levels (Int &&rr=&r; // this will give an error)
• Pointers have pointer arithmetic which allow you to work with arrays or data structures like linked lists. There is no such thing as reference arithmetic

Other Applications of Pointers

• Dynamic Memory Allocation using Heap memory
  • Pointers allocate memory dynamically during runtime usingnew and delete.
• Example

int* arr = new int[5]; // Allocates an array of size 5 on the heap 
// Assign values
for (int i = 0; i < 5; i++) { 
    arr[i] = i * 10;
}
// Free memory to avoid memory leaks 
delete[] arr;

• Pointers to Functons allow flexible functions

#include <iostream>
using namespace std;

void hello() { cout << "Hello, World!\n"; }
void bye() { cout << "Goodbye!\n"; }

void execute(void (*func)()) { func(); } // Function pointer

int main() {
    execute(hello); // Calls hello()
    execute(bye);   // Calls bye()
}

• Dynamic data structures use linked lists, trees, and graphs

struct Node {
    int data;
    Node* next; // Pointer to the next node 
};

Passing 1D array to functions

• Unsized array + size

void printarray(int a[],int size) // signature
printarray(a,size) // Passing array to function

• As pointer + size

void printarray(int* a, int size)
printarray(a,size)

• As reference

void printarray(int (&a) [size], int size)
printarray(a,size)

Passing 2D array to functions

• Array + size

void printarray(int a[] [10],int r, int c)
printarray(a,r,c); // Passing array to function

• pointer to array + size:

void printarray(int (*a) [10],int r, int c) // 10 is number of columns
printarray(a,r,c); // Passing array to function

• reference to array + size:

void printarray(int (&a) [10],int r, int c) // 10 is number of columns
printarray(a,r,c); // Passing array to function