面向对象编程(C++篇2)——构造

目录

• 1. 引述
• 2. 详述
  • 2.1. 数据类型初始化
  • 2.2. 类初始化

1. 引述

在C++中，学习类的第一课往往就是构造函数。根据构造函数的定义，构造函数式是用于初始化类对象的数据成员的。无论何时，只要类被创建，就会执行构造函数：

class ImageEx
{
public:
    ImageEx()
    {
        cout << "Execute the constructor!" << endl;
    }
};

int main()
{
    ImageEx imageEx;
    return 0;
}

那么问题来了，为什么要有构造函数？

2. 详述

2.1. 数据类型初始化

正如上一篇文章《面向对象编程(C++篇1)——引言》中提到的那样：类是抽象的自定义数据类型。对于C++的内置数据类型，我们可以采用如下方式进行初始化：

double price = 109.99;

这种初始化行为很像赋值操作，但是初始化与赋值是两种概念：初始化的含义是创建变量的时候赋予其一个初始值，而赋值的含义则是把对象的当前值擦除，以一个新的值来代替。实际上，我们同样可以使用类似构造函数一样的方式初始化内置数据类型：

double price(109.99);

那么，我们在定义变量的时候不进行初始化会怎么样呢？答案是会进行默认初始化（其实不太准确，在某些情况下，会不被初始化，进而产生未定义的行为，是非常危险的）：

double price;
price = 109.99;

在C++中，一个合理的原则是：变量类型定义时初始化。这个原则不仅可以避免未初始化可能产生的未定义行为，还节省了性能：避免定义（默认初始化）后再进行赋值操作。

2.2. 类初始化

可能你会认为，先定义（默认初始化）之后再进行赋值，对性能影响不大。这句话对于C#、Java、JavaScript这样的语言来说是成立的，它们的应用场景很多时候可以不用关心这个（性能场景则不一定）。而对于C++这样的面向底层的语言来说，追求的是"零成本抽象（zero overhead abstraction）"的设计原则，只是简单的数据结构影响当然不太，但是对于一个非常复杂的数据类型，则可能存在不可忽视的性能开销。

可以为一个类的数据成员提供一个类内初始值：

class ImageEx
{
    int imgWidth = 0;
    int imgHeight = 0;
    int bandCount = 0;
};

类的数据成员如果不进行初始化，那么就会如前所述，进行默认初始化：

class ImageEx
{
public:

    void Print()
    {
        cout << imgWidth << '\t' << imgHeight << '\t' << bandCount << endl;
        for (int i = 0; i < 10; i++)
        {
            printf("%d\t", data[i]);
        }
    }

private:
    int imgWidth;
    int imgHeight;
    int bandCount;

    unsigned char data[10];
};

int main()
{
    ImageEx imageEx;
    imageEx.Print();

    return 0;
}

运行结果：

默认初始化的未定义行为当然不是我们想要的，于是我们给他加一个初始化函数：

class ImageEx
{
public:

    void Init()
    {
        imgWidth = 200;
        imgHeight = 100;
        bandCount = 3;
        memset(data, 0, 10 * sizeof(unsigned char));
    }

    void Print()
    {
        cout << imgWidth << '\t' << imgHeight << '\t' << bandCount << endl;
        for (int i = 0; i < 10; i++)
        {
            printf("%d\t", data[i]);
        }
        cout << endl;
    }

private:
    int imgWidth;
    int imgHeight;
    int bandCount;

    unsigned char data[10];
};

int main()
{
    ImageEx imageEx;
    imageEx.Print();
    imageEx.Init();
    imageEx.Print();

    return 0;
}

运行结果：

从上例可以发现，如果我们自己给类的数据成员进行初始化函数，其实类的数据成员早就进行了一次默认初始化操作，这个初始化函数其实是一次额外的赋值。以这个类对象中的数组数据成员data为例，假使这个数组的容量很大，其额外的一次赋值操作对于底层来说，是不可忽略的性能开销。

那么使用构造函数的原因就很容易理解了，构造函数就是实现当类定义时初始化数据成员的，这样可以避免额外的初始化性能开销:

class ImageEx
{
public:
    ImageEx()
    {
        cout << "Default initialization!" << endl;
        Print();
        cout << "Execute the constructor!" << endl;
        Init();
    }

    void Print()
    {
        cout << imgWidth << '\t' << imgHeight << '\t' << bandCount << endl;
        for (int i = 0; i < 10; i++)
        {
            printf("%d\t", data[i]);
        }
        cout << endl;
    }

private:
    void Init()
    {
        imgWidth = 200;
        imgHeight = 100;
        bandCount = 3;
        memset(data, 0, 10 * sizeof(unsigned char));
    }

    int imgWidth;
    int imgHeight;
    int bandCount;

    unsigned char data[10];
};

int main()
{
    ImageEx imageEx;
    imageEx.Print();

    return 0;
}

进一步探究，构造函数本质是个函数，函数是由语句组成，已经定义的数据类型只能赋值初始化，而无法再进行构造。也就是说，在调用构造函数之前，数据成员还是已经默认初始化了：

因此，初始化最好的实现是使用构造函数的初始值列表：

class ImageEx
{
public:
    ImageEx() :
        imgWidth(200),
        imgHeight(100),
        bandCount(3),
        data{ 0, 1, 2 }
    {
        cout << "Execute the constructor!" << endl;
    }

    void Print()
    {
        cout << imgWidth << '\t' << imgHeight << '\t' << bandCount << endl;
        for (int i = 0; i < 10; i++)
        {
            printf("%d\t", data[i]);
        }
        cout << endl;
    }

private:
    int imgWidth;
    int imgHeight;
    int bandCount;

    unsigned char data[10];
};

int main()
{
    ImageEx imageEx;
    imageEx.Print();

    return 0;
}

运行结果：

通过这种实现，类中所有的数据成员都在定义时初始化，从而使类对象也实现了定义时初始化；避免了先定义后赋值的性能开销，体现了C++"零成本抽象（zero overhead abstraction）"的设计哲学。

上一篇

目录

下一篇