For an enpty class, if you don't declare them yourself, compilers will declare their own versions of a copy constructor, a copy assignment operator, and a destructor. Furthermore, if you declare no constructors at all, compilers will also declare a default constructor for you.

These functions are generated only if they are needed.

Note that the generated destructor is non-virtual unless it's for a class inheriting from a base class that itself declares a virtual destructor (in which case the function's virtualness comes from the base class).

If you want to support copy assignment in a class containing a reference member, you must define the copy assignment operator yourself.

Compilers behave similarly for classes containing const members (such as objectValue in the modified class above). It's not legal to modify const members, so compilers are unsure how to treat them during an implicitly generated assignment function.

Finally, compilers reject implicit copy assignment operators in derived classes that inherit from base classes declaring the copy assignment operator private.

template<typename T>
class NamedObject {
public:
    // this ctor no longer takes a const name, because nameValue
    // is now a reference-to-non-const string. The char* constructor
    // is gone, because we must have a string to refer to.
    NamedObject(std::string& name, const T& value);
    //... // as above, assume no
    // operator= is declared
private:
    std::string& nameValue; // this is now a reference
    const T objectValue; // this is now const
};

//Now consider what should happen here :
std::string newDog("Persephone");
std::string oldDog("Satch");

NamedObject<int> p(newDog, 2); // when I originally wrote this, our dog Persephone was about to have her second birthday

NamedObject<int> s(oldDog, 36); // the family dog Satch (from my childhood) would be 36 if she were still alive

p = s; // what should happen to the data members in p?