构造函数是一种特殊的类成员函数
创建对象时自动调用构造函数来初始化对象 

构造函数名与类名相同
没有返回值
可重载，但创建对象时只会调用其中的一个

普通构造函数

拷贝构造函数 复制构造函数
类名(const 类名& 对象名)
A(const A& obj)
拷贝构造函数是一种特殊的构造函数
在创建对象时，使用同一类中之前创建的对象来初始化新创建的对象 
通过使用另一个同类型的对象来初始化新创建的对象
复制对象把它作为参数传递给函数
复制对象，并从函数返回这个对象

拷贝构造函数 如果在类中没有定义拷贝构造函数，编译器会自动生成
拷贝操作是浅拷贝!!!


如果类带有指针变量，并有动态内存分配，则必须有一个拷贝构造函数
相应的赋值运算符也需要重载
否则会重复释放内存

对象拷贝和赋值的区别

对象的赋值是对一个已经存在的对象进行重新赋值，因此必须先定义被赋值的对象，才能进行赋值
而对象的拷贝是在从无到有建立一个新对象，并使这个新对象和已有对象完全相同

A a1(1);
A a2(2);
// 对象赋值 调用 operator=运算符重载
a2 = a1;
// 对象拷贝 调用复制构造函数
A a3 = a2;
A a4{a2};

默认赋值操作符，会对每一个成员逐一赋值 ， 类似浅拷贝




https://gitee.com/dyyx/hellocode/blob/master/web/tech/cpp/demo/construct001.cpp


#include "iostream"

class A{
  public :
  int value;
};

class B{
  public :
  int value;
  
  B(){
    std::cout << "B() run " << this << std::endl;
    value=1;
  }
  
  B(int value):value(value){
    std::cout << "B(int) run" << std::endl;
  }
  B(const B& obj){
    std::cout << "B copy construct run" << std::endl;
    value = obj.value;
  }
  
  B& operator =(const B& obj){
    std::cout << "B = run" << std::endl;
    if (this != &obj){
       this->value = obj.value;
    }
    return *this;
  }
  
  ~B(){
    std::cout << "~B() run" << std::endl;
  }
 
};

class C{
  public :
  // int* p=new int(0);
  int* p=NULL;
  C(){
    p = new int(1);
    std::cout << "C() run " << this << std::endl;
    // *p=1;
  }
  
  C(int value):C(){
    *p = value;
    std::cout << "C(int) run" << std::endl;
  }
  C(const C& obj):C(){
    std::cout << "C copy construct run" << std::endl;
    *p = *(obj.p);
  }
  
  C& operator =(const C& obj){
    std::cout << "C = run" << std::endl;
    if (this != &obj){
       *p = *(obj.p);
    }
    return *this;
  }
  
  ~C(){
    free(p);
    std::cout << "~C() run" << std::endl;
  }
 
};

// g++ -std=c++11 
int main(){  
    A a1;
    // 不赋值  值不确定
    a1.value = 1;
    std::cout << a1.value << std::endl;
    A a2{a1};
    std::cout << a2.value << std::endl;
    A a3 = a2;
    std::cout << a3.value << std::endl;
    A a4;
    a4 = a2;
    std::cout << a4.value << std::endl;
    
    //
    B b1;  
    std::cout << b1.value << std::endl;
    B b2{b1};
    std::cout << b2.value << std::endl;
    B b3 = b2;
    std::cout << b3.value << std::endl;
    B b4;
    b4 = b2;
    std::cout << b4.value << std::endl;
    
    //
    C c1;
    std::cout << *(c1.p) << std::endl;
    C c2{c1};
    std::cout << *(c2.p) << std::endl;
    C c3 = c2;
    std::cout << *(c3.p) << std::endl;
    C c4;
    c4 = c2;
    std::cout << *(c4.p) << std::endl;
    
   
    return 0;
}