14.4. Assignment Operators

We covered the assignment of one object of class type to another object of its type in Section 13.2 (p. 482). The class assignment operator takes a parameter that is the class type. Usually the parameter is a const reference to the class type. However, the parameter could be the class type or a nonconst reference to the class type. This operator will be synthesized by the compiler if we do not define it ourselves. The class assignment operator must be a member of the class so the compiler can know whether it needs to synthesize one.

Additional assignment operators that differ by the type of the right-hand operand can be defined for a class type. For example, the library string class defines three assignment operators: In addition to the class assignment operator, which takes a const string& as its right-hand operand, the string class defines versions of assignment that take a C-style character string or a char as the right-hand operand. These might be used as follows:

     string car ("Volks");
     car = "Studebaker"; // string = const char*
     string model;
     model = 'T'; // string = char

To support these operations, the string class contains members that look like

     // illustration of assignment operators for class string
     class string {
     public:
         string& operator=(const string &);      // s1 = s2;
         string& operator=(const char *);        // s1 = "str";
         string& operator=(char);                // s1 = 'c';
         // ....
      };

Assignment Should Return a Reference to *this

The string assignment operators return a reference to string, which is consistent with assignment for the built-in types. Moreover, because assignment returns a reference there is no need to create and destroy a temporary copy of the result. The return value is usually a reference to the left-hand operand. For example, here is the definition of the Sales_item compound-assignment operator:

     // assumes that both objects refer to the same isbn
     Sales_item& Sales_item::operator+=(const Sales_item& rhs)
     {
        units_sold += rhs.units_sold;
        revenue += rhs.revenue;
        return *this;
     }

Exercises Section 14.4 Exercise 14.14: Define a version of the assignment operator that can assign an isbn to a Sales_item. Exercise 14.15: Define the class assignment operator for the CheckoutRecord introduced in the exercises to Section 14.2.1 (p. 515). Exercise 14.16: Should CheckoutRecord define any other assignment operators? If so, explain which types should be used as operands and why. Implement the assignment operators for those types.