1.1.16.2 ctor, destructor, copy and assignment

• Normally, ctor , destructor and assignment should be public. In inheritance context, all the base class desctructor should be virtual.
• The Default ctor, Copy ctor and Assignment operator will not be implicitly generated if
  1. you have explicitly declared any constructor. Or copy ctor and Assigmnet operaor(for class X a constructor taking X, X& or const X&).
  2. There is a member in your class that is not default-constructible (such as a reference, a const object, or a class with no or inaccessible default constructor)
  3. (C++11) you have explicitly told the compiler to not generate one using A() = delete;
• The Destructor will not be implicitly generated if
  1. you have explicitly declared a destructor
  2. (C++11) you have explicitly told the compiler to not generate one using  A() = delete;
• The Move Constructor or Move Operator(C++11) will not be implicitly generated if
  1. you have explicitly declared a move constructor or move assignment(for class X, a constructor taking X&&)
  2. there is a member in your class that cannot be moved (have deleted, inaccessible, or ambiguous)
  3. you have defined a copy assignment operator, copy constructor, destructor, or move assignment operator
  4. you have explicitly told the compiler to not generate one using A(A&&) = delete;
• Even you write Empty class, compiler will produce at least five member functions.
  class Empty{}; 
  /////////////////////////// 
  Empty(); 
  Empty(const Empty& rhs); 
  Empty& oprator=(const empty & rhs); 
   
  Empty* operator&(){return this}; 
  const Empty* operator&() const ;
• Sometimes you dont’ want compiler to produce these member function automatically, such as you define a array class. you don’t want client to use array1=array2(It’s not allow in common c/c++ language). You can just declare you own assignment operator as private member function, and you don’t need to implement it. (If you use it, linker will yelp at you. ) A example can be seen effective c++ item "Explicitly disallow use of implicityly generated member functions you don’t want". Another way is to use =delete, see last chapter " C++ new features"
• Make Constructors Protected to prohibit direct Instantiation. Make constructors Private to prohibit Derivation.
• Use default arguments to reduce the number of ctor.
  class Brush{ 
  Brush(); 
  Brush(Color c); 
  Brush(Texture t); 
   
  Brush(Color c= Black, Texture t = Solid); // it will be better. 
  }
• If you define a specify ctor, you also need to define default ctor. Because system will not produce any default ctor for you. So below statement will produce error when compiling.
  class obj; //error 
  class* obj = new class(); //error 
  class arra[10] //error 
  template<class T> 
  class Array{ 
  T t; 
  }; 
   
  Array<class> a; //error
• From previous example, you can see that default ctor is very important. but when class MUST need another information when create, such as worker class, You must provide SSN when you create a worker. At this time, if you create default ctor, It’s not good idea. A NULL SSN will cause a lot of trouble in the future. That is C++ spirit, You never have the best answer, only have context answer.
  class worker{ 
  char* SSN; 
  worker(const char*); 
  worker(){SSN=nullptr); //bad smell. 
  }
• copy ctor, assignment operator, and destructor three function should be exit at the same time. The perform deep copy if you have new action inside of class. or you will perform shallow copy, which sometimes is dangerous.
• When to use member initalize list, you can see in this link:
  1. to non-static const data members.
  2. reference member
  3. member objects which do not have default constructor: (why I need default ctor can be explained here too)
  4. need pass argument to base class ctor
  5. need to by copy between obj to member obj. (only one copy ctor, more efficient! see below source code.)
  http://www.geeksforgeeks.org/when-do-we-use-initializer-list-in-c/
  //method 1: 
  class(string &a, string &b): m_a(a),m_b(b){} 
  // just call string copy ctor, 
  //so you don’t need string default ctor 
   
  //method 2: 
  class(string &a, string &b){   // two action. 
  m_a = a;  //call default constructor to build m_a 
  m_b = b; // then call assignment operator. 
  }
• List member in a initialization list in the order in which they are declared in class. see effective c++ item 13. Order is important.
• A copy constructor is called whenever a new variable is created from an object. This happens:
  1. When a new object is initialized to an object of the same class.
  2. When an object is passed to a functon by value.
  3. When a function returns an object by value.
  4. When the compiler generates a temporary object.
  1) Person r(p);   or  Person p = q;      // copy constructor 
  p = q;  // but not called in assignment; p has existed before 
   
  2) A value parameter is initialized from its argument. 
  fun(Person r)    fun(p); 
  // copy constructor, produce a new object r. 
  //just like Person r = p; 
   
  3) An object is returned by a function. 
  Person fun(); 
  Person r = fun(); 
  //here copy ctor is called twice. 
  // use -fno-elide-constructors in g++ produce two copy ctor 
  // or It will use Return value optimization. 
   
  4) class(string &a, string &b): m_a(a),m_b(b){} 
  //Initialization list
• In previous example, you can see when you pass and return value of obj, It will call copy ctor, It’s not very efficient. So you should use reference or pointer if it’s possible, don’t pass object directly.
• An Assignment operator examples: 1) avoid assignment self 2) return *this reference.
  class & class::operator=(class &a){ 
    if(this == &a) 
      return *this;  //avoid assignment 
      .............  // assignment operation here. 
      return *this ; // return *this reference. 
  }