Introduction To C++ Pointers

• used to access dynamic storage, i.e., objects on the heap
• only one unique_ptr per object
• pointer and target object have same lifetime

• used to access dynamic storage, i.e., objects on the heap
• many shared_ptrs and/or weak_ptrs per object
• target object lives as long as at least one shared_ptr points to it

Address Operator &

char  c = 65;
char* p = &c;

Dereference Operator *

char  c = 65;
char* p = &c;
*p = 88;
char  x = *p;

Member Access Operator ->

struct Coord {
  char x = 0; 
  char y = 0; 
};
Coord a {12,34};
Coord* p = &a;
char v = p->x;  // v = 12
char w = p->y;  // w = 34
// alternative:
char s = (*p).x;  // s = 12
char t = (*p).y;  // t = 34

Declaration Pitfall

int*  p1, p2;    // int*, int
int  *p1, *p2;   // int*, int*

Better & Unambiguous:

int* p1 = …;
int* p2 = …;

#include <iostream>

int main () {
int a = 0;
int b = 0; 
int* p = &a;
*p = 2;
p = &b;
*p = 9;
std::cout << a << '\n';  // 2
std::cout << b << '\n';  // 9
}

• special pointer value
• is implicitly convertible to false
• not necessarily represented by 0 in memory! (depends on platform)

Coding Convention: nullptr signifies value not available

• set pointer to nullptr or valid address on initialization
• check if not nullptr before dereferencing

int* p = nullptr;   // init to nullptr
if (…) {                             
  int i = 5;
  p = &i;  // assign valid address
  …
  // check before dereferencing!
  if (p) *p = 7;  
  …
  // set to nullptr, signalling 'not available'
  p = nullptr;   
}                             
// i's memory is freed, // any pointer to i would be invalidated!

Purposes

1. read-only access to objects
2. preventing pointer redirection

Read it right to left: "(const) pointer to a (const) T"

int i = 5;
int j = 8;
int const* cp = &i;
*cp = 8;   //  COMPILER ERROR: pointed-to value is const
cp = &j;   //  OK
int *const pc = &i;
*pc = 8;   //  OK
pc = &j;   //  COMPILER ERROR: pointer itself is const
int const*const cpc = &i;
*cpc = 8;  //  COMPILER ERROR: pointed-to value is const
cpc = &j;  //  COMPILER ERROR: pointer itself is const

• available inside member functions
• this returns the address of an object itself
• this-> can be used to access members
• *this accesses the object itself

#include <iostream>

class IntRange {
  int l_ = 0;
  int r_ = 0;
public:
  explicit
  IntRange (int l, int r): l_{l}, r_{r} {
    if (l_ > r_) std::swap(l_, r_);
  }
  int left ()  const { return l_; }
  // can also use 'this' to access members:
  int right () const { return this->r_; }
  …
  // returns reference to object itself
  IntRange& shift (int by) {
    l_ += by;
    r_ += by;
    return *this;
  }
  IntRange& widen (int by) {
    l_ -= by;
    r_ += by;
    return *this;
  }
};

int main () {
  IntRange r1 {1,3};

  r1.shift(1);
  std::cout << '[' << r1.left() <<','<< r1.right() << "]\n";

  r1.shift(2).widen(1);  
  std::cout << '[' << r1.left() <<','<< r1.right() << "]\n";
}

IntRange r1 {1,3};
r1.shift(1);
r1.shift(2).widen(1);  // chaining possible!

In order to define a type, the memory sizes of all its members must be known.

This in turn is only possible if the full definition of all members is known.

However, all pointer types have the same size
⇒ we can just declare the existence of Hub, because Device only needs a pointer to it.