cpp复习笔记2

七

析构函数：

语法： ~类名

class Student {
    int age;
    
public: // 保证析构和构造函数别人可以访问
    
    // 构造函数
    Student() {

    }
    
    // 析构函数
    ~Student() {
        
    }
};
头文件和实现文件：

.h文件：

//#ifndef Student_hpp
//#define Student_hpp

#pragma once // 相当于上面的注释 防止重复包含

#include <stdio.h>

class Student {
    int m_age;
public:
    void setAge(int age);
};

//#endif /* Student_hpp */

.cpp文件：

#include "Student.hpp"
#include <iostream>

using namespace std;

void Student::setAge(int age) {
    this -> m_age = age;
    cout << m_age << endl;
}

::域运算符

命名空间

namespace是用来限定作用域的

namespace US {
class Person {
public:
    int m_name;
};
}

namespace CN {
class Person{
public:
    int m_name;
};
}

int main(int argc, const char * argv[]) {

    US::Person *p = new US::Person();
    p->m_name = 10;
    CN::Person *p1 = new CN::Person();
    p1->m_name = 10;
    
    return 0;
}

还可以使用using namespace 别名 来简便使用：

int main(int argc, const char * argv[]) {
    
    // 往后的都是使用CN命名空间内的
    using namespace CN;

    Person *p = new Person();
    p->m_name = 10;

    return 0;
}
继承

权限控制三个关键字：
public private protected

// class的继承 默认是private
class Person{  
    // 属性默认是private
    int name;
};

class Student: private Person {
    int age;
};
// 结构体的继承 默认是public
namespace struc {
struct Person{
     // 属性默认是public
    int name;
};

class Student: public Person {
    int age;
};
}

子类能否访问到父类的属性或者方法，要看父类的权限控制和继承时候的权限控制，取最小的权限控制来决定能否访问。
开发中继承最多用的是public，这样可以完全保留父类的权限：

class Person{
    int name;
};

class Student: public Person {
    int age;
};
初始化列表
class Person{
    int height;
    int age;
    
//    Person(int age, int height) {
//        this->age = age;
//        this->height = height;
//    }
    // 等价于上面的写法
    Person(int age, int height): age(age), height(height) {
        
    }
};

注意：初始化列表中，初始化的顺序，只跟成员变量的定义顺序有关，跟列表中写法顺序无关。

构造函数的互相调用，必须在初始化列表中去做：
不能直接调用⚠️⚠️⚠️⚠️

class Person{
    int height;
    int age;
    
    // 初始化列表中 调用其他的构造函数
    Person(): Person(0, 0) {
        // 不能在里面调用 否则产生的只是一个临时对象
    }
    
    Person(int age, int height) {
        this->age = age;
        this->height = height;
    }
};

总结：

  1. 子类的构造函数默认会调用父类的无参构造函数
  2. 如果子类的构造函数显式地调用了父类的有参构造函数，就不会再去调用父类的无参构造函数
  3. 如果父类缺少无参构造函数，子类的构造函数必须显式调用父类的有参构造函数
  4. 构造函数调用顺序（父、子）和析构函数调用顺序（子、父）相反

九

多态

cpp的多态是通过虚函数实现的
虚函数是使用virtual修饰的成员函数
只要在父类中声明为虚函数，子类中重写的函数也会自动变成虚函数（子类可以省略virtual关键字）

// 父类
class Person{
    int height;
    int age;
public:
    Person(): Person(0, 0) {
    }
    
    Person(int age, int height) {
        this->age = age;
        this->height = height;
    }
    // 虚方法
    virtual void run() {
        cout << "Person run" << endl;
    }
};
// 子类
class Student: public Person {
public:
    Student() {
    }
    // 重写 虚方法
    void run() {
        cout << "student run" << endl;
    }
};

int main(int argc, const char * argv[]) {
    
    Person *stu = new Student();
    stu->run();
    return 0;
}

虚函数的实现原理是虚表。虚表里面存储的是最终需要调用的虚函数地址。
如果对象中有方法为虚函数，那么对象的大小会在最前面增加4个字节（x86环境下）指向内存中虚表的地址：

class Person{
    int height;
    int age;
    virtual void run() {
        cout << "Person run" << endl;
    }
};

注意：如果子类没有重写父类的虚函数，那么子类的虚函数表中存储的就是父类的虚函数地址。

虚析构函数

含有虚函数的类，应该将析构函数也声明为虚函数。
这样delete父类指针时，才会调用子类的析构函数，来保证析构的完整性。

class Person {
public:
    virtual ~ Person() {
        cout << "Person dealloc" << endl;
    };
};

class Student: public Person {
    ~ Student() {
        cout << "Student dealloc" << endl;
    }
};

int main(int argc, const char * argv[]) {
    
    Person *stu = new Student();
    delete stu;
    return 0;
}
// 输出内容    Student dealloc
//            Person dealloc
纯虚函数、抽象类

没有函数体且初始化为0的函数，用来定义接口规范。
类似于java的接口、抽象类，oc的协议。
注意⚠️⚠️⚠️：
只要有一个纯虚函数，那么这个类就是抽象类，不可以实例化这个类。

class Person {
public:
    virtual void run() = 0; // 纯虚函数
};

class Student: public Person {
    // 子类实现
    void run() { 
        cout << "sub run" << endl;
    }
};

如果父类是抽象类，子类没有 全部 实现纯虚函数，那么子类也是抽象类。

多继承

如果每一个父类都有虚函数，那么子类会存储多个数函数表的地址。

// 抽象类
class Person {
public:
    virtual void run() = 0; // 纯虚函数
};

class Student {
public:
    virtual void run() {
        cout << "run" << endl;
    }
};

// 会存储两张虚表
class XiaoMing: public Person, public Student {
};
同名函数 和 同名成员变量
class Person {
public:
    int age;
    virtual void run() {
        
    }
};


class Student {
public:
    int age;
    virtual void run() {
        cout << "run" << endl;
    }
};

class XiaoMing: public Person, public Student {
    void run() override {
        
    }
};

int main(int argc, const char * argv[]) {
    
    XiaoMing _xiaoMingg;
    _xiaoMingg.Student::run();
    _xiaoMingg.Person::run();
    _xiaoMingg.Person::age = 10;
    _xiaoMingg.Student::age = 20;
    
    cout << sizeof(Student) << endl;
    return 0;
}

菱形继承：
虚继承可以解决菱形继承带来的问题（成员变量重复）
基类被称为虚基类

虚继承：class Student: virtual public Person {}

        Person          // 虚基类
Student        Worker   // 均虚继承于Person
       XiaoMing

Student对象的内存排布中，最后面放的是虚基类Person的成员变量。最前面是虚表地址。虚表中存放着：

  1. 虚表指针与本类起始的偏移量
  2. 虚基类成员与本类起始的偏移量
最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。

推荐阅读更多精彩内容

  • 《C++ Primer》读书笔记
    前言 把《C++ Primer》[https://book.douban.com/subject/25708312...
    尤汐Yogy阅读 9,542评论 1赞 51
  • C++ Primer第五版（3）——类设计者工具
    3. 类设计者工具 3.1 拷贝控制 五种函数拷贝构造函数拷贝赋值运算符移动构造函数移动赋值运算符析构函数拷贝和移...
    王侦阅读 1,884评论 0赞 1
  • C++入门基础
    C++入门基础 namespace专题讲座 namespace概念 所谓namespace，是指标识符的各种可见范...
    蔡俊宇阅读 808评论 0赞 2
  • 2018-06-11
    mean to add the formatted="false" attribute?.[ 46% 47325/...
    ProZoom阅读 2,729评论 0赞 3
  • C++ 学习笔记
    第一章 计算机与C++编程简介 C++程序6个阶段编程 ->预处理->编译->连接->装入->执行1.程序在编译器...
    rogertan30阅读 4,129评论 0赞 1