Question

Suppose I have a class that doesn’t support memberwise copying so I don’t want to preserve compiler-implemented copy-constructor and assignment operator. I also don’t want to implement those because either

1. doing so takes extra effort and I don’t need those operations in my class or
2. those operations won’t make sense in my class

so I want to prohibit them. To do so I’ll declare them private and provide no implementation:

class NonCopyable {
private:
   NonCopyable( const NonCopyable& ); //not implemented anywhere
   void operator=( const NonCopyable& ); //not implemented anywhere
};

Now I can select any return type for operator=() member function. Will it matter which return type I select?

Answer 1

It matters a tiny, tiny bit:

• void ensures a small percentage of accidental/misguided calls (a = b = c / f(d = e)) from within the class’s implementation produce compile time errors rather than link time errors, which may save compile time and be more understandable (minimally relevant for large classes touched by many developers, some with limited prior familiarity).

• void would ring an alarm bell for me (and hopefully most developers), wondering whether you:

  • wanted to remove the default-generated operator=
  • were just lazy about the extra typing, or
  • were unfamiliar/uncaring re the generally expected semantics of operator=.

With the open question in mind, other programmer are less likely to come along and think you just didn’t get around to providing the implementation and add it casually (you may feel comments are adequate).

• returning a reference to type may make the overall function signature more instantaneously recognisable, or visually searching past a complicated type to find operator= could have the opposite effect – all in the eye (and mind) of the beholder….