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;}

运行结果如下：

Constructor0 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 ConstructorMyClass copy Constructor Test data is 1 xMyClass Data is 100MyClass 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 100Destructor

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

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