Background, Introduction and What You Should Never Do.

• I am starting on page 49 of the book.
• We can get to two types of memory:
  • The stack is where "declared" variables are allocated space.
  • The Free Store or heap is where we can allocate memory.
  • Actually, constants and static variables are most likely declared in another location, but ...
• Each of these actions sets aside memory on the stack and associates an identifier with it.

  int x;
  float pi{3.14};
  char word[10];
      

• We can actually start to play with pointers here.
• Adding a * to the declaration will result in a pointer data type, not a basic data type.

  • // not initialized, definitely don't do.
    int * iPtr;   // a pointer to an int, or an array of ints.
    BodyPartT * parts;  // a pointer to a BodyPartT or an arry of them;
    FooT * fooPtr; 
         

  • We generally want to initialize any pointer to be nullptr
    0, NULL and nullptr
    • All eventually become 0.
    • 0 is from the bad old c days.
    • NULL is from c, probably a defined constant.
    • nullptr is the modern, accepted version.

    • int * iPtr = nullptr;   // a pointer to an int, or an array of ints.
      BodyPartT * parts{nullptr};  // a pointer to a BodyPartT or an arry of them;
      FooT * fooPtr{nullptr}; 
           

    • NEVER DEREFERENCE 0, NULL or nullptr
    • For any variable, &identifier returns a pointer to that variable.
    • For any pointer, *ptr dereferences or follows the pointer.
      • NEVER DEREFERENCE 0, NULL or nullptr
    • Take a look at the first part of simple.cpp
    • Arrays and Pointers, The same or different?
      • An array variable is probably a pointer deep down inside.

      •  
        // this is not real, but ...
        assume T ary[n];
        
        T operator [] (T *  base_address; size_t index) {
            return T + size_of(*T) * index
        }

      • If you don't know the size_of()operator, you should check it out.
    • Passing pointers to functions
      • The type is type * & parameter
      • See the last of
    • Const
      • const int * ptr makes a pointer to a constant int.
        • You can change what the pointer value
        • But you can not change the value it points to.
      • Same for int const * ptr
      • int * const ptr makes the pointer constant.