从C向C++4——对象特性

一.构造函数

1.构造函数

在C++中，有一种特殊的成员函数，它的名字和类名相同，没有返回值，不需要用户显式调用（用户也不能调用），而是在创建对象时自动执行。这种特殊的成员函数就是构造函数（Constructor）。

我们通过成员函数 setname()、setage()、setscore() 分别为成员变量 name、age、score 赋值，这样做虽然有效，但显得有点麻烦。有了构造函数，我们就可以简化这项工作，在创建对象的同时为成员变量赋值，请看下面的代码：

#include <iostream>
using namespace std;
class Student{
private:
    char *m_name;
    int m_age;
    float m_score;
public:
    //声明构造函数
    Student(char *name, int age, float score);
    //声明普通成员函数
    void show();
};
//定义构造函数
Student::Student(char *name, int age, float score){
    m_name = name;
    m_age = age;
    m_score = score;
}
//定义普通成员函数
void Student::show(){
    cout<<m_name<<"的年龄是"<<m_age<<"，成绩是"<<m_score<<endl;
}
int main(){
    //创建对象时向构造函数传参
    Student stu("黄绍强", 20, 88.5f);
    stu.show();
    //创建对象时向构造函数传参
    Student *pstu = new Student("李明", 16, 96);
    pstu -> show();
    return 0;
}

该例在 Student 类中定义了一个构造函数Student(char *, int, float)，它的作用是给三个 private 属性的成员变量赋值。要想调用该构造函数，就得在创建对象的同时传递实参，并且实参由( )包围，和普通的函数调用非常类似。

在栈上创建对象时，实参位于对象名后面，例如Student stu("小明", 15, 92.5f)；在堆上创建对象时，实参位于类名后面，例如new Student("李华", 16, 96)。

构造函数必须是 public 属性的，否则创建对象时无法调用。当然，设置为 private、protected 属性也不会报错，但是没有意义。

构造函数没有返回值，因为没有变量来接收返回值，即使有也毫无用处，这意味着：

• 不管是声明还是定义，函数名前面都不能出现返回值类型，即使是 void 也不允许；
• 函数体中不能有 return 语句。

2.构造函数重载

和普通成员函数一样，构造函数是允许重载的。一个类可以有多个重载的构造函数，创建对象时根据传递的实参来判断调用哪一个构造函数。

构造函数的调用是强制性的，一旦在类中定义了构造函数，那么创建对象时就一定要调用，不调用是错误的。如果有多个重载的构造函数，那么创建对象时提供的实参必须和其中的一个构造函数匹配；反过来说，创建对象时只有一个构造函数会被调用。

对示例1中的代码，如果写作Student stu或者new Student就是错误的，因为类中包含了构造函数，而创建对象时却没有调用。

3.默认构造函数

如果用户自己没有定义构造函数，那么编译器会自动生成一个默认的构造函数，只是这个构造函数的函数体是空的，也没有形参，也不执行任何操作。比如上面的 Student 类，默认生成的构造函数如下：

Student(){}

一个类必须有构造函数，要么用户自己定义，要么编译器自动生成。一旦用户自己定义了构造函数，不管有几个，也不管形参如何，编译器都不再自动生成。在示例1中，Student 类已经有了一个构造函数Student(char *, int, float)，也就是我们自己定义的，编译器不会再额外添加构造函数Student()。

**最后需要注意的一点是，调用没有参数的构造函数也可以省略括号。**对于示例的代码，在栈上创建对象可以写作Student stu()或Student stu，在堆上创建对象可以写作Student *pstu = new Student()或Student *pstu = new Student，它们都会调用构造函数 Student()。以前我们就是这样做的，创建对象时都没有写括号，其实是调用了默认的构造函数。

4.初始化列表

构造函数的一项重要功能是对成员变量进行初始化，为了达到这个目的，可以在构造函数的函数体中对成员变量一一赋值，还可以采用初始化列表。

//采用初始化列表
Student::Student(char *name, int age, float score): m_name(name), m_age(age), m_score(score){
    //TODO:
}

本例所示，定义构造函数时并没有在函数体中对成员变量一一赋值，其函数体为空（当然也可以有其他语句），而是在函数首部与函数体之间添加了一个冒号:，后面紧跟m_name(name), m_age(age), m_score(score)语句，这个语句的意思相当于函数体内部的m_name = name; m_age = age; m_score = score;语句，也是赋值的意思。

使用构造函数初始化列表并没有效率上的优势，仅仅是书写方便，尤其是成员变量较多时，这种写法非常简单明了。

初始化列表可以用于全部成员变量，也可以只用于部分成员变量。下面的示例只对 m_name 使用初始化列表，其他成员变量还是一一赋值：

Student::Student(char *name, int age, float score): m_name(name){
    m_age = age;
    m_score = score;
}c

5.初始化const成员变量

构造函数初始化列表还有一个很重要的作用，那就是初始化 const 成员变量。初始化const成员变量的唯一方法就是使用初始化列表。例如 VS/VC 不支持变长数组（数组长度不能是变量），我们自己定义了一个 VLA 类，用于模拟变长数组，请看下面的代码：

class VLA{
private:
    const int m_len;
    int *m_arr;
public:
    VLA(int len);
};
//必须使用初始化列表来初始化 m_len
VLA::VLA(int len): m_len(len){
    m_arr = new int[len];
}

VLA 类包含了两个成员变量，m_len 和 m_arr 指针，需要注意的是 m_len 加了 const 修饰，只能使用初始化列表的方式赋值，如果写作下面的形式是错误的：

VLA::VLA(int len){
    m_len = len;
    m_arr = new int[len];
}

6.构造函数的分类

两种方式分类：

• 按参数分为：有参构造和无参构造（默认构造）
• 按类型分为：普通构造和拷贝构造

先来说一下分类，第一种方式比较好理解，看一下第二种，平时我们写的绝大多数构造函数都是普通构造函数，而拷贝构造函数顾名思义就是复制的意思，假设现在有一个Person类，实例化一个对象张三，现在要构造一个新的对象李四，我们现在把张三的所有成员复制（拷贝）给李四，这样的构造函数就叫拷贝构造：

class Person{
    …………………//此处省略其他成员属性或方法的定义
public:
    Person(Person p){
        m_age=p.age;
    }

拷贝构造函数的参数是一个Person的实例化对象，凡是其参数不为Person类型的其余构造函数，我们都叫他普通构造函数。原理上拷贝构造函数是上面这么写的，但是实际上我们不能因为拷贝而改变原来的属性，所哟修改的代码为：

class Person{
    …………………//此处省略其他成员属性或方法的定义
public:
    Person( const Person &p){
        m_age=p.age;
    }

即采用const关键字修饰的引用传递方式来保证原来的实参不发生改变。

7.构造函数的调用

三种调用方式：

• 括号法
• 显示法
• 隐式转换法

第一种括号法调用应该很常见，我们平时使用的函数调用基本都是括号法，但是有一个注意事项：采用括号法调用默认构造函数时请不要带括号，比如Person p而不是Person p()，具体结果差异自行探索，原因是后者计算机会把它当作一个函数的声明。

显示法中，看一下啊下面代码：

Person p2 = Person (10);   //显示调用普通构造函数
Person p3 = Person (p2);   //显示调用拷贝构造函数

其实其就相当于构造一个匿名对象，通过赋值把匿名对象属性给新的对象。这里有两个注意事项：

• 匿名对象在执行当前行代码时被创建，在执行完当前行代码时被回收；
• 不要利用拷贝构造函数初始化匿名对象

隐式调用在我看来是相当抽象的，比如Person p2 =10这就是一种隐式转换，在我们看来左右两边都不是一个类型的数据，事实上它等价于Person p2 = Person(10)，反正我们平时大多数程序员写的都是括号法，直观且容易理解。

二.拷贝

上一部分我们知道了拷贝构造函数，这一部分来深挖以下拷贝构造函数。

1.拷贝构造函数的调用时机

C++中拷贝构造函数调用时机通常有三种情况：

• 使用一个已经创建完毕的对象来初始化一个新对象
• 值传递的方式给函数参数传值
• 以值方式返回局部对象

2.构造函数调用规则

默认情况下，c++编译器至少给一个类添加3个函数：

• 默认构造函数(无参，函数体为空)
• 默认析构函数(无参，函数体为空)
• 默认拷贝构造函数，对属性进行值拷贝

构造函数调用规则如下：

• 如果用户定义有参构造函数，c++不在提供默认无参构造，但是会提供默认拷贝构造
• 如果用户定义拷贝构造函数，c++不会再提供其他构造函数

3.深拷贝与浅拷贝

深浅拷贝是面试经典问题，也是常见的一个坑。

• 浅拷贝: 简单的赋值拷贝操作
• 深拷贝: 在堆区重新申请空间，进行拷贝操作

总结: 如果属性有在堆区开辟的，一定要自己提供拷贝构造函数，防止浅拷贝带来的问题

深拷贝与浅拷贝参考视频

三.析构函数

创建对象时系统会自动调用构造函数进行初始化工作，同样，销毁对象时系统也会自动调用一个函数来进行清理工作，例如释放分配的内存、关闭打开的文件等，这个函数就是析构函数。

析构函数（Destructor）也是一种特殊的成员函数，没有返回值，不需要程序员显式调用（程序员也没法显式调用），而是在销毁对象时自动执行。构造函数的名字和类名相同，而析构函数的名字是在类名前面加一个~符号。

注意：析构函数没有参数，不能被重载，因此一个类只能有一个析构函数。如果用户没有定义，编译器会自动生成一个默认的析构函数。

析构函数在对象被销毁时调用，而对象的销毁时机与它所在的内存区域有关。

在所有函数之外创建的对象是全局对象，它和全局变量类似，位于内存分区中的全局数据区，程序在结束执行时会调用这些对象的析构函数。

在函数内部创建的对象是局部对象，它和局部变量类似，位于栈区，函数执行结束时会调用这些对象的析构函数。

new 创建的对象位于堆区，通过 delete 删除时才会调用析构函数；如果没有 delete，析构函数就不会被执行。所以我们需要自己编写带delete关键字的析构函数来释放new创建的空间。

四.对象特性

1.对象数组

C++ 允许数组的每个元素都是对象，这样的数组称为对象数组。

对象数组中的每个元素都需要用构造函数初始化。具体哪些元素用哪些构造函数初始化，取决于定义数组时的写法：

#include<iostream>
using namespace std;

class CSample {
public:
    CSample() {  //构造函数 1
        cout << "调用默认构造函数" << endl;
    }
    CSample(int n) {  //构造函数 2
        cout << "调用有参构造函数" << endl;
    }
};

int main() {
    cout << "stepl" << endl;
    CSample arrayl[2];

    cout << "step2" << endl;
    CSample array2[2] = { 4, 5 };

    cout << "step3" << endl;         
    CSample array3[2] = { 3 };

    cout << "step4" << endl;
    CSample* array4 = new CSample[2];
    delete[] array4;

    return 0;
}

执行结果：

stepl 调用默认构造函数 调用默认构造函数 step2 调用有参构造函数 调用有参构造函数 step3 调用有参构造函数 调用默认构造函数 step4 调用默认构造函数 调用默认构造函数

上面可以自行分析。

2.封闭类

一个类的成员变量如果是另一个类的对象，就称之为“成员对象”。包含成员对象的类叫封闭类（enclosed class）。

上一节的案例练习中我们在圆内就有点类，所以圆类是一个封闭类。

创建封闭类的对象时，它包含的成员对象也需要被创建，这就会引发成员对象构造函数的调用。如何让编译器知道，成员对象到底是用哪个构造函数初始化的呢？这就需要借助封闭类构造函数的初始化列表。

构造函数初始化列表的写法如下：

类名::构造函数名(参数表): 成员变量1(参数表), 成员变量2(参数表), ...
{
  //TODO:
}

对于基本类型的成员变量，“参数表”中只有一个值，就是初始值，在调用构造函数时，会把这个初始值直接赋给成员变量。

但是对于成员对象，“参数表”中存放的是构造函数的参数，它可能是一个值，也可能是多个值，它指明了该成员对象如何被初始化。

总之，生成封闭类对象的语句一定要让编译器能够弄明白其成员对象是如何初始化的，否则就会编译错误。

这一部分一定要结合各种例子来看，可以在相关网站寻找例子理解。

笔试重点：

封闭类对象生成时，先执行所有成员对象的构造函数，然后才执行封闭类自己的构造函数。成员对象构造函数的执行次序和成员对象在类定义中的次序一致，与它们在构造函数初始化列表中出现的次序无关。

当封闭类对象消亡时，先执行封闭类的析构函数，然后再执行成员对象的析构函数，成员对象析构函数的执行次序和构造函数的执行次序相反，即先构造的后析构，这是 C++ 处理此类次序问题的一般规律。

3.静态成员

静态成员就是在成员变量和成员函数前加上关键字static，称为静态成员 静态成员分为:

• 静态成员变量

• 所有对象共享同一份数据
• 在编译阶段分配内存
• 类内声明，类外初始化

• 静态成员函数

• 所有对象共享同一个函数
• 静态成员函数只能访问静态成员变量

4.静态成员变量

对象的内存中包含了成员变量，不同的对象占用不同的内存，这使得不同对象的成员变量相互独立，它们的值不受其他对象的影响。例如有两个相同类型的对象 a、b，它们都有一个成员变量 m_name，那么修改 a.m_name 的值不会影响 b.m_name 的值。

可是有时候我们希望在多个对象之间共享数据，对象 a 改变了某份数据后对象 b 可以检测到。共享数据的典型使用场景是计数，以前面的 Student 类为例，如果我们想知道班级中共有多少名学生，就可以设置一份共享的变量，每次创建对象时让该变量加 1。

static 成员变量属于类，不属于某个具体的对象，即使创建多个对象，也只为 m_total 分配一份内存，所有对象使用的都是这份内存中的数据。当某个对象修改了 m_total，也会影响到其他对象。

static 成员变量必须在类声明的外部初始化，具体形式为：

type class::name = value;

type 是变量的类型，class 是类名，name 是变量名，value 是初始值。将上面的 m_total 初始化：

int Student::m_total = 0;

静态成员变量在初始化时不能再加 static，但必须要有数据类型。被 private、protected、public 修饰的静态成员变量都可以用这种方式初始化。

注意：static 成员变量的内存既不是在声明类时分配，也不是在创建对象时分配，而是在（类外）初始化时分配。反过来说，没有在类外初始化的 static 成员变量不能使用。

static 成员变量既可以通过对象来访问，也可以通过类来访问。

几点说明：

• 1.一个类中可以有一个或多个静态成员变量，所有的对象都共享这些静态成员变量，都可以引用它。
• 2.static 成员变量和普通 static 变量一样，都在内存分区中的全局数据区分配内存，到程序结束时才释放。这就意味着，static 成员变量不随对象的创建而分配内存，也不随对象的销毁而释放内存。而普通成员变量在对象创建时分配内存，在对象销毁时释放内存。
• 3.静态成员变量必须初始化，而且只能在类体外进行。
• 4.静态成员变量既可以通过对象名访问，也可以通过类名访问，但要遵循 private、protected 和 public 关键字的访问权限限制。当通过对象名访问时，对于不同的对象，访问的是同一份内存。

5.静态成员函数

在类中，static 除了可以声明静态成员变量，还可以声明静态成员函数。普通成员函数可以访问所有成员（包括成员变量和成员函数），静态成员函数只能访问静态成员。

编译器在编译一个普通成员函数时，会隐式地增加一个形参 this，并把当前对象的地址赋值给 this，所以普通成员函数只能在创建对象后通过对象来调用，因为它需要当前对象的地址。而静态成员函数可以通过类来直接调用，编译器不会为它增加形参 this，它不需要当前对象的地址，所以不管有没有创建对象，都可以调用静态成员函数。

普通成员变量占用对象的内存，静态成员函数没有 this 指针，不知道指向哪个对象，无法访问对象的成员变量，也就是说静态成员函数不能访问普通成员变量，只能访问静态成员变量。

普通成员函数必须通过对象才能调用，而静态成员函数没有 this 指针，无法在函数体内部访问某个对象，所以不能调用普通成员函数，只能调用静态成员函数。

面试重点：

静态成员函数与普通成员函数的根本区别在于：普通成员函数有 this 指针，可以访问类中的任意成员；而静态成员函数没有 this 指针，只能访问静态成员（包括静态成员变量和静态成员函数）。

6.this指针

this是 C++ 中的一个关键字，也是一个const指针，它指向当前对象，通过它可以访问当前对象的所有成员。所谓当前对象，是指正在使用的对象。例如对于stu.show();，stu 就是当前对象，this 就指向 stu。

我们知道在C++中成员变量和成员函数是分开存储的，当你使用sizeof计算一个类的大小时，只计算成员属性的大小，每一个非静态成员函数只会诞生一份函数实例，也就是说多个同类型的对象会共用一块代码。

那么问题是: 这一块代码是如何区分那个对象调用自己的呢？c++通过提供特殊的对象指针，this指针，解决上述问题。this指针指向被调用的成员函数所属的对象，this指针是隐含每一个非静态成员函数内的一种指针。this指针不需要定义，直接在非静态成员函数内使用即可。

注意：

• this 只能用在类的内部，通过 this 可以访问类的所有成员，包括private、protected、public属性的。
• this 是一个指针，要用->来访问成员变量或成员函数。

this指针的用途：

• 当形参和成员变是同名时，可用this指针来区分
• 在类的非静态成员函数中返回对象本身，可使用return *this，其对应的函数类型应该为类&，即类的引用方式来声明函数类型。