Gotcha #81: Const and Reference Data Members

In this item, I'll attempt to convince you that it rarely makes sense to declare const or reference data members in a class. Const and reference data members tend to make classes harder to work with, require unnatural copy semantics, and encourage maintainers to introduce dangerous changes.

Let's look at a simple class with const and reference data members:

class C { 
 public:
   C();
   // . . .
 private:
   int a_;
   const int b_;
   int &ra_;
};

The constructor must initialize const and reference data members:

C::C() 
   : a_( 12 ), b_( 12 ), ra_( a_ )
   {}

So far, so good. We can declare objects of type C and initialize them:

C x; // default ctor 
C y( x ); // copy ctor

Oops! Where did that copy constructor come from? The compiler wrote it for us, and by default, that copy constructor will perform a member-by-member initialization of the members of y with the corresponding members of x (see Gotcha #49). Unfortunately, this default implementation will set the ra_ reference in y to the a_ in x. Since we're on the subject of good, general advice, another such piece of advice is "Consider writing copy operations for any class that contains a handle (generally a pointer or reference) to other data":

C::C( const C &that ) 
   : a_( that.a_ ), b_( that.b_ ), ra_( a_ )
   {}

Let's continue to use our C objects:

x = y; // error! 

The problem here is that the compiler is unable to generate an assignment operation for us. By default, it will attempt to generate an assignment operation that simply assigns each data member of y to the corresponding data member of x. For objects of type C, that isn't possible, since the b_ and ra_ members can't be assigned. This is just as well, really, since such an assignment operation would exhibit the same incorrect behavior as that of the default copy constructor.

The problem is, it's not a simple task to write the assignment operator. Consider a first attempt:

C &C::operator =( const C &that ) { 
   a_ = that.a_; // OK
   b_ = that.b_; // error!
   return *this;
}

It's not legal to assign to a constant. The danger here is that a "creative" maintainer of our code will attempt to perform the assignment anyway. Usually, the first recourse is to a cast:

int *pb = const_cast<int *>(&b_); 
*pb = that.b_;

Now, in point of fact, this code will probably not cause any runtime problems, since it's unlikely that the b_ member will be in a read-only segment when it's part of a non-constant C object. However, one can hardly call this a natural implementation, and this trick won't work on a reference member. (Note that in this particular assignment operator, it was not necessary to attempt to rebind the reference data member of C, since it was already referring to the a_ member of its own object.)

Some excessively creative maintainers might take a different tack. Rather than assign y to x, they'll destroy x entirely and reinitialize it with y:

C &C::operator =( const C &that ) { 
   if( this != &that ) {
       this->~C(); // call dtor
       new (this) C(that); // copy ctor
   }
   return *this;
}

A lot of ink has been expended over the years in proposing and, ultimately, rejecting this approach. Even though it may work in this limited case—for a time—it's complex, doesn't scale, and is likely to cause problems in the future. Consider what would happen if C ultimately became a base class. It's likely that a derived class assignment operator would call C's assignment operator. The destructor call, if virtual, will destroy the entire object, not just the C part. The destructor call, if nonvirtual, will have undefined behavior. Avoid this approach.

The easiest and most straightforward approach is to simply avoid const and reference data members. Since all our data members are private (they are private, aren't they?), we already have adequate protection from accidental modification. If, on the other hand, the intent of using const or reference data members is to keep the compiler from generating a default assignment operator, a more idiomatic way will achieve that (see Gotcha #49):

class C { 
   // . . .
 private:
   int a_;
   int b_;
   int *pa_;
   C( const C & ); // disallow copy construction
   C &operator =( const C & ); // disallow assignment
};

Const or reference data members are rarely needed. Avoid them.