【C/C++ 构造函数 详解】深入解析C++ 构造函数：C++ 11 中的新特性与实践

//例1： 隐式转换
    class Complex {
    public:
      double real, imag;
      Complex( int i) {//类型转换构造函数
        cout << "IntConstructor called" << endl;
        real = i; imag = 0;
      }
      Complex(double r,double i) {real = r; imag = i; }
    };
    int main ()
    {
      Complex c1(7,8);
      Complex c2 = 12;// 属于情况一：编译器先创建一个Complex对象c2，然后将12传递给转换构造函数对c2变量进行初始化。
      c1 = 9; // 属于情况二：9被自动转换成一个临时Complex对象，然后将该对象赋值给c1。这里的转换属于隐式的转换。
      cout << c1.real << "," << c1.imag << endl;
      return 0;
    }
    //例2：显式转换
    class Complex {
    public:
      double real, imag;
      explicit Complex( int i) {//显式类型转换构造函数
      cout << "IntConstructor called" << endl;
      real = i; imag = 0;
      }
      Complex(double r,double i) {real = r; imag = i; }
    };
    int main () {
      Complex c1(7,8);
      Complex c2 = Complex(12);
      c1 = 9; // error，9不能被自动转换成一个临时Complex对象，不支持隐式的转换。所匹配的转换构造函数不支持隐式转换。
      c1 = Complex(9) //正确，这里，complex（9）先创建一个临时的Complex对象，然后调用转换构造函数将其初始化，即：显示的将9转换为一个Complex对象。
      cout << c1.real << "," << c1.imag << endl;
      return 0;
    }
    //显式类型转换构造函数，不会隐式的调用类型转换构造函数，必须显式的调用

operator type(){
        //TODO:
        return data;
    }

classname (const classname &obj) {   
    // 构造函数的主体
    }

#include<iostream>
            using namespace std;
            class A{
            public:
                A(){};
                A(A & a){
                    cout<<"Copy constructor called"<<endl;
                }
            };
            void Func(A a){ }
            int main(){
                A a;
                Func(a);
                return 0;
            }

#include<iostream>
           using namespace std;
           class A {
           public:
               int v;
               A(int n) { v = n; };
               A(const A & a) {
                   v = a.v;
                   cout << "Copy constructor called" << endl;
               }
           };
           A Func() {
               A a(4);
               return a;
           }
           int main() {
               cout << Func().v << endl;
               return 0;
           }

Complex c2(c1);
            Complex c2 = c1;

class_name(class_name && )

Data(Data&& Other) {
        this->IntData = Other.IntData;
        Other.IntData = nullptr;
        this->IntDataLength = Other.IntDataLength;
        Other.IntDataLength = 0;
    }

#include <iostream>
  using namespace std;
  
  class Coordinate
  {
  public:
    // 无参构造函数
    // 如果创建一个类你没有写任何构造函数，则系统自动生成默认的构造函数，函数为空，什么都不干
    // 如果自己显示定义了一个构造函数，则不会调用系统的构造函数
    Coordinate()
    {
      c_x = 0;
      c_y = 0;
    }     
  
    // 一般构造函数
    Coordinate(double x, double y):c_x(x), c_y(y){}   //列表初始化
    // 一般构造函数可以有多个，创建对象时根据传入的参数不同调用不同的构造函数
  
    Coordinate(const Coordinate& c)
    {
      // 复制对象c中的数据成员
      c_x = c.c_x;
      c_y = c.c_y;
    }
  
    // 等号运算符重载
    Coordinate& operator= (const Coordinate& rhs)
    {
      // 首先检测等号右边的是否就是等号左边的对象本身，如果是，直接返回即可
      if(this == &rhs)
        return* this;
      // 复制等号右边的成员到左边的对象中
      this->c_x = rhs.c_x;
      this->c_y = rhs.c_y;
      return* this;
    }
  
    double get_x()
    {
      return c_x;
    }
  
    double get_y()
    {
      return c_y;
    }
  
  private:
    double c_x;
    double c_y;
  };
  
  int main()
  {
    // 调用无参构造函数，c1 = 0，c2 = 0
    Coordinate c1, c2;
    // 调用一般构造函数，调用显示定义构造函数
    Coordinate c3(1.0, 2.0);
    c1 = c3;    //将c3的值赋值给c1，调用"="重载
    Coordinate c5(c2);
    Coordinate c4 = c2;    // 调用浅拷贝函数，参数为c2
    cout<<"c1 = "<<"("<<c1.get_x()<<", "<<c1.get_y()<<")"<<endl
      <<"c2 = "<<"("<<c2.get_x()<<", "<<c2.get_y()<<")"<<endl
      <<"c3 = "<<"("<<c3.get_x()<<", "<<c3.get_y()<<")"<<endl
      <<"c4 = "<<"("<<c4.get_x()<<", "<<c4.get_y()<<")"<<endl
      <<"c5 = "<<"("<<c5.get_x()<<", "<<c5.get_y()<<")"<<endl;
    return 0;
  }

//拷贝构造函数
#include <iostream>
  using namespace std;
  
  class Test
  {
  public:
    // 构造函数
    Test(int a):t_a(a){
    cout<<"creat: "<<t_a<<endl;
    }
  
    // 拷贝构造函数
    Test(const Test& T)
    {
      t_a = T.t_a;
      cout<<"copy"<<endl;
    }
  
    // 析构函数
    ~Test()
    {
      cout<<"delete: "<<t_a<<endl;
    }
  
    // 显示函数
    void show()
    {
      cout<<t_a<<endl; 
    }
  
  private:
    int t_a;
  };
  
  // 全局函数，传入的是对象
  void fun(Test C)
  {
    cout<<"test"<<endl;
  }
  
  int main()
  {
    Test t(1);
    // 函数中传入对象
    fun(t);
    return 0;
  }

#include <iostream>
using namespace std;
class IntNum
{
private:
    int *xptr;
public:
    IntNum(int x);
    // IntNum(const IntNum &n);
    IntNum(IntNum &&n);
    ~IntNum();
    int getInt() { return *xptr; }
};
IntNum::IntNum(int x = 0) : xptr(new int(x))
{
    cout << "Calling constructor..." << endl;
}
IntNum::IntNum(IntNum &&n) : xptr(n.xptr)//两个& 表示右值的引用
{
    n.xptr = nullptr;
    cout << "Calling Move Assignment Operator..." << endl;
}
IntNum::~IntNum()
{
    delete xptr;
    cout << "Destructing..." << endl;
}
IntNum getNum()
{
    IntNum a;
    return a;
}
int main(int argc, char *argv[])
{
    cout << getNum().getInt() << endl;
    return 0;
}

class X {
void CommonInit();
Y y_;
Z z_;
public:
X();
X( int );
X( W );
};
X::X() : y_(42), z_(3.14) { CommonInit(); }
X::X( int i ) : y_(i), z_(3.14) { CommonInit(); }
X::X( W e ) : y_(53), z_( e ) { CommonInit(); }