Introduction to Pointers and Dynamic Memory

• You will not produce pointer code this semester.
  • But you are responsible for the knowledge on the test.
  • And I expect you to know about them next fall in 330.
• We will be learning about raw pointers.
• There are better ways to deal with memory than raw pointers.
  • C++ has what are called smart pointers.
  • But we need to understand raw pointers first.
• Up until now we have been dealing with memory allocated at compile time.

  • int main() {
        WordT words[10];
        int wordCount;
        ...
    }

  • The memory for the array, the int and so on are placed on the runtime stack.
  • Function calls allocate memory at run time, but it is of known size.
    • The size of the variables and parameters for the function.
• We will now learn how we can allocate memory at run time.
  • This will allow us to declare the size of an array at run time.
  • Or to build any number of other data structures.
• We need a new basic type, the pointer.
  • These are introduced in section 10.7, page 490
• A pointer is a simple data type consisting of an unbound set of values, each of which addresses or otherwise indicates the location of a variable of a given type.
  • Pointers point to memory.
  • Or they contain a memory address.
• Up to now, you have been using direct addressing
  • You access the variable directly through the identifier
• Pointers use indirect addressing
  • You follow the pointer to get to the memory.
• Pointer syntax
  • nullptr
    • nullptr is a special value
    • It means this pointer points to nothing.
    • It is very common to initialize pointers to nullptr.
    • Older versions include NULL and 0
    • But use nullptr.
  • Declaration

    • type * identifier;
      type * identifier, * identifier, ...;  

    • Note the * is associated with the identifier.

    • int * intPtr{nullptr};
      WordT * wordPtr = nullptr;
             

    • 
  • Dereference
    • This means follow the pointer.
    • * for pointers to basic data types.
    • -> for pointers to structures or classes
    • [index] for arrays

    • int * intPtr = nullptr;
      WordT * wordPtr{nullptr};
      float * floatAry{nullptr};
      
      // assume memory has been set up.
      *intPtr = 8;
      cout << *intPtr;
      
      wordPtr->Word("hello");
      cout << wordPtr->Count();
      
      // assuming there are at least 8 elements in floatAry
      floatAry[7] = 3.14;
                 

    • Assignment
      • The & operator will give us the address of a variable.

      • int a;
        int * intPtr  = & a; 

      • This code makes intPtr point at a.
        • a and *intPtr are the same thing.
        • Changing either changes both.
        • But intPtr is not.

        • int a;
          int * intPtr = & a;
          
          a = 7;
          *intPtr = 22;
          cout << a << " " << *intPtr << endl;
                               

      • Direct pointer assignment is ok
        • But remember, it copies the pointer, not the data.
    • Pointers can be passed by value or reference.
      • The syntax for pass by reference is

      • void MyFunc(ptrType * & parameter);
                       

      • But pass by reference is not really that important.
    • Other operations are not what you think.
      • I/O
      • Math
      • Comparison
• See simplePonter.cpp