CSE687 - Object Oriented Design

Language Note #1
Distinguish between value types and reference types

Language Note #1:

• The C++ language supports the definition of copy constructors and assignment operators that you use to make instances behave like value types. You can also define classes that behave like reference types by holding a pointer to an instance of some type stored on the heap.
• Value types define copy construction and assignment operations that treat source and destination as separate memory locations. Copy construction creates a new value type object that is distinct (stored in a different location) from its copy source. Similarly, assignment copies the state of a source value type to another existing value type instance. Subsequent changes to the destination do not affect the source. We call these operations deep assignments and deep copies.
• All of the primitive C++ types and almost all of the standard C++ library types are value types. When you create a new type by declaring a class and defining its members, you will usually create a value type by defining a copy constructor and assignment operator that ensure that resources pointed to by member pointers are properly copied and assigned. We will discuss this in detail when we talk about Value Types. We will use, in that discussion, a string class as an example of how to implement copy and assignment, as well as many other things.
• The default model used by C++ for types is the value type. C++ provides default copy constructors, assignment operators, and destructors, that do memberwise copy, assignment, and destruction. Your classes will use these if they do not declare their own. That works correctly for value types, e.g., all classes that hold primitive member types and hold any other type that has correct copy, assignment, and destruction semantics. If, however, a class holds a pointer to an instance stored on the heap, the default operations simply copy, assign, and delete the pointers, which for the first two operations, cause shallow copy and assignment, and for destructuon, will cause run-time failures on destruction of any but the first instance, since that's what happens when delete is called more than once on a pointer with non-zero address.

  That means that, any time you design a class that holds pointers or C++ references to type instances stored on the heap, you must define a copy constructor, assignment operator, and destructor for that class that properly handle its resources.

• Reference types act like pointers to an instance stored in memory. Assignment and copy operations simply copy the pointer from source to destination, so that, after the operation, both refer to the same stored instance. That means if you make a state change with one of the references, the change will also be seen by the other reference. We call these shallow assignment and shallow copy operations.
• With reference types you need to be careful about deallocation of resources held by reference, as discussed above. The Java and C# languages manage reference types with garbage collection. That does a good job handling managed memory, but has its own problems when classes hold native resources like file streams and database locks.

  When implementing reference types in C++ we have essentially two alternatives. The first is to use reference counting and only deallocate a referenced resource when the reference count goes to zero. We will discuss a Smart Pointer type that uses this approach. The second alternative is to disallow assignment and copy operations. Then there will never be more than one reference to the resource, so there are no problems with destruction. You do that by declaring the copy constructor and assignment operator as private and then don't provide any implementation. This tactic is seldom used, since it limits the utility of these types.

Conclusions: