C++读书笔记2：C++基础（类、对象、构造与析构）

一、基本概念

1、类的定义和成员函数定义一般是分开的

类定义在头文件中，成员函数一般定义在源文件中。在类内定义的函数被默认成内联函数，这种函数一般要求尽量短小简单。另外，可以使用inline关键字声明一个函数是内联函数。

2、类成员的访问控制属性有三种：public、private和protected

- public属性的类成员可以在类的外部直接访问，一般用于定义成员函数。

- private属性表示类的私有成员，不能在类的外部直接访问，一般用于定义成员变量。

- protected属性表示类的受保护成员，基本上和private属性一致，不能在类的外部直接访问protected属性成员。

同时，protected与private区别主要用于基类和派生类之间的访问控制场景。具体如下：派生类可以访问基类的protected成员，但不能访问基类的private成员。基本上可以理解为访问的开放程度是：public > protected > private。（也许C++的设计师最早认为只需要public和private，在考虑继承关系的时候，才发现需要在两者之间增加一种新的访问控制的类型。）

【注：这里要完全理解类的访问控制属性，必须对类的继承有一点了解。由此可见，C++中的很多知识，前后耦合的非常紧密。再比如C++中友元的概念，如果不学习运算符重载，几乎完全无法理解友元函数的必要性。所以，对于任何一本经典的C++书籍，总会有人觉得其中各个章节的阅读顺序是反人类的，实际原因是C++的知识点前后紧密耦合，很难用简单的递进关系描述。】

3、构造函数

1. 构造函数没有返回值，包括void类型的返回值也不能有。

2. 构造函数有参数，函数可以重载，且通常都需要重载。

3. 构造函数不能是虚函数（构造函数准备执行的时候，虚表还没建立）

一个类（包括那种只包含纯虚函数的抽象类）正常情况都会有构造函数，如果不显示定义，编译器也会生成默认的。各种构造函数规则在后面单独描述。

构造函数是由编译器来安排调用的，如果在代码中显示调用一个构造函数的话将创建一个无名对象。所以，当有多个重载的构造函数时，构造函数之间不应该互相调用，可以单独写一个Initialize函数，完成构造函数的公共部分，然后让多个重载的构造函数调用Initialize函数。

4、析构函数

1. 析构函数没有返回值，没有参数，且不能重载。

2. 考虑到为了代码复用，类一般都会被继承，所以应该优先考虑将析构函数定义成虚函数。

一个类（包括那种只包含纯虚函数的抽象类）只能有且必须有一个析构函数，如果没有显式的定义，编译器会生成一个缺省的析构函数。如果，在类中显示声明了析构函数，就必须显示的把析构函数的函数体也定义出来。否则，编译器会报错。

5、每个类必须有一个构造函数，如果没有，编译器就自动生产一个没有参数的默认构造函数。如果已经显式定义了任意某种构造函数，则编译器不再提供默认构造函数。

【根据《深度探索C++对象模型》第47页所述，如果默认构造函数用不上，编译器是不会自动生成默认构造函数的。不过我觉得这一点无非是说明C++的设计师非常辛苦，为了保证C++的效率考虑了很多问题，将编译器设计的非常高效。但是对于普通程序员来讲似乎完全没有意义。】

6、如果一个类中包含多个其它类对象，则编译器会在类的构造函数代码之前插入调用其它类对象构造函数的代码（即成员对象先完成初始化，且按照成员类的声明顺序实现类成员的初始化）。

7、创建对象的时候，为构造函数传递参数

创建对象的时候，对象的构造函数是编译器自动插入调用的，用户不能显示调用。如果构造函数需要参数，可以考虑使用如下方式：

classname object（参数1，参数2，…），如果创建对象不需要参数，应该写成：classname object

classname* p = new classname(参数1，参数2，…)

new对象的时候，如果加了括号且无参数，表示调用没有参数的构造函数，不加括号则调用默认构造函数或唯一的构造函数。

8、如何给成员类的构造函数传递参数

如果框架类中还包含了成员类，一般情况下，创建框架类对象的时候，在框架类构造函数的入口，也就是框架类构造函数本身还没有执行的时候，编译器会自动插入成员类的构造函数。此时带来一个新问题就是如何给成员类的构造函数传递参数（如前所述，如果在框架类的构造函数中通过显式调用成员类的构造函数的方法为成员类的构造函数传递参数，就会和编译器自动插入的构造函数调用代码冲突），没有办法，C++定义了一种被称为初始化列表的新语法，具体如下：（这样，编译器在自动插入成员类的构造函数时就知道应该传递什么参数）

class Frame
{
    public:
        Frame(参数1, 参数2...)：成员类对象1（参数），成员类对象2（参数）
        {

        }
} 

如上所示，：表示对成员类或基类的构造函数进行调用，且传入的参数作为成员类或基类构造函数的参数（注意：这一切都是在Frame类定义的时候完成。另外这个语法还可以为常量和引用进行初始化。

建立一个概念是非常重要的：在构造函数中，对于对象成员的初始化发生在初始化列表中（即在初始化列表中调用成员类或基类的构造函数，初始化列表中成员类的排列顺序应该和声明的次序保持一致，这样可以解决成员类之间存在依赖关系的问题），所以，我们可以把初始化列表直接看做是对类成员的定义，而构造函数体中进行的则是类成员的赋值操作。所以不难理解有四种情况必须必须为类的构造函数建立初始化列表，详见《Effective C++ 第二版》条款12：

- 有const类型成员

- 有引用类型成员（这里可以理解为引用就是一个const指针）

- 成员类没有默认构造函数（即必须提供参数）

- 基类没有默认构造函数（即必须提供参数，后面详细描述）

前两者要求定义时初始化，所以必须明确的在初始化队列中给它们提供初值。后两者因为没有默认构造函数（需要有参数的构造函数），所以必须通过初始化列表指定成员对象或基类初始化需要的参数。

9、const函数：

如果类的某个成员函数不会修改类本身的数据成员，那么最好将其声明为const函数

class Frame
{
    public:
        int Memberfunc(int a) const;// const函数
        int Memberfunc(int a);      // 非const函数
} 

函数后面的const用于修饰this指针，因为函数的参数类型参与函数签名，所以，同名的const和非const函数之间属于重载关系。

在《深度探索C++对象模型》第5章195页描述，对于虚函数，本身就是给继承类实现的，是否需要修改数据成员，基类不好去判断，所以虚函数不应该声明为const函数。

const函数的原始目的应该是用户有可能定义一个类的常量对象，因为常量对象是不能改变的，此时常量对象就只能够调用自己的const成员函数，不能调用自己的非const成员函数，所以说const成员函数可以为C++编译器做合法性判断。另外，const成员函数还可以使接口容易被理解、消除误操作的隐患。

10、类的静态成员

类的全部对象共享类的静态数据成员，这个特性可以解决以前C代码中大量存在的全局变量的问题。静态数据成员必须在类声明的外部定义（分配空间并初始化）。

每一个类一般都有一个头文件声明类，还有一个源文件定义类的实现，一般类的静态成员变量就应该在这个类的源文件中完成定义即分配空间（即谁的孩子谁抱走，放在其它地方真心不合适）。例如：

// .h文件,类的头文件中声明
class Frame
{
    public:
        static int m_staticMember;
};

// .cpp文件,类的源文件中定义, 注意这里在定义的时候不能用static。
int Frame::m_staticMember = 1;

在类对象的数据空间里一定不包含静态数据成员，这样才能保证静态数据成员不会随着类对象的释放而消失。同理，静态数据成员的空间分配和初始化也与类的构造函数无关。

前面分析了静态成员变量的定义，接着问题来了，C++的成员变量除了pubilc属性，还有private和protected，如果静态成员变量是private或protected属性，则只能由类成员函数访问。就是静态成员函数来解决私有静态成员变量的访问。静态成员函数定义如下：

class Frame
{
    public:
        static int functionName();
};

静态成员函数在声明的时候必须有static 关键字，但是在类的外部定义函数体的时候不能有static 关键字。

静态成员函数没有this指针，所以静态成员函数对任何非静态成员的访问都是非法的。

静态成员函数不能够直接存取其类中的非静态成员（nostatic members），包括不能调用非静态 成员函数(Nonstatic Member Functions)。

静态成员函数不能被声明为 const、voliatile或virtual。

调用静态成员函数可以像调用普通函数一样，不需要通过对象调用，当然，通过对象调用也是允许的。

11、类的友元

友元是一种定义在一个类的外部的普通函数或类，但它需要在类体内进行声明，使用关键字friend修饰。友元函数或友元类可以访问目标类中全部的成员包括私有和保护成员。

class Frame
{
    public:
        int function1();
        int function2();
        int function3();

        friend int outsideFunc(Frame&); // 声明友元函数
};

int outsideFunc(Frame&) // 定义友元函数
{
    return 0;
}

根据《C++ primer plus第六版》描述：友元函数的一个重要应用场景是用于针对运算符重载，且第一个参数的类型不是类本身的情况（例如：operator<< 和 operator>>）。所以，友元函数的详细描述放在运算符重载的地方。

二、构造函数的种类与作用

1、默认构造函数：”构造函数无参数或者所有参数都有默认值，这种构造函数被称为默认构造函数。

按照《深度探索C++对象模型》中的描述，如果用户没有定义类的任何构造函数，而类的实现又确实需要构造函数，此时编译器才会自动生成默认构造函数。那什么情况下必须使用默认构造函数呢：

“通常当用户需要定义对象的数组时，就会需要一个默认构造函数”【见《Effective C++ 第二版》第5~6页】。

例如声明一个数组包含10个classA的对象：classA a[10]，这个表达式中无法传递参数，这就要求编译器自动插入一个无参数的构造函数（即默认构造函数）用来完成数组元素的构造。（千万不要想classA a[10]（5）这种方式，这种想法太猥琐，C++设计师不会同意的。）

如果就是不想用默认构造函数，另外还有两种方法创建对象数组：

方式1：定义对象的指针数组，再通过new（调用普通构造函数）完成每个元素的初始化

// .h文件
class A  
{  
private:  
    int m_x;  
public:  
    A(int x):m_x(x){}  
    ~A() {}  
};  

// .cpp文件
A *pA[10];     // 定义对象的指针数组
for (int i=0; i<10; i++)
{
    pA[i]=new A(5); // 数组的每个元素分创建
}

方式2：采用placement new，形如：new (指向地址的指针)classname(参数列表)

int size = sizeof(A);
char* buff = new char[size * 10];
for (int i=0; i<10; i++)
{
    new (buff + (i*size))A(5);
}

2、一般构造函数：有参数的构造函数，也称为重载构造函数，必须由用户定义，编译器不会自动生成

3、拷贝构造函数

拷贝构造函数，又称复制构造函数，是一种特殊的构造函数，它由编译器自动调用，用来完成使用一个类的已存在对象构建（初始化）这个类的一个新对象。拷贝构造函数的形式如下，函数的名称必须和类名称一致，它唯一的参数是本类型对象的引用

classname（const classname&）

这里的参数类型可以不是const类型，但是建议使用const，因为函数的形参是const，在调用的时候。既可以接收const类型的实参，也可以接收非const类型的实参，适用性更强。

编译器需要拷贝构造函数的场景有三种：

1. 一个对象作为函数参数，以传值的方式传入函数体

2. 一个对象作为函数返回值，以传值的方式从函数返回

3. 一个对象用于给另外一个对象进行初始化

如果在类中没有显式的声明一个拷贝构造函数，那么，编译器会自动生成一个默认拷贝构造函数来进行对象之间非static成员的按位拷贝（也被称为浅拷贝）。

如果类的数据成员中有指针变量，且这个类需要负责这些指针所指向资源的回收。如果采用默认拷贝构造函数（浅拷贝方式）会出现两个对象拥有同一个资源，当销毁这两个对象时，这些资源面临重复释放的问题。针对这种情况，就需要用户自己显示定义拷贝构造函数实现资源的单独申请即深拷贝。

拷贝构造函数举例

class A
{
public:
    A(const A& rRhs);  // 声明拷贝构造
}

class A::A(const A& rRhs)
{
    // 需要自己维护的指针数据成员，单独申请资源

    // 其它数据成员，从rRhs中获取并复制
}

禁止拷贝构造函数

还是关于一个包含指针变量的类，可以通过定义禁止拷贝/赋值构造，有效的防止这个类的对象以传值的方式传入另外一个函数。具体的方法就是：将赋值构造函数和拷贝构造函数声明为private属性，且不实现。

class A
{
private:
    A(const A& rRhs);             // 只声明不实现，表示禁止拷贝构造
    A& operator=(const A& rRhs);  // 禁止赋值
}

4、赋值运算符重载函数（也被称为赋值构造函数）

赋值构造函数本质上就是赋值运算符的重载函数，把一个已存在的对象赋值给另一个已存在的对象的时候，编译器需要自动调用赋值运算符重载函数，如果用户没有显示定义这个函数，编译器就会自动生成一个默认的赋值运算符重载函数。

为了实现连续赋值，赋值运算符（=）重载函数的返回值应该返回一个“引用”指向操作符的左侧实参。

String & String::operator=(const String &other)
{
    if (this == &other)
    {
        return *this;
    }
    else
    {
        delete [] m_data;
        m_data = new char[length + 1];
        strcpy(m_data, other.m_data);
        return *this;
    }
}

赋值运算符重载函数的写法

- 赋值函数中，函数入口判断 this == &other 是很必要的，可以防止自复制.【《Effective C++ 第二版》条款17：因为赋值运算符重载函数在给左侧对象配置新资源之前，必须将左侧对象原先配置的资源释放掉。如果左右都是自己，这个资源释放的动作就会造成一场灾难。】

- 赋值函数中，接着要释放掉m_data，否则就没机会了

- 为了实现连续赋值，赋值函数的返回值应该返回一个“引用”指向操作符的左侧实参，即this对象的引用。

【注：写到这里，赋值运算符重载函数的内容似乎已经很多了。但实际情况是，对于继承类的赋值运算符函数，又有新的问题需要注意，因为现在还没有介绍类的继承，所以无法继续深入了，只能放在后面再讲。有兴趣可参考《Effective C++ 第二版》条款16第69页】

5、类型转换构造函数

类型转换构造函数其实就是只有一个参数的一般构造函数。如果存在这种单参数的构造函数，C++编译器会默认支持从参数类型到类类型的自动转换。但是，有时候这种编译器背后的类型转换并不是是我们想要的，所以C++又引入了一个新的关键字explicit来限制这种转换。

class A
{
public:
    A(int num):m_x(num){}

private:
    int m_x;
};

A obj = 10; //ok,convert int to Class A

在上面的代码中编译器自动将整型转换为类A的对象，实际上等同于下面的操作：

A temp(10);
A obj = temp;

上面的转换过程也被称为”隐式转换”。通过explicit关键字可以避免这种自动转换功能，如果我们修改上面类的构造函数为声明的，那么同样的代码就不能够编译通过了，如下所示：

class A
{
public:
    explicit A(int num):m_x(num){}

private:
    int m_x;
};

A obj = 10; // error,编译器在这里将产生编译错误