References

• There are several discussions of references in chapter 9
• But they are not fully discussed until chapter 11.
  • I would like to discuss this next.
  • This starts on page 334.
• Gregorie states that references are used extensively in programming
• A reference is an alias for another variable.
  • Just think of reference parameters.
  • When we change a reference parameter you change the argument at which it is pointing.
• He offers two views
  • Just a nickname and don't think any deeper.
  • A fancy automatic pointer.
    • On first assignment, the pointer is copied.
    • After that the pointer is dereferenced.
• You can use references for more than parameters.
• Reference Variables
  • Just declare type & identifier = identifier;
  • The assignment is important.
• Consider simpleRef.cpp
• Just like parameters, we can have a const ref variable
  • const & int sevenRef = 7
  • This is the only way we can assign a literal to a reference.
  • This would, in my opinion be silly.
• You can not change the variable pointed to by a ref.
• Pointers and references

  • int * foo //is a pointer
    int * & fooRef //is a reference to an int pointer.  

  • 
  • We can also do

  • int x
    int & xRef = x;
    int * xPtr = & xRef; 

  • The last one is a bit confusing to me.
    • They do something a little unexpected.
    • You would expect xPtr to point to xRef.
    • But the semantics say that it points ot x.
    • 
  • Consider ptrRef.cpp
• He provides two scenarios relating to

  • void Swap (int & a, int  & b) {
        int tmp;
        tmp = a;
        a = b;
        b  = tmp;
    } 

  • He points out that Swap(3, 4) will not compile, why?
  • What would the following do?

  • int * ptr1;
    int * ptr2;
    ....
    Swap(ptr1, ptr2);

  • How about this

  • Swap(*ptr1, *ptr2);

• He argues strongly for passing everything but basic types as a pass by reference.
  • Speed.
  • Correctness
    • Some items might not have copy constructors.
    • And they might be in error.
    • This avoids both issues.
  • Meyers provides the following (modified) example.

    • 
      class Address() {
          public:
          private:
              vector<string> addressLines(4);
              string city;
              string state;
              int zip;
      }
      
      class Person {
          public: 
             Person():
             ~Person():
             Person(const Person & person);
          private:
             Address address;
             string name;
      };
      
      bool ValidPerson1(Person p); 
      bool ValidPerson2(const Person & p); 

    • What does a call to ValidPerson1 entail?
      • A call to the Person copy constructor
        • Which calls the copy constructor of Address
          • Which calls the vector copy constructor.
          • and two more string constructors.
        • and a call to the string constructor
      • Then a call the the Person destructor
        • Which calls all of the appropriate destructors.
  • This also avoids the slicing problem we will encounter soon.
• Returning references.
  • He suggests that this is a good thing.
  • But
    • Do not return references to local variables.
      • Those will be deleted when the function returns.
    • Do not return references to things allocated on the stack
      • you will probably lose this memory.
      • Or it will cause really strange acrobatics.
    • This may cause an assignment operator invocation.
  • We will see this when we get back to chapter 9.
  • See returnDemo.cpp
• He finishes with a section that compares pointers and references.
  • The long and short is prefer references to pointers.
• Back to chapter 9,
  • Why would you want a member data element?
  • Consider a board game application
    • The pieces need to ask the board questions
      • Can I move into this location?
      • What is at that location?
    • The board needs to hold pieces
    • Should we pass the board to the piece every time it want's to do something?
    • Should we give each piece a copy of the board?
    • A better solution

    • class BoardT;
      
      class PieceT {
            PieceT(BoardT & boardRef): theBoard(boardRef) ...{
            }
         private:
            BoardT & theBoard;
            // could be const if we know the piece will not change the board.
      };
      
      class BoardT {
             ...
             void AddPiece(PieceT & piece);
          private:
             vector <PieceT *> pieces;
      };