C++ 构造函数讲解

构造函数是C++、Java等面向对象编程语言不可绕过的话题，构造函数的作用就是初始化所创建对象的数据成员。不过与Java相比C++的构造函数显得更为复杂。因此，现在便来讲解一下C++的构造函数，以此进一步加深对构造函数的理解。

C++的构造函数分为无参构造函数和有参构造函数，且构造函数可以重载。当一个类中没有自定义的构造函数时，创建对象时便会自动调用系统默认的无参构造函数，不过这个构造函数的函数体为空，什么操作也不执行。不过一旦有自定义的构造函数时，便再也不会调用系统默认的构造函数。如果要使用无参构造函数，便需要自行定义。

数据成员为基本类型的类的讲解：

示例代码如下：

 #include <iostream>
 using namespace std;

 class Test
 {
     public:
         Test();
         Test(int a, int b);
     private:
         int a;
         int b;
 };

 Test::Test()
 {
     cout << "调用Test的无参构造函数" << endl;
     a = ;
     b = ;
 }

 Test::Test(int a, int b)
 {
     cout << "调用Test的有参构造函数" << endl;
     this->a = a;
     this->b = b;
 }

 int main()
 {
     //若想通过无参构造函数初始化对象，只能以此种方式声明对象
     Test t1;
     Test t2(, );
     Test t3 = Test(, );

     Test* t11 = new Test;
     Test* t22 = new Test(, );
 }

运行结果如下：

通过分析运行结果我们可以发现:

Test t1;这个语句所执行的操作是：在栈区为对象t1分配存储空间，并调用无参构造函数对t1数据成员进行初始化。

Test* t11 = new Test;这个语句所执行的操作是：在栈区为t11指针分配存储空间，在堆区为t11所指向的对象分配存储空间，并调用默认构造函数对对象的数据成员进行初始化。

数据成员为类类型的类的讲解：

示例代码：

 #include <iostream>
 #include <vector>

 using namespace std;

 class Person
 {
     public:
         Person();
         Person(string name, int age);
         void display();
     private:
         string name;
         int age;
 };

 Person::Person()
 {
     cout << "调用 Person 无参构造函数" << endl;
     name = "kkkk";
     age = ;
 }

 Person::Person(string name, int age)
 {
     cout << "调用 Person 有参构造函数" << endl;
     this->name = name;
     this->age = age;
 }

 void Person::display()
 {
     cout << "Name: " << name << " Age: " << age << endl;
 }

 class Test
 {
     public:
         Test();
         Test(string name, int age, int value);
         void show();
     private:
         Person person;
         int value;
 };

 Test::Test()
 {
     person = Person("wwww", );
     person.display();
     cout << "调用 Test 无参构造函数" << endl;
     value = ;
 }

 Test::Test(string name, int age, int value):person(name, age)
 {
     person.display();
     cout << "调用 Test 第二个有参构造函数" << endl;
     value = ;
 }

 void Test::show()
 {
     person.display();
     cout << "Value: " << value << endl;
 }

 int main()
 {
     Test t1;
     cout << "##################################" << endl;
     Test t2("hhhh", , );
     return ;
 }

运行结果如下：

分析运行结果：

Test::Test()
{
    person = Person("wwww", 3333);
    person.display();
    cout << "调用 Test 无参构造函数" << endl;
    value = 100;
}

此构造函数实际是首先调用person的无参构造函数初始化person,然后再初始化本对象基本数据类型的数据成员。

而person = Person("wwww", 3333);语句是将Person("wwww", 3333)对象的数据成员复制给本person对象的数据成员,而且通过=复制本身也只是一种浅拷贝。相当于person对象被进行了两次初始化

Test::Test(string name, int age, int value):person(name, age)
{
    person.display();
    cout << "调用 Test 第二个有参构造函数" << endl;
    value = 100;
}

这个Test函数与上一个Test并无本质区别，只是这个Test函数是显式调用person对象的有参构造函数。

由此可以得出以下结论：

有类A，A有类类型数据成员B b，那么A的构造函数只能是以下形式：

如果B有无参构造函数：

A::A()

{

　　......

}

A::A(...)

{

　　......

}

如果B有有参构造函数:

A::A():b(...)

{

　　.....

}

A::A(...):b(...)

{

　　......

}

继承时构造函数的讲解：

示例代码:

 #include <iostream>

 using namespace std;

 class A
 {
     public:
         A();
         A(int a);
     private:
         int a;
 };

 A::A()
 {
     cout << "调用A无参构造函数" << endl;
     a = ;
 }

 A::A(int a)
 {
     cout << "调用A有参构造函数" << endl;
     this->a = a;
 }

 class B: public A
 {
     public:
         B();
         B(int a, int b);
     private:
         int b;
 };

 B::B()
 {
     cout << "调用B无参构造函数" << endl;
     b = ;
 }

 B::B(int a, int b):A(a)
 {
     cout << "调用B有参构造函数" << endl;
     this->b = b;
 }

 int main()
 {
     B b1;
     cout << "##################################" << endl;
     B b2(, );
     return ;
 }

运行结果如下:

分析运行结果：

B::B()
{
    cout << "调用B无参构造函数" << endl;
    b = 20;
}

此构造函数调用了A类的无参构造函数，且首先执行A类的构造函数，后执行B类的构造函数

B::B(int a, int b):A(a)
{
    cout << "调用B有参构造函数" << endl;
    this->b = b;
}

此构造函数与上一构造函数并无本质区别，只是显示调用A类的有参构造函数

由此可以得出以下结论：

现有类A，类B，且B继承A

如果A有无参构造函数，那么B的构造函数可以这么写：

B::B()

{

　　......

}

B::B(...)

{

　　......

}

如果A有有参构造函数，那么B的构造函数可以这么写：

B::B():A(...)

{

　　......

}

B::B(...):A(...)

{

　　......

}

讲解完毕，若有不足之处，敬请指出！！！