重学C++学习笔记（二）

接上一篇，本篇主要是面向对象相关的知识点

类

C++可以使用struct和class定义一个类

// 默认为public权限
struct Person {
    int age;
    void run {
        cout << "person run" << endl;
    }
};

// 默认为private，需要显示声明public
class Person {
public:
    int age;
    void run {
        cout << "person run" << endl;
    }
}

struct和class的区别: class默认权限为private，struct默认权限为public，推荐使用class

嵌套类

C++中类支持嵌套定义，本质是语法糖，用于限制作用域

class Person {
    class Car {

    }
}

void func() {
    // 局部类，可以在函数内使用
    class Point {
        int x;
        int y;
    }
}

函数调用

Person p;
p.age = 20;
p.run();

转成汇编

mov d word ptr [ebp-0Ch], 0Ah

; 传递调用者到exc，也就是p
lea ecx, [ebp-0Ch]

; 调用函数
call 00061366

C++对象的内存结构如下

对象的本质，其实就是字段（和虚表指针）的内存集合，先定义的对象会放在低地址，后定义的对象防止高地址

this

this是调用对象的地址，为指针，当对象调用成员函数的时候，会自动传入当前对象的指针

class Person {
private:
    int m_age;
public:
    void func() {
        this -> m_age = 0;
        // 编译成汇编
        // 0x10c9c2f7c <+12>: movl   $0x0, (%rax)       ; 取到寄存器rdx存放的地址，给该地址赋值0
    }
};

int main() {
    Person p = Person();
    p.func();
    return 0;

    // 生成汇编（AT&T）
    // 0x10c9c2f50 <+32>: movq   %rax, -0x10(%rbp)         ; 设置p变量
    // 0x10c9c2f54 <+36>: callq  0x10c9c2f8a               ; 初始化Person的内存
    // 0x10c9c2f59 <+41>: movq   -0x10(%rbp), %rdi         ; 将p的地址赋值给寄存器rdi
    // 0x10c9c2f5d <+45>: callq  0x10c9c2f84               ; 调用函数

}

由汇编可以看出，通过寄存器传递this指针，this指针存放对象的地址

堆空间初始化

int *p1 = new int;          // 不会被初始化
int *p2 = new int();        // 初始化为0
int *p3 = new int(5);       // 初始化为5
int *p4 = new int[3];       // 数组未被初始化
int *p5 = new int[3]();     // 数组元素都被初始化为0
int *p6 = new int[3]{};     // 数组元素都被初始化为0
int *p7 = new int[3] {5};   // 数组首元素被初始化为5，其他被初始化为0

Person *p8 = new Person;        // 成员变量不会被初始化
Person *p9 = new Person();      // 成员变量默认被初始化为0，或调用构造函数

对象内存分布

// 全局变量，全局区
Person g_person;

int main() {
    // 局部变量，栈空间
    Person person;

    // 手动申请内存，堆空间
    Person *p = new Person();
    return 0;
}

构造函数/析构函数

构造函数支持重载

struct Person {
    int m_age;
    Person() {
        m_age = 10;
    }

    // 重载构造函数
    Person(int age) {
        m_age = age;
    }

    // 析构函数，只有一个
    ~Person() {
        // 对象释放之前调用
    }
};

Person person(20);
cout << person.age << endl;

如果自定义了构造函数，除了全局区（默认会初始化为0），其他内存空间的成员变量都需要手动初始化

struct Person {
    int age;
    Person() {
        // age的值不确定，需要手动初始化age变量

        // 所有成员初始化为0
        msmset(this, 0, sizeof(Person));
    }
};

构造函数和析构函数必须是public，如果定义为private，则该类无法被外部创建
构造函数先调用父类，后调用子类
析构函数先调用子类，后调用父类

成员访问权限

权限与JAVA一样，对类的成员变量声明权限（struct默认为public，class默认为private）

• public：公开访问（struct默认）
• protected：当前类和子类访问
• private：私有（class默认）

继承关系也可以添加权限，表示继承的成员对子类的权限，struct默认为public，class默认为private，class要手写public

// Student的子类不能访问Person的成员，叠加权限使用最小权限
struct Student: private Person {
    int m_score;
};

初始化列表

struct Person {
    int m_age;
    int m_height;

    // Person(int age, int height) {
    //     m_age = age;
    //     m_height = height;
    // }

    // 与上面构造方法等价
    Person(int age, int height): m_age(age), m_height(height) {

    }
};

初始化顺序跟成员变量的声明顺序有关系，和列表顺序无关，下面写法是一样的

Person(int age, int height): m_age(age), m_height(height) { }

// 与上面等价，先初始化m_age，再初始化m_height
Person(int age, int height): m_height(height), m_age(age) { }

构造函数互相调用

struct Person {
    int m_age;
    int m_height;

    // 必须写在后面
    Person() : Person(0, 0) {
        // 这里相当于创建一个新的对象
        // Person(0, 0);
    }

    Person(int age, int height) {
        m_age = age;
        m_height = height;
    }
};

父类的构造函数

struct Person {
private:
    int m_age;
    Person() {
        m_age = 0;
    }

    Person(int age): m_age(age) {

    }
};

struct Student : Person {
    // 默认是调用无参构造函数
    // Student() : Person() {

    // 显示调用父类构造函数
    Student() : Person(10) {

    }
};

• 如果父类没有构造函数，则不调用
• 如果父类有构造函数，子类没有定义构造函数，则子类会隐式生成构造函数，并且调用父类的构造函数

调用父类方法

继承关系中调用父类方法，通过类名调用

class Person {
public:
    void func() { }
}

class Student: public Person {
public:
    void func() {
        // 调用父类方法，相当于swift的super.func()
        Person::func();
    }

    //运算符重载
    Student &operator=(const Student &student) {
        // 调用父类的方法
        Person::operator=(student);
        ...
    }
}

拷贝构造函数

class Person {
public:
    int m_age;

    // 默认无参构造函数
    Person() {}

    // 拷贝构造函数，赋值操作会调用拷贝构造函数
    Person(const Person &person): m_age(person.m_age) { }
};

int main() {
    // p1, p2通过无参构造函数构造
    Person p1 = Person();
    Person p2;

    // p3, p4通过拷贝构造函数构造
    Person p3 = p1;
    Person p4(p1);

    // 非初始化赋值，直接做变量内存拷贝，不会调用构造函数
    p2 = p1;
    return 0;
}

隐式构造

class Person {
private:
    int m_age;
public:
    Person(int age): m_age(age) { }
};

Person p1(10);

// 隐式构造，相当于：Person p2 = Person(20)
Person p2 = 20;

可读性差，尽量不用，可以通过关键字explicit禁用隐式构造

// 不能通过 Person p2 = 20; 构造
explicit Person(int age): m_age(age) { }

自动生成构造函数

在下面情况下，编译器会自动为类生成无参构造函数

• 父类存在构造函数，子类没有定义构造函数
• 虚继承（需要做虚表指针的初始化）
• 有虚函数（需要做虚表指针的初始化）
• 类包含了有构造函数的成员，并且没有定义构造函数，则编译器会自动生成构造函数初始化成员
• 类的字段在声明的时候进行了初始化

仿函数

相当于直接调用对象，本质是重载()运算符

class Sum {
public:
    int operator()(int a, int b) {
        return a + b;
    }
}

auto sum = Sum();
// res = 30
auto res = sum(10, 20);

深拷贝/浅拷贝

• 浅拷贝: 编译器默认提供的拷贝为浅拷贝，将一个对象所有成员变量的值拷贝到另一个对象（指针变量只拷贝地址，不会拷贝指针指向的内存空间），浅拷贝会带来一个问题，就是多次free的问题

  class Car {
  public:
      Car() {}
  };
  
  class Person {
  private:
      int m_age;
      Car *car;
  public:
      Person() {
          car = new Car();
      }
      ~Person() {
          if (car != nullptr) {
              delete car;
              car = nullptr;
          }
      }
  };
  
  int main() {
      {
          // 下面代码会导致Person的析构函数调用了两次
          Person p1 = Person();
          Person p2 = p1;
      }
  }

• 深拷贝：需要自定义拷贝构造函数实现，手动将指针类型的变量指向的内容拷贝一份新的

多态

C++的多态通过虚函数来实现

虚函数

需要在父类方法实现virtual函数才能使用多态，否则不是多态（不加virtual，编译器直接根据类型调用对应的函数）

struct Animal {
    void speak() {
        cout << "animal speak" << endl;
    }
};

struct Dog: Animal {
    // 子类不用声明virtual，默认就是虚函数
    void speak() {
        cout << "dog speak" << endl;
    }
};

void func(Animal *ani) {
    // 由于speak是普通函数，编译之后，会直接调用Animal::speak
    ani.speak();
    // call [0A3C] ; Animal::speak
}

int main() {
    Dog *dog = new Dog();
    func(dog);
    // 输出 animal speak，而我们希望输出 dog speak

    delete dog;
    return 0;
}

修改Animal::speak改为virtual

struct Animal {
    virtual void speak() {
        cout << "animal speak" << endl;
    }
};

// 输出 `dog speak`

• 纯虚函数：没有实现的虚函数，后面用等于0
• 抽象类：含有纯虚函数的类，抽象类不能被实例化

struct Animal {
    // 纯虚函数，等于0是固定写法
    virtual void speak() = 0;
    virtual void run() = 0;
}

虚表

虚函数的多态特性是通过虚表来实现的，如果一个类对象有虚函数，则会多4或8个字节，32或64位环境不同，并且多出来的内存是放在对象首地址

struct Animal {
    int m_age;
    virtual void speak() {
        cout << "animal speak" << endl;
    }

    virtual void run() {
        cout << "animal run" << endl;
    }
};

cout << sizeof(Animal) << endl;
// 输出8 (4 + 4）(x86环境)

原理：多出的4/8个字节用来存储虚函数表的地址，虚函数表存放着对象的虚函数地址，编译器在运行时通过该表，找到对应的函数地址执行，从而达到多态的目的

Animal *ani = new Dog();
// speak是虚函数
ani.speak();

// 编译为汇编
// mov eax, dword ptr [epb-8]       ; [epb-8]是ani指向的地址，即Dog的地址
// mov edx, dword ptr [eax]         ; 取出eax头4个自己的值（即虚表地址），存放到edx
// mov eax, dword ptr [edx]         ; 取出edx的前4个字节（即虚表中的第一个函数地址），存放到eax
// call eax                         ; 调用寄存器eax指向的函数地址

ani.run();

// 转成汇编和speak方法是一样的，在从虚表取函数地址的时候，会加上对应的偏移量
// mov eax, dword ptr [edx+4]         ; 从edx地五个字节开始读（即虚表中的第二个函数地址），存放到eax

从汇编代码可以看出，虚函数的调用过程

1. 通过对象存放的虚表地址（对象首地址）
2. 通过虚表地址找到虚表，从虚表中找到对应函数的地址
3. 调用函数

同个类所有对象共用一份虚表，不管对象使用什么指针接收，最终都会调用虚表的方法，也就是对象真正的方法

注意：如果子类没有重写父类的虚函数，父类的虚函数编译的时候也会被放到子类的虚表里面，也就是函数调用在编译的时候就确定了，如下

struct Animal {
    virtual void speak() { }
    virtual void run() { }
}

struct Dog : Animal {
    void run() { }
}

struct WhiteDog: Dog {

}

WhiteDog *dog = new WhiteDog();

// dog对象的虚表存放了 Dog::run 和 Animal::speak 方法的地址

多态的调用行为在编译后就确定了，而不是运行时动态确定

多态-析构函数

由于C++多态使用的虚表实现的，对于多态，析构函数也要使用虚函数

using namespace std;

struct Animal {
    // 父类的析构函数
    ~Animal {
        cout << "Animal::~Animal" << endl;
    }
}

struct Dog: Animal {
    // 父类的析构函数
    ~Dog {
        cout << "Dog::~Dog" << endl;
    }
}

Animal *ani = new Dog();
// 这里值调用Animal的析构函数，不会调用Dog的析构函数
delete ani;

需要把Animal的析构函数设置为virtual

struct Animal {
    // 父类的析构函数
    virtual ~Animal {
        cout << "Animal::~Animal" << endl;
    }
}

多态继承

如果要用父类指针指向子类对象，则继承的权限必须是public

class Person { }

// 必须public继承Person
class Student: public Person {

}

// 多态
Person *person = new Student()

调用父类方法

直接通过类名调用

using namespace std;

struct Animal {
    virtual void speak() {
        cout << "animal speak" << endl;
    }

    void run() { }
}

struct Dog: Animal {
    void speak() {
        // 直接调用父类的方法
        Animal::speak();

        // 调用父类的成员函数
        Animal::run();

        cout << "animal speak" << endl;
    }
}

多继承

C++支持多继承（不建议使用，会增加程序设计的复杂度）

class Student {
public:
    int m_score;
    void study() { }
};

class Worker {
public:
    int m_salary;
    void work() { }
};

class Undergraduate: public Student, public Worker {
public:
    int m_grade;
    void play() { }
};

int main() {
    Undergraduate ug;
    ug.m_score = 10;
    ug.m_salary = 20;
    ug.m_grade = 30;
    ug.study();
    ug.work();
    ug.play();

    return 0;
}

内存分布

多继承-虚函数

多继承的多态也是通过虚函数实现的，单继承一样，但是由于又多个父类，多继承会又多个虚表地址

多继承的子类会产生多张虚表，分别对应不同父类

class Student {
public:
    int m_score = 1;
    virtual void func() {
        cout << "student func" << endl;
    }
};

class Worker {
public:
    int m_salary = 2;
    virtual void func() {
        cout << "worker func" << endl;
    }
};

class Undergraduate : public virtual Student, public virtual Worker {
public:
    int m_grade = 3;
    void func() {
        cout << "undergraduate func" << endl;
    }
};

int main() {
    Undergraduate *undergraduate = new Undergraduate();
    Student *stu = undergraduate;
    cout << stu->m_score; << endl;
    stu->func();
    return 0;
}

同名函数/变量问题

对于同名变量，C++默认会当成多个变量来存储

class Student {
public:
    int m_age = 1;
}
class Worker {
public:
    int m_age = 2;
}
class Undergraduate {
public:
    int m_age = 3;
}

int main() {
    Undergraduate *under = new Undergraduate();
    // 默认访问 Undergraduate::m_age == 3
    cout << under->m_age << endl;

    // 多态，这里不支持，需要通过虚继承实现
    Student* stu = under;

    // 访问的是Student::m_age == 1
    cout << stu->m_age << endl;
    return 0;
}

内存分布

菱形继承

由于C++支持多继承，所以会出现菱形继承这种情况，我们知道子类会继承父类的所有成员变量（包括同名的）

class Person {
public:
    int m_age = 1;
};

class Student: public Person {
public:
    int m_score = 2;
};

class Worker: public Person {
public:
    int m_salary = 3;
};

class Undergraduate : public Student, public Worker {
public:
    int m_grade = 4;
};

int main() {
    Undergraduate *under = new Undergraduate();

    // 不能直接引用，存在二义性，下面代码报错
    under->m_age = 10;

    // 可以通过指定类类访问
    under->Student::m_age = 11;
    under->Worker::m_age = 11;

    return 0;
}

Undergraduate的内存分布

虚继承

上面Undergraduate会继承两份Person的成员m_age，为了避免这种情况（通常我们希望只继承一份成员变量），C++使用虚继承解决

class Person {
public:
    int m_age = 1;
};

// 虚继承基类
class Student: virtual public Person {
public:
    int m_score = 2;
};

// 虚继承基类
class Worker: virtual public Person {
public:
    int m_salary = 3;
};

class Undergraduate : public Student, public Worker {
public:
    int m_grade = 4;
};

int main() {
    Undergraduate *under = new Undergraduate();

    under->m_age = 10;
    cout << sizeof(Undergraduate) << endl;
    return 0;
}

内存分布

可以看到出多了两个虚表，用于声明基类字段m_age的偏移量，m_age只有一份

静态成员

• 静态成员存储在数据段（全局区）整个程序运行过程中只有一份内存

• C++的静态成员必须初始化，并且必须在类外面初始化

  class Student {
      // 声明
      static int m_count;
  };
  
  // 初始化
  int Student::m_count = 10;

友元

友元方法：可以在类外部的方法访问类的所有成员（字段和方法）
友元类：可以在其他类访问类的所有成员（字段和方法）

class Point {
    // 声明友元方法
    friend Point add(const Point &a, const Point &b);

    // 声明友元类
    friend class Math;

private:
    int m_x;
    int m_y;
    // 私有方法
    void func() { }
public:
    Point(int x, int y): m_x(x), m_y(y) {
    }
};

Point add(const Point &a, const Point &b) {
    // 在这里可以直接访问Point的私有变量
    return Point(a.m_x + b.m_x, a.m_y + b.m_y);
}

class Math {
    void func() {
        Point p = Point(1, 2);
        // 可以访问类的私有成员
        p.m_x = 10;
        p.m_y = 20;
        // 访问私有方法
        p.func();
    }
};

下一篇主要是C++的新特性