C++ for Scientists - Technische Universität Dresden

3.6. AUTOMATICALLY GENERATED OPERATORS 77
{}
//...
varn(that.varn)
∼my class()
{
varn.∼typen();
// ...
var2.∼type2();
var1.∼type1();
}
my class& operator=(const my class& that)
{
var1= that.var1;
var2= that.var2;
// ...
varn= that.varn;
return ∗this;
}
private:
type1 var1;
type2 var2;
// ...
typen varn;
};
The generation is straight forward. The four operators are respectively called on each member
variable. The careful reader has realized that the constructors and the assignment is performed
in the exact order as the variables are defined. The destructors are called in reverse order.
The generation of these operators will be disabled if you define your own. The rules for this
are quite simple. The simplest is for the destructor: either you define it or the compiler does.
There is only one destructor (because it has no arguments). The default constructor generation
is disabled when any constructor is defined by the user — even a private constructor.
The copy constructor and copy assignment operator are generated automatically unless there
is a user-defined version for the class type or a reference of it. In detail, if the user defines one
or two of the following:
• return type operator=(my class that);
• return type operator=(const my class& that); or
• return type operator=(my class& that);
Then the compiler does not generated it. Typically, one defines only the second operator
because the first one causes an extra copy 7 and the last one requires mutability what is usually
not necessary for the assignment. The copy constructor can only be defined for references
because it need itself for passing a value as argument. Defining a constructor or assignment for
any other type does not disable the generation of the copy operators.
7 An exception is user-defined move semantics. 8