TITLE: What methods the compiler automatically writes


PROBLEM: <excerpted from "Effective C++" by Scott Meyers

Know what functions C++ silently writes and calls.

...

If you write this,

	class Empty {};

you may end up with this:

	class Empty {
	  public:
	     Empty ();                            // default constructor
	     Empty (const Empty& rhs);            // copy constructor

	     Empty& operator= (const Empty& rhs); // assignment operator
	     Empty* operator& ();                 // address-of operator
	     const Empty* operator& ();
	};

If Empty were derived from some other class, and that other class
had a destructor, C++ would also write a destructor for Empty, a topic
I'll return to below.

Now in facat these are generated only if they are needed, but it doesn't
take much to need them.  ...


	const Empty e1;          // default constructor
	Empty e2 = e1;           // copy constructor
	e2 = e1;                 // assignment operator

	Empty* pe2 = &e1;        // address-of operator (non-const)


	const Empty* pe1 = &e1;  // address-of operator (const)

Given that the compiler is writing functions for you, what do the
functions do? ...

	inline Empty :: Empty () {}

	inline Empty* Empty::operator& () { return this; }

	inline const Empty* Empty::operator& () const { return this; }
...

The default copy constructor (assignment operator) performs memberwise
copy construction (assignment) of the nonstatic data members of the 
class.

...

There is one additional case where the compiler will generate a function
for you. If you derive a class from another class, and that other class
has a destructor, C+ will generate a public, non-virtual destructor for
you.

...

All this gives rise to the question, what do you do if you want to 
disallow use of these functions?

<The answer is to declare but not define a given methods. For example,

	class X {
	  private:
	     int x;
	     X (const X& rhs);  // do not provide any implementation
	  public:
	     X (int i) : x(i) {}
	};
>