C++：构造函数与析构函数
构造函数与析构函数
构造函数：
构造函数是一种特殊的函数（方法），在根据类创建对象时被调用。与函数一样，构造函数也可以重载。
数据成员多为私有的，要对他们进行初始化，必须用一个公有函数来进行。同时这个函数应该在定义对象时自动执行一次。称为 构造函数。
构造函数的用途：1）创建对象；2）初始化对象中的属性；3）类型转换
C++ 兼容于C语言：
C语言：有空间即可操作
int main()
{
int a = 10;
char str[20];
new(str) int(100);
int* p = (int*)&str[4];
*p = 10;
return 0;
}C++：有空间不一定能够操作，必须调动构造函数，来创建对象：有空间不一定有对象，有对象一定有空间；
class Complex
{
private:
int real;
int image;
public:
};
int main()
{
Complex c1;
Complex c2;
}构造函数的定义与使用：
参考：21天学通C++：
构造函数是一种特殊的函数，它与类同名且不返回任何值。因此， Human 类的构造函数的声明类似于下面这样：
class Human
{
public:
Human(); // declaration of a constructor
}; 这个构造函数可在类声明中实现，也可在类声明外实现。在类声明中实现（定义）构造函数的代码类似于下面这样：
class Human
{
public:
Human()
{
// constructor code here
}
}; 在类声明外定义构造函数的代码类似于下面这样：
class Human
{
public:
Human(); // constructor declaration
};
// constructor implementation (definition)
Human::Human() //作用域运算符
{
// constructor code here
}构造函数是特殊的公有成员函数（在特殊用途中构造函数的访问限定可以定义成私有或者保护）。其特征如下：
1.函数名与类型名相同。
2.构造函数无函数返回类型说明。注意是没有而不是void,即什么也不写，也不可以写成void。实际上构造函数有返回值，返回的就是构造函数所创建的对象；
3.在程序运行时，当新的对象被建立，该对象所属的类构造函数自动被调用，在该对象生存期间也只调用这一次。
class Object
{
int value;
public:
Object() {}
Object(int x)
{
value = x;
}
};
int main()
{
Complex c1;
Object obj;
Object obja(10);
return 0;
}4.构造函数可以重载。严格地讲，类中可以定义多个构造函数，他们由不同的参数表区分，系统在自动调用时按照一般函数重载的规则原则一个执行。
class Complex
{
private:
double real;
double image;
public:
Complex() //缺省函数的构造
{
cout << "creat object:Complex()" << endl;
}
Complex(double r, double i); //构造函数的重载 函数名相同 参数名不同
void fun();
};5.构造函数可以在类中定义，也可以在类中声明，在类外定义；
class Complex
{
private:
double real;
double image;
public:
Complex() //缺省函数的构造
{
cout << "creat object:Complex()" << endl;
}
Complex(double r, double i); //构造函数的重载 函数名相同 参数名不同
void fun();
};
Complex::Complex(double r, double i) //构造函数可以在类中定义，也可以在类中声明，在类外定义。
{
real = r;
image = i;
cout << "creat object:Complex(int ,int)" << endl;
}6.如果类说明中没有给出构造函数，则C++编译器自动给出一个缺省的构造函数。
类名（void）{ }
但是只要我们定义了一个构造函数，系统就不会自动生成缺省的构造函数。只要构造函数是无参的或者只要各参数均有缺省值的，C++编译器都认为是缺省的构造函数，并且缺省的构造函数只能有一个。
class Complex
{
private:
double real;
double image;
public:
Complex() //缺省函数的构造
{
cout << "creat object:Complex()" << endl;
}
Complex(double r, double i); //构造函数的重载 函数名相同 参数名不同
void fun();
};
Complex::Complex(double r, double i) //构造函数可以在类中定义，也可以在类中声明，在类外定义。
{
real = r;
image = i;
cout << "creat object:Complex(int ,int)" << endl;
}
void Complex::fun()
{
cout << "real= " << real << 't' << "image= " << image << endl;
}
int main()
{
Complex c1;
Complex c2(1,2);
Complex c3= Complex(3, 4);
Complex c4{ 2,3 };
return 0;
}
运行结果如下：
成员初始化表：
#include
using namespace std;
class Complex
{
int Real;//实部
int Image;//虚部
public:
Complex() :Real{}, Image{} //缺省函数的构造
{
cout << "creat object:Complex()" << endl;
}
Complex(int r, int i) :Real{ r }, Image{i} //带参数的构造函数
{
cout<< "creat object:Complex(int ,int)" << endl;
}
void print() const //常方法
{
cout << "Real= " << Real << '\t' << "Image= " << Image << endl;
}
};
int main()
{
Complex ca;
Complex cb(1, 2);
Complex cc = Complex(3, 4);
Complex cd{ 5,6 };
Complex ce();//是否可以构造对象
return 0;
} 运行结果：
1. 根据main中的提示，实现构造函数
class CDate
{
int year;
int month;
int day;
public:
void ShowDate() const
{
cout << "year" << year << "month" << month << "day" << day << endl;
}
public:
CDate() :year(1), month(1), day(1){}
CDate(int y, int m=1, int d=1) :year(y), month(m), day(d){}
void Print()
{
cout << "year" << year << endl;
cout << "month" << month << endl;
cout << "day" << day << endl;
}
};
int main()
{
CDate cd1;
CDate cd2(2022, 3, 15);
CDate cd3(2024);
cd1.Print();
cd2.Print();
return 0;
}
2. 根据main中的提示，实现构造函数
const int len = 20;
class CGoods
{
private:
char Name[len];
int Amount;
float Price;
float Totle;
public:
CGoods() :Name{ '\0' }, Amount{}, Price{}, Totle{}
{
}
CGoods(const char* a, int b, float c) :Name{ '\0' }, Amount{ b }, Price{ c }, Totle{ b * c }
{
strcpy_s(Name, len, a);
}
void Print()
{
cout << "Name" << Name << endl;
cout << "Amount" << Amount << endl;
cout << "Price" << Price << endl;
cout << "Totle" << Totle << endl;
}
};
int main()
{
CGoods ca;
CGoods car("byd", 3, 128000.00);
CGoods book("C++",10,128.00);
ca.Print();
car.Print();
book.Print();
return 0;
} 
运行结果：
析构函数的定义：
与构造函数一样，析构函数也是一种特殊的函数。构造函数在实例化对象时被调用，而析构函数在对象销毁时自动被调用。
参考21天学通C++：
析构函数的语法：
声明和实现析构函数
析构函数看起来像一个与类同名的函数，但前面有一个腭化符号（～）。因此，Human 类的析构函数的声明类似于下面这样：
class Human
{
~Human(); // declaration of a destructor
}; 这个析构函数可在类声明中实现，也可在类声明外实现。在类声明中实现（定义）析构函数的代码类似于下面这样：
class Human
{
public:
~Human()
{
// destructor code here
}
}; 在类声明外定义析构函数的代码类似于下面这样：
class Human
{
public:
~Human(); // destructor declaration
};
// destructor definition (implementation)
Human::~Human()
{
// destructor code here
} 正如看到的，析构函数的声明与构造函数稍有不同，那就是包含腭化符号（ ～ ）。然而，析构函数的作用与构造函数完全相反。
析构函数的定义：
当定义一个对象时，C++自动调用构造函数建立该对象并进行初始化，那么当一个对象的生命周期结束时，C++也会自动调用一个函数注销该对象并进行善后工作，这个特殊的成员函数即析构函数：
1. 函数名与类型名相同，但是需要在前面加‘~’，如：~CGoods()。
2. 析构函数无函数返回类型，与构造函数在这一方面是一样的，但析构函数不带任何参数。
3.一个类有一个也只有一个析构函数，这与构造函数不同。
4.对象注销时，系统自动调用析构函数。
5. 如果类说明中没有给出析构函数，则C++编译器会自动给出一个缺省的析构函数。
如：~类型名（）{ }
#include
using namespace std;
class Complex
{
int Real;//实部
int Image;//虚部
public:
Complex() :Real{}, Image{} //缺省函数的构造
{
cout << "creat object: " <