C++构造函数

一． 构造函数

1. 每个类都分别定义了它的对象被初始化的方式，通过一个或几个特殊的函数来控制其对象的初始化过程，这些函数叫做构造函数。构造函数的任务是初始化类对象的数据成员。

2.

#include <iostream>
using namespace std;

class Test {
private:
int data;
public:
Test () {      // 构造函数，与类名同名
data = 0;
}
};

在main函数Test类实例化一个对象Test T1，编译系统为对象的数据成员data分配空间，并调用构造函数初始化数据成员。在构造函数中，Test应该为Test(Test*const this)，this指针指向当前对象。

一． 构造函数种类

1. 无参构造函数

(1) 如果在一个类中没有定义任何构造函数，编译器会自动生成一个默认无参构造函数初始化数据成员。

(2) 如果定义了一个构造函数，编译器不会自动生成默认构造函数。而如果需要默认构造函数，需要显示的定义默认构造函数。但要注意二义性的问题。当定义了默认构造函数，并且重载了一个带默认参数的构造函数，如下：

class Test {
private:
int data;
public:
Test () {
data = 0;
}
Test (int d = 0) {
data = d;
}
};
int main(void) {
Test T;
return 0;
};

编译后，出现如下错误：

Class.cpp:19:10: error: call of overloaded ‘Test()’ is ambiguous

没有传递参数时，系统默认又两种选择，一种是调用默认构造函数，另一种是调用带参构造函数并传递默认参数。这样就造成了二义性。

2. 一般构造函数

构造函数允许重载。除了上述的无参构造还可以定义一些参数进行传递的构造函数。

class Test {
private:
int data;
public:
Test () {
data = 0;
cout << "Constructor" << endl;
}

Test(int data) {
this -> data = data;
}

};

3. 拷贝构造函数

如果一个构造函数的第一个参数是自身类型的引用，且任何额外参数都有默认值，此构造函数为拷贝构造函数。

Test(const Test & T2) {
Data = T2.data;
}

(1) 如果类中为定义一个拷贝构造函数，则编译器会自动生成一个拷贝构造函数。

class Test {
private:
int data;
char ch;
public:
Test(int data = 0, char ch = 'a') {
this -> data = data;
this -> ch = ch;
cout << "Constructor" << endl;
}

void Print() {

cout << data << ' ' << ch;
cout << endl;
}
};

int main(void) {
Test T;
Test T1 = T;
T1.Print();
return 0;
}

运行结果如下：

Constructor
0 a

(2) 每个成员的类型决定其如何拷贝：对于类类型的数据成员，会使用其拷贝构造函数进行拷贝；对于内置类型成员则直接拷贝。拷贝构造函数会将数组元素逐一拷贝。

class MyClass {
private:
int data;
int array[3];
public:
MyClass(int data = 0, int * array = NULL) {
this -> data = data;
this -> array[0] = array[0];
this -> array[1] = array[1];
this -> array[2] = array[2];

cout << "MyClass Constructor " << endl;
}

MyClass(const MyClass& myclass) {

this -> data = myclass.data;
this -> array[0] = myclass.array[0];
this -> array[1] = myclass.array[1];
this -> array[2] = myclass.array[2];

cout << "MyClass copy Constructor " << endl;
}

void Print() {
cout << "MyClass Data is " << data << endl;
cout << "MyClass Array is ";
int i = 0;

for ( i = 0; i < 3; i++) {
cout << array[i] << ' ';
}
cout << endl;

}
};
class Test {
private:
int data;
char ch;
MyClass myclass;   // MyClass类对象
public:
Test(int data, char ch, int d, int * a):myclass(d, a) {
this -> data = data;
this -> ch = ch;
cout << "Test Constructor" << endl;
}

Test(MyClass my):myclass(my) {   // 调用MyClass对象的拷贝构造函数
}

void Print() {

cout << "Test data is ";
cout << data << ' ' << ch;
cout << endl;
myclass.Print();
}
};

int main(void) {

int array[3] = {1, 2, 3};
Test T(1, 'x',100, array);
Test copy = T;
copy.Print();
return 0;
}

其结果为：

MyClass Constructor
Test Constructor
MyClass copy Constructor
Test data is 1 x
MyClass Data is 100
MyClass Array is 1 2 3

注：Test类的对象在对MyClass类类型成员无论是调用构造函数还是拷贝构造函数时，一定要有MyClass类的对象去调用。 也就是Test(intdata, char ch, int d, int * a):myclass(d, a)和Test(MyClass my):myclass(my)，因为MyClass类成员的数据是私有的，Test类无法访问。

(3) 拷贝构造函数不仅在用 ‘ = ‘ 定义变量时会发生。下列情况也会发生。

a. 将一个对象作为实参传递个一个非引用类型的形参。

b. 从一个返回类型为非引用的类型函数返回一个对象。

(4) 为什么拷贝构造函数的参数要为引用？如果不为引用，例如Test(const Test T)，相当于把对象作为参数进行传递，需要调用拷贝构造，然后发现又不是引用，就一直执行这个拷贝构造函数。

4. 转换构造函数

(1) 如果构造函数只接受一个实参，则它实际上定义了转换为此类类型的隐式转换机制。这种构造函数称为转换构造函数。

class ConvertingConstructor {
public:
ConvertingConstructor(int IntData = 0) {
this -> IntData = IntData;
cout << "Constructor " << endl;
}
void Print() {
cout << IntData << ' ' << DoubleData;
cout << endl;
}
private:
int    IntData;
double DoubleData;
};
int main(void) {

ConvertingConstructor  coveting = 100;
coveting.Print();
return 0;
}

结果如下：

Constructor
100 0

在100为整型变量，在赋值时，构造了一个临时的ConvertingConstructor对象，然后该对象调用ConvertingConstructor(int IntData = 0)构造函数，形参的值为100，然后将该临时对象赋给coverting对象，完成隐式类型转换。

若要将一个类的对象赋值给一个内置类型，需要一下函数定义：

operator type() const; // type为要转换的类型。

type可以为任意类型（void除外）。不能转化为数组或者函数类型，但可以为指针和函数指针类型。

class ConvertingConstructor {
public:
ConvertingConstructor(int IntData = 0, double DoubleData = 0.0) {
this -> IntData = IntData;
this -> DoubleData = DoubleData;
cout << "Constructor " << endl;
}

operator int() const {
return IntData;
}
void Print() {
cout << IntData << ' ' << DoubleData;
cout << endl;
}

~ConvertingConstructor() {
cout << "Destructor" << endl;
}
private:
int    IntData;
double DoubleData;
};

int main(void) {

ConvertingConstructor  coverting(100, 3.13124);
int IntData = coverting;
cout << IntData;
cout << endl;
return 0;

运行结果如下：

Constructor
100
Destructor

(2) 抑制构造函数定义的隐式转换。

通过将构造函数声明为explicit来抑制。关键字explicit只对一个实参的构造函数有效。只能在类内声明构造函数时使用该关键字，在类外部定义不应重复。