重载和重写

1. 重载---同一个类中函数名相同，函数的参数列表不相同的两个及两个以上的函数就是函数重载。注意：函数的返回值不能作为函数是否重载的依据。
2. 重写---是在子类继承父类的时候，对父类的虚函数进行了覆盖。重写会使程序发生动态联编，产生多态。
3. 重定义---是在子类继承父类的时候，对父类的非虚函数进行了覆盖。

面向对象多态的体现:

静态多态：函数重载，运算符重载。
动态多态：通过虚函数实现。
使用指针或引用访问非虚函数时，编译器根据指针本身的类型决定要调用哪个函数。而不是不是根据指针指向对象的类型。
使用指针访问虚函数时，编译器根据指针指向的类型决定要调用哪个函数，与指针本身类型无关。
派生类可以对基类的虚函数的进行重写（重定义、覆盖）：
与基类的虚函数的参数类型必须一样
与基类的虚函数的参数个数必须一样
与基类的虚函数的函数返回值类型必须一样(可以替换为子类类型指针）

C++函数数调用默认不使用动态绑定，触发动态绑定必须满足一下条件：

只有指定为虚函数的函数才能进行动态绑定
必须通过基类的指针或引用对函数进行调用

哪些函数不能为虚函数

构造函数：若有虚构造函数则不能正确调用 父类的构造函数
静态成员函数：静态成员函数对每个类来说只有一份代码，所有对象共享这份代码，它不归属于某个具体对象所有。 友元函数：本就不是成员函数
内联函数：赋值操作符重载函数：基类与子类的参数类型不同

C++ 默认的析构函数不是虚函数是因为虚函数需要额外的虚函数表和虚表指针，占用额外的内存。
而对于不会被继承的类来说，其析构函数如果是虚函数，就会浪费内存。因此C++默认的析构函数不是虚函数，而是只有当需要当作父类时，设置为虚函数。

虚函数表

每个类的指向虚函数的指针，放在表格中，这个表格被称为虚函数表（bptr）
每个对象都被添加一个指向虚函数表的指针（虚函数表指针vptr）。
虚函数表是在编译期间就已经生成了

存放位置:

1. 虚函数表是class specific的，也就是针对一个类来说的，这里有点像一个类里面的staic成员变量，即它是属于一个类所有对象的，不是属于某一个对象特有的，是一个类所有对象共有的。
   
2. 虚函数表是编译器来选择实现的，编译器的种类不同，可能实现方式不一样，vptr在一个对象的最前面，但是也有其他实现方式，不过目前gcc 和微软的编译器都是将vptr放在对象内存布局的最前面。
   
   • msvc中虚函数表存放在常量段。
   • gcc中存放在可执行文件的只读数据段中(rodata)，这与微软的编译器将虚函数表存放在常量段存在一些差别。

不同继承模式下对象中虚函数表内存分布：

单继承

派生类中仅有一个虚函数表。这个虚函数表和基类的虚函数表不是一个表（无论派生类有没有重写基类的虚函数），但是如果派生类没有重写基类的虚函数的话，基类和派生类的虚函数表指向的函数地址都是相同的。
C不重写A的虚函数，虚函数表指针指向A的函数地址：

 class Animal{
      public:
          virtual void eat(){}
          virtual void run(){}
      private:
          int name;
          int age;
 };
 class Dog : public Animal{
      public:
          virtual void shout(){}
          virtual void stand(){}
 };

C重写A的虚函数，虚函数表指针指向C自己：

 class Animal{
      public:
          virtual void eat(){}
          virtual void run(){}
      private:
          int name;
          int age;
 };
 class Dog  : public Animal{
      public:
          virtual void eat(){}
          virtual void shout(){}
 };

多继承

派生类中有多个虚函数表，虚函数的排列方式和继承的顺序一致。派生类重写函数将会覆盖所有虚函数表的同名内容，派生类自定义新的虚函数将会在第一个类的虚函数表的后面进行扩充。
多继承和单继承差别就是多继承有多个虚函数表指针指。

class A
{
public:
 virtual void func1()
 {
 cout << "A::func1" << endl;
 }

 virtual void func2()
 {
 cout << "A::func2" << endl;
 }

public:
 int _a;
};

class B 
{
public:
 virtual void func3()
 {
 cout << "B::func1" << endl;
 }

public:
 int _b;
};

class C : public A , public B
{
 //覆盖A::func1()
 virtual void func1()
 {
 cout << "C::func1()"<<endl;
 }

 virtual void func4()
 {
 cout << "C::func4()" << endl;
 }
public:
 int _c;
};

继承的使用语法

正常继承

正常继承可以重写父类的方法，也可以补充些

class Person{
  public:
    virtual void id();
};

纯虚函数

纯虚函数的作用：实现抽象类；强制派生类重写虚函数,形如:

class Person{
  public:
    virtual void id() = 0;
};

override保留字

表示当前子类的成员函数重写了基类的虚成员函数。
如果cpp文件中没有的重写该函数，就会报错,这就限制这个函数一定要是父类的虚函数

class Person{
  public:
    virtual void id() override;
};

虚构造函数的作用

当用父指针引用子类子对象进行delete时，父类有虚构造函数会自动调用父类的构造函数，如果不是析构函数，则只会调用子类的析构函数。

class Base{
public:
    Base(){};
    ~Base(){cout<<"base deconstruct";};
};
class Child:public Base{
public:
    ~Child(){cout<<"child deconstruct";}
};
int main(){ 
// 
    Child *p = new Child();       
    delete p;   
}

非虚析构函数输出

child deconstruct   

虚析构函数输出

"base deconstruct"
"child deconstruct"

1.Clocks

chrono提供了三种不同的时钟:

1. std::chrono::system_clock: 依据系统的当前时间 (不稳定)
2. std::chrono::steady_clock: 以统一的速率运行(不能被调整)
3. std::chrono::high_resolution_clock: 提供最小可能的滴答周期

std::chrono::system_clock 它表示当前的系统时钟，系统中运行的所有进程使用now()得到的时间是一致的。 每一个clock类中都有确定的time_point, duration, Rep, Period类型。 操作有： now() 当前时间time_point to_time_t() time_point转换成time_t格式 from_time_t() 从time_t转换成time_point格式 典型的应用是计算时间日期：

// system_clock example
#include <iostream>
#include <ctime>
#include <ratio>
#include <chrono>

int main ()
{
  using std::chrono::system_clock;

  std::chrono::duration<int,std::ratio<60*60*24> > one_day (1);

  system_clock::time_point today = system_clock::now();
  system_clock::time_point tomorrow = today + one_day;

  std::time_t tt;

  tt = system_clock::to_time_t ( today );
  std::cout << "today is: " << ctime(&tt);

  tt = system_clock::to_time_t ( tomorrow );
  std::cout << "tomorrow will be: " << ctime(&tt);

  return 0;
}

std::chrono::steady_clock 为了表示稳定的时间间隔，后一次调用now()得到的时间总是比前一次的值大（这句话的意思其实是，如果中途修改了系统时间，也不影响now()的结果），每次tick都保证过了稳定的时间间隔。

2.Durations

std::chrono::duration 表示一段时间，比如两个小时，12.88秒，半个时辰，一炷香的时间等等，只要能换算成秒即可。

1 template <class Rep, class Period = ratio<1> > class duration;

其中 Rep表示一种数值类型，用来表示Period的数量，比如int float double Period是ratio类型，用来表示【用秒表示的时间单位】比如second milisecond 常用的duration<Rep,Period>已经定义好了，在std::chrono::duration下： ratio<3600, 1> hours ratio<60, 1> minutes ratio<1, 1> seconds ratio<1, 1000> microseconds ratio<1, 1000000> microseconds ratio<1, 1000000000> nanosecons

这里需要说明一下ratio这个类模版的原型：

 template <intmax_t N, intmax_t D = 1> class ratio;

N代表分子，D代表分母，所以ratio表示一个分数值。 注意，我们自己可以定义Period，比如ratio<1, -2>表示单位时间是-0.5秒。 由于各种duration表示不同，chrono库提供了duration_cast类型转换函数。

 typedef std::chrono::duration<int> seconds_type;
 typedef std::chrono::duration<int,std::milli> milliseconds_type;
 typedef std::chrono::duration<int,std::ratio<60*60>> hours_type;

   hours_type h_oneday (24);                  // 24h
   seconds_type s_oneday (60*60*24);          // 86400s
   milliseconds_type ms_oneday (s_oneday);    // 86400000ms

   seconds_type s_onehour (60*60);            // 3600s
 //hours_type h_onehour (s_onehour);          // NOT VALID (type truncates), use:
   hours_type h_onehour (std::chrono::duration_cast<hours_type>(s_onehour));
   milliseconds_type ms_onehour (s_onehour);  // 3600000ms (ok, no type truncation)

不同的period提供了std::chrono::duration_cast<>()转换成相同period的方法。 同时提供了count函数返回这个period的rep格式。

3.Time points

std::chrono::time_point 表示一个具体时间，如上个世纪80年代、你的生日、今天下午、火车出发时间等，只要它能用计算机时钟表示。鉴于我们使用时间的情景不同，这个time point具体到什么程度，由选用的单位决定。一个time point必须有一个clock计时。参见clock的说明。

template <class Clock, class Duration = typename Clock::duration>  class time_point;

使用方法:

// time_point constructors
#include <iostream>
#include <chrono>
#include <ctime>

int main ()
{
  using namespace std::chrono;

  system_clock::time_point tp_epoch;    // epoch value

  time_point <system_clock,duration<int>> tp_seconds (duration<int>(1));

  system_clock::time_point tp (tp_seconds);

  std::cout << "1 second since system_clock epoch = ";
  std::cout << tp.time_since_epoch().count();
  std::cout << " system_clock periods." << std::endl;

  // display time_point:
  std::time_t tt = system_clock::to_time_t(tp);
  std::cout << "time_point tp is: " << ctime(&tt);

  return 0;
}

time_point有一个函数time_from_eproch()用来获得1970年1月1日到time_point时间经过的duration。 举个例子，如果timepoint以天为单位，函数返回的duration就以天为单位。

遍历删除即在遍历中删除，不同的数据类型会有不同的问题比如:

for (auto itr = mDevices.begin(); itr != mDevices.end(); itr++) {
    if (itr->first == id) {
        mDevices.erase(itr->first);
    }
}

因为itr在删除的时候已经失效了，因此itr++会报错。 正确的姿势应该是

for (auto itr = mDevices.begin(); itr != mDevices.end();) {
    if (itr->first == id) {
        auto itrSave = itr;
        itr = mDevices.erase(itrSave);
    }else{  
        itr++;
    }
}

有些erase()方法返回的是void

for (auto itr = mDevices.begin(); itr != mDevices.end();) {
    if (itr->first == id) {
        auto itrSave = mDevices.erase(itr->first);
        itr++;
        mDevices.erase(itrSave);
    }else{  
        itr++;
    }
}

在使用多线程时，很多不规范的方法会导致意外的bug，现在讨论一种关闭线程不彻底导致的可能导致的隐患。

typedef struct {
bool isStop;
}ThreadCtx;
thread1(ThreadCtx *p){

    while(p->stop){
    ...some user code 
    }
}

int main(){
    ThreadCtx *p = new ThreadCtx;
    p->isStop = false;
    std::thread *t1 = new thread(thread1,p); //start the thread 
    ... some user code 

    // i just want to stop the thread
    p->isStop = true;
    // so the thread is close

}

如上代码所示，用标志位来判断线程是否关闭，隐患在于，当用户的代码在thread里面blocking时，线程是未退出的状态，这个时候主线程认为子线程已经退出了，问题在于缺少线程退出的反馈，正确的做法还需要在p->isStop = true;后面，加上

p->join(); //等待线程退出

等待线程退出，才能确保线程是退出的。

流程图如下:

类的继承方式有：公有继承，私有继承，保护继承

类当继承的方式为公有继承时： 基类的公共成员和受保护成员在派生类中访问属性（大众还是大众，受保护的还是保护的）还是不变，但是在类族之外的派生类的对象只能访问基类的公共成员，受保护和私有成员通过对象都不可以访问。
在派生类中，只有基类的私有成员在派生类中不可直接访问。

类当继承的方式为私有继承时：

基类的公用成员和保护成员都以私人身份出现在派生类中，所以在类族之外的派生类的对象不能访问基类的公共和保护的成员，当然包括基类的私有成员。
由于继承基类的函数可以说是派生类拥有对基类函数的调用权，所以在派生类中的其他成员可以直接访问基类的公共和保护成员，对于函数，一般采用在函数中调用基类的公共或保护函数的方式访问。
类当继承的方式为保护继承时：
基类的公用成员和保护成员都以保护身份出现在派生类中。
在类族之外的派生类的对象和在派生类中的其他成员对于公众，保护，私人的访问权限与私有继承相同。

#include<iostream>  
using namespace std; 

class A 
{ 
private: 
    int privatetedateA;
protected:  
    int protecteddateA; 
public:
    int publicdateA;
};

class B :public A      
{  
public:  
    void funct()  
    {  
        int b;  
        b=privatedateA;   //error：基类中私有成员在派生类中是不可见的  
        b=protecteddateA; //true：基类的保护成员在派生类中为保护成员  
        b=publicdateA;    //true：基类的公共成员在派生类中为公共成员  
    }  
};  
/  
class C :private A  
{  
public:  
    void funct()  
    {  
        int c;  
        c=privatedateA;    //error：基类中私有成员在派生类中是不可见的  
        c=protecteddateA;  //true：基类的保护成员在派生类中为私有成员  
        c=publicdateA;     //true：基类的公共成员在派生类中为私有成员  
    }  
};  

class D :protected A  
{  
public:  
    void funct()  
    {  
        int d;  
        d=privatedateA;   //error：基类中私有成员在派生类中是不可见的  
        d=protecteddateA; //true：基类的保护成员在派生类中为保护成员  
        d=publicdateA;    //true：基类的公共成员在派生类中为保护成员  
    }  
};  

int main()  
{  
    int a;   

    B objB;  
    a=objB.privatedateA;   //error：基类中私有s成员在派生类中是不可见的,对对象不可见  
    a=objB.protecteddateA; //error：基类的保护成员在派生类中为保护成员，对对象不可见  
    a=objB.publicdateA;    //true：基类的公有成员在派生类中为公共成员，对对象可见  

    C objC;  
    a=objC.privatedateA;   //error：基类中私有成员在派生类中是不可见的,对对象不可见  
    a=objC.protecteddateA; //error：基类的保护成员在派生类中为私有成员，对对象不可见  
    a=objC.publicdateA;    //error：基类的公有成员在派生类中为私有成员，对对象不可见  

    D objD;  
    a=objD.privatedateA;   //error：基类中私有成员在派生类中是不可见的,对对象不可见  
    a=objD.protecteddateA; //error：基类的保护成员在派生类中为保护成员，对对象不可见  
    a=objD.publicdateA;    //error：基类的公有成员在派生类中为保护成员，对对象不可见  

    return 0;  
}  

———————————————— 版权声明：本文为CSDN博主「Joerrot」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。 原文链接：https://blog.csdn.net/DYD850804/article/details/80514591