C++面向对象-3-构造函数的分类和调用

前面一篇学习了类的构造函数和析构函数，两者都是编译器自动调用一次，构造函数是在类初始化的时候调用，析构函数是类在销毁之前调用。这篇继续学习类的构造函数分类和调用。

前面学习过了无参构造，这篇要学习有参构造，和拷贝构造。

 

有参构造

继续使用前面的代码例子

#include<iostream>
using namespace std;

class Point
{

public:

    //构造函数
    Point()
    {
	cout << "调用了构造函数"<< endl;
    }

    Point(int x, int y)
    {
	cout << "调用了有参构造函数"<< endl;
        X = x;
        Y = y;
    }

    //析构函数
    ~Point()
    {
	cout << "调用了析构函数" << endl;
    }

private:
    int X;
    int Y;
};

void test01()
{
    Point p(10, 10);
}

int main()
{
    test01();
    system("pause");
    return 0;
}

运行结果

 

拷贝构造

拷贝构造函数就是，参数传入是该类本身的一个实例对象，例如外部我有一个Point p1(10,10)， 如果我想在构造函数初始化就把X设置等于10， Y设置等于10，那么就可以通过拷贝构造实现，就是把p1的属性拷贝一份给构造函数。下面来举例

#include<iostream>
using namespace std;

class Point
{

public:

    //构造函数
    Point()
    {
	cout << "调用了构造函数"<< endl;
    }

    Point(int x, int y)
    {
	cout << "调用了有参构造函数"<< endl;
        X = x;
        Y = y;
    }

    //拷贝构造
    Point(const Point &p)
    {
	cout << "调用了拷贝构造函数" << endl;
	//将p的属性拷贝到当前类的初始化
	X = p.X;
	Y = p.Y;
    }

    //析构函数
    ~Point()
    {
	cout << "调用了析构函数" << endl;
    }

private:
    int X;
    int Y;
};

构造函数的调用

下面来学习小构造函数不同的调用方法，其实上面第一个代码运行就采用了构造函数调用的一种方法。构造函数调用方法有三类：括号法，显示法， 隐式转换法，下面分别来看看。

 

括号法

这个方法最好理解，在写实例化代码的时候Point p， 如果p后面不写小括号，默认调用无参构造函数，如果写小括号，会自动根据参数个数和类型，调用不同的重载的有参构造函数。

修改test01()的代码如下，保存，运行

void test01()
{
    Point p1; // 调用无参构造
    Point p2(10, 10); //调用有参构造,两个参数
    Point p3(p2);  //调用拷贝构造函数
}

由于初始化了三个对象，分别调用三个不同构造函数，所以有三次析构函数调用的打印。

注意：

上面调用无参构造的代码是Point p1, 而不是Point p1(), 一定不要这么写，如果这么写了，编译器 会认为代码Point p()是一个函数声明，而不是一个类的初始化。

 

显示法

把test01()的代码改成下面这样

void test01()
{
    Point p1 = Point(); // 调用无参构造
    Point p2 = Point(10, 10); //调用有参构造,两个参数
    Point p3 = Point(p2);  //调用拷贝构造函数
}

这种写法就是显示法，其实第一个调用无参构造，我们都习惯Point p1, 就这样写，显示法也不写成 Point p1 = Point()

这里面需要注意两点

1.如果是匿名对象，执行完初始化代码里面销毁对象

把test01()代码写成这样

void test01()
{
    //Point p1 = Point(); // 调用无参构造
    //Point p2 = Point(10, 10); //调用有参构造,两个参数
    //Point p3 = Point(p2);  //调用拷贝构造函数
    Point(3, 5); //匿名对象
    cout << "aaaabbb" << endl;
}

从打印结果就可以看出，这个匿名对象，在test01还没有执行到打印aaabb就已经销毁了。

2. 不要利用拷贝构造函数去初始化匿名对象

直接看下面代码，更好理解，在test01(){} 代码改成这样

这是因为，在编译器认为，此时48行代码 Point(p2) 等价于 Point p2，所以定义了两个p2，报错提示重定义。

 

隐式转换法

为了好演示隐式转换法，我上面添加了一个单个参数的构造函数，然后test01()代码修改了

#include<iostream>
using namespace std;

class Point
{

public:

    //构造函数
    Point()
    {
	cout << "调用了构造函数"<< endl;
    }

    Point(int x)
    {
	cout << "调用了单个有参构造函数"<< endl;
        X = x;
        Y = 0;
    }

    Point(int x, int y)
    {
	cout << "调用了有参构造函数"<< endl;
        X = x;
        Y = y;
    }

    //拷贝构造
    Point(const Point &p)
    {
	cout << "调用了拷贝构造函数" << endl;
	//将p的属性拷贝到当前类的初始化
	X = p.X;
	Y = p.Y;
    }

    //析构函数
    ~Point()
    {
	cout << "调用了析构函数" << endl;
    }

private:
    int X;
    int Y;
};

void test01()
{
    Point p1 = 10;  //等价于 Point p1 = Point(10);
    Point p2 = p1; //拷贝构造 等价于 Point p2 = Point(p1);
}

int main()
{
    test01();
    system("pause");
    return 0;
}

运行结果

这个隐式转换发现，需要把VS2017 编译环境调整为X64才可以，X86不支持这种语法编译会报错。还有就是不支持采用隐式转换的方法去调用两个参数的构造函数。

三种方法，建议使用前面两种，个人感觉第一种使用更简洁一些。