类的构造函数
类的构造函数是类的一种特殊的成员函数，它会在每次创建类的新对象时执行。
构造函数的名称与类的名称是完全相同的，并且不会返回任何类型，也不会返回 void。构造函数可用于为某些成员变量设置初始值。
下面的实例有助于更好地理解构造函数的概念：
#include <iostream> using namespace std; class Line { public: void setLength(double len); double getLength(void); Line(); private: double length; }; Line::Line(void) { cout << "Object is being created" << endl; } void Line::setLength(double len) { cout << "Debug 2" << endl; length = len; } double Line::getLength(void) { return length; } int main() { Line line; cout << "Debug 1" << endl; line.setLength(6.0); cout << "Length of line : " << line.getLength() << endl; return 0; }
编译输出：
kevin@kevin-virtual-machine:~/Documents/Test/C++/three$ ./constructor Object is being created Debug 1 Debug 2 Length of line : 6
带参数的构造函数
默认的构造函数没有任何参数，但如果需要，构造函数也可以带有参数。这样在创建对象时就会给对象赋初始值，如下面的例子所示：
#include <iostream> using namespace std; class Line { public: void setLength(double len); double getLength(void); Line(double len); private: double length; }; Line::Line(double len) //成员函数定义，包括构造函数 { cout << "Object is being created" << endl; length = len; } void Line::setLength(double len) { cout << "Debug 2" << endl; length = len; } double Line::getLength(void) { return length; } int main() { Line line(10.0); cout << "Length of default line : " << line.getLength() << endl;//获取默认设置的长度 line.setLength(6.0); cout << "Length of line : " << line.getLength() << endl; return 0; }
编译输出：
kevin@kevin-virtual-machine:~/Documents/Test/C++/three$ ./constructor_para Object is being created Length of default line : 10 Debug 2 Length of line : 6
使用初始化列表来初始化字段：
Line::Line(double len): length(len) { cout << "Object is being created, length = " << len << endl; }
上面的语法等同于如下语法：
Line::Line(double len) { length = len; cout << "Object is being created, length = " << len << endl; }
假设有一个类 C，具有多个字段 X、Y、Z 等需要进行初始化，同理地，您可以使用上面的语法，只需要在不同的字段使用逗号进行分隔，如下所示：
C::C( double a, double b, double c): X(a), Y(b), Z(c) { .... }
类的析构函数
类的析构函数是类的一种特殊的成员函数，它会在每次删除所创建的对象时执行。
析构函数的名称与类的名称是完全相同的，只是在前面加了个波浪号（~）作为前缀，它不会返回任何值，也不能带有任何参数。析构函数有助于在跳出程序（比如关闭文件、释放内存等）前释放资源。
下面的实例有助于更好地理解析构函数的概念：
#include <iostream> using namespace std; class Line { public: void setLength(double len); double getLength(void); Line(); ~Line(); private: double length; }; Line::Line(void) //成员函数定义，包括构造函数 { cout << "Object is being created" << endl; } Line::~Line(void) { cout << "Object is being deleted" << endl; } void Line::setLength(double len) { cout << "Debug 2" << endl; length = len; } double Line::getLength(void) { return length; } int main() { Line line; line.setLength(6.0); cout << "Length of line : " << line.getLength() << endl; return 0; }
编译输出：
kevin@kevin-virtual-machine:~/Documents/Test/C++/three$ ./deconstructor Object is being created Debug 2 Length of line : 6 Object is being deleted
构造函数应用举例：
#include <iostream> #include <string> using namespace std; class Student { public: string name; string number; char X; int year; Student(string, string, char, int); //构造函数声明 void display(void); }; Student::Student(string N, string n, char x, int y) //利用构造函数给类的成员赋值 { name = N; number = n; X = x; year = y; } void Student::display() //输出成员的值 { cout << name << endl; cout << number << endl; cout << X << endl; cout << year << endl; } int main() { cout << "输入姓名："; string N; cin >> N; cout << "输入学号："; string n; cin >> n; cout << "输入性别(M或W)："; char x; cin >> x; cout << "输入年龄："; int y; cin >> y; Student S(N, n, x, y); //定义对象并对构造函数赋值 S.display(); //引用输出函数 return 0; }
编译输出：
kevin@kevin-virtual-machine:~/Documents/Test/C++/three$ ./cons_exam 输入姓名：kevin 输入学号：10 输入性别(M或W)：M 输入年龄：20 kevin 10 M 20
初始化列表的成员初始化顺序:
C++ 初始化类成员时，是按照声明的顺序初始化的，而不是按照出现在初始化列表中的顺序。
class CMyClass { CMyClass(int x, int y); int m_x; int m_y; }; CMyClass::CMyClass(int x, int y) : m_y(y), m_x(m_y) { };
你可能以为上面的代码将会首先做 m_y=y，然后做 m_x=m_y，最后它们有相同的值。但是编译器先初始化 m_x，然后是 m_y,，因为它们是按这样的顺序声明的。结果这样的话， m_x 将有一个不可预测的值。有两种方法避免它，一个是总是按照你希望它们被初始化的顺序声明成员，第二个是，如果你决定使用初始化列表，总是按照它们声明的顺序罗列这些成员。这将有助于消除混淆。
拷贝构造函数
拷贝构造函数是一种特殊的构造函数，它在创建对象时，是使用同一类中之前创建的对象来初始化新创建的对象。拷贝构造函数通常用于：
1) 通过使用另一个同类型的对象来初始化新创建的对象。
2) 复制对象把它作为参数传递给函数。
3) 复制对象，并从函数返回这个对象。
如果在类中没有定义拷贝构造函数，编译器会自行定义一个。如果类带有指针变量，并有动态内存分配，则它必须有一个拷贝构造函数。拷贝构造函数的最常见形式如下：
classname (const classname &obj) { // 构造函数的主体 }
在这里，obj 是一个对象引用，该对象是用于初始化另一个对象的。
#include <iostream> using namespace std; class Line { public: int getLength( void ); Line( int len ); // 简单的构造函数 Line( const Line &obj); // 拷贝构造函数 ~Line(); // 析构函数 private: int *ptr; }; // 成员函数定义，包括构造函数 Line::Line(int len) { cout << "调用构造函数" << endl; // 为指针分配内存 ptr = new int; *ptr = len; } Line::Line(const Line &obj) { cout << "调用拷贝构造函数并为指针 ptr 分配内存" << endl; ptr = new int; *ptr = *obj.ptr; // 拷贝值 } Line::~Line(void) { cout << "释放内存" << endl; delete ptr; } int Line::getLength( void ) { return *ptr; } void display(Line obj) { cout << "line 大小 : " << obj.getLength() <<endl; } // 程序的主函数 int main( ) { Line line(10); display(line); return 0; }
编译输出：
kevin@kevin-virtual-machine:~/Documents/Test/C++/three$ ./cp_constructor 调用构造函数 调用拷贝构造函数并为指针 ptr 分配内存 line 大小 : 10 释放内存 释放内存
下面的实例对上面的实例稍作修改，通过使用已有的同类型的对象来初始化新创建的对象：
#include <iostream> using namespace std; class Line { public: int getLength( void ); Line( int len ); // 简单的构造函数 Line( const Line &obj); // 拷贝构造函数 ~Line(); // 析构函数 private: int *ptr; }; // 成员函数定义，包括构造函数 Line::Line(int len) { cout << "调用构造函数" << endl; // 为指针分配内存 ptr = new int; *ptr = len; } Line::Line(const Line &obj) { cout << "调用拷贝构造函数并为指针 ptr 分配内存" << endl; ptr = new int; *ptr = *obj.ptr; // 拷贝值 } Line::~Line(void) { cout << "释放内存" << endl; delete ptr; } int Line::getLength( void ) { return *ptr; } void display(Line obj) { cout << "line 大小 : " << obj.getLength() <<endl; } // 程序的主函数 int main( ) { Line line1(10); Line line2 = line1; // 这里也调用了拷贝构造函数 display(line1); display(line2); return 0; }
编译输出：
调用构造函数 调用拷贝构造函数并为指针 ptr 分配内存 调用拷贝构造函数并为指针 ptr 分配内存 line 大小 : 10 释放内存 调用拷贝构造函数并为指针 ptr 分配内存 line 大小 : 10 释放内存 释放内存 释放内存
拷贝构造函数的调用时机
在C++中，下面三种对象需要调用拷贝构造函数！
1. 对象以值传递的方式传入函数参数
class CExample { private: int a; public: //构造函数 CExample(int b) { a = b; cout<<"creat: "<<a<<endl; } //拷贝构造 CExample(const CExample& C) { a = C.a; cout<<"copy"<<endl; } //析构函数 ~CExample() { cout<< "delete: "<<a<<endl; } void Show () { cout<<a<<endl; } }; //全局函数，传入的是对象 void g_Fun(CExample C) { cout<<"test"<<endl; } int main() { CExample test(1); //传入对象 g_Fun(test); return 0; }
调用g_Fun()时，会产生以下几个重要步骤：
(1). test对象传入形参时，会先会产生一个临时变量，就叫 C 吧。
(2). 然后调用拷贝构造函数把test的值给C。 整个这两个步骤有点像：CExample C(test);
(3). 等g_Fun()执行完后, 析构掉 C 对象。
拷贝构造函数几个原则：
C++ primer p406 ：拷贝构造函数是一种特殊的构造函数，具有单个形参，该形参（常用const修饰）是对该类类型的引用。当定义一个新对象并用一个同类型的对象对它进行初始化时，将显示使用拷贝构造函数。当该类型的对象传递给函数或从函数返回该类型的对象时，将隐式调用拷贝构造函数。
C++支持两种初始化形式：
拷贝初始化 int a = 5; 和直接初始化 int a(5); 对于其他类型没有什么区别，对于类类型直接初始化直接调用实参匹配的构造函数，拷贝初始化总是调用拷贝构造函数，也就是说：
A x(2); //直接初始化，调用构造函数
A y = x; //拷贝初始化，调用拷贝构造函数
必须定义拷贝构造函数的情况：
只包含类类型成员或内置类型（但不是指针类型）成员的类，无须显式地定义拷贝构造函数也可以拷贝；有的类有一个数据成员是指针，或者是有成员表示在构造函数中分配的其他资源，这两种情况下都必须定义拷贝构造函数。
什么情况使用拷贝构造函数：
类的对象需要拷贝时，拷贝构造函数将会被调用。以下情况都会调用拷贝构造函数：
（1）一个对象以值传递的方式传入函数体
（2）一个对象以值传递的方式从函数返回
（3）一个对象需要通过另外一个对象进行初始化。