动态多态和虚函数

虚函数：

#include<iostream>
using namespace std;
class Animal{
public: 
//c++中可以用纯虚方法做接口
virtual void run(){
cout<<123<<endl;
}
virtual void eat(){
cout<<123<<endl;
}
virtual void  say(){
cout<<123<<endl;
}
  void ationEat{
  this->run();
  this->eat();
  this->say();

}
};
class Cat :public Animal{


}
class Dog: public Animal{


};
class Car{
};
class BMW:public Car{};
class Builder{
public:
virtual Car*builder()=0;

};
class BMWBuilder:public Builder{
public:
Car*buildCar()override{
return new BMW();

}
}
class AutoSystem{
private:
    std::map<string,Car*>cars;
    static std::map<string,Builder*>builders;
 public:
   static void createBMW(string name){
   if(name=="bmw"){
 Car*pCar=builders["bmw"]->buildCar();
 }

}
};
int main(){
         Animal*animals[10];
         for(int i=0;i<10;i++){
         if(i%2==1){
animals[i]=new Cat();
         }else{
animals[i]=new Dog();
}
}
}
for(auto animal:animals){
animal->actionEat();
}

return 0;

}

//函数指针的调用
void func1(int n){
cout<<"call func1"<<endl;

}
void func2(){
cout<<"call func2"<endl;

}
void output_obj_address(void*ptr,int size){
    unsigned char*p=(unsigned char*)ptr;
    printf("%p ",p);
    for(int i=0;i<size;i++){
        printf("%02X",p[i]);
    }
    printf("\n");
}
int main(){
//每个类对象都会生成自己的虚函数表
output_obj_address(&base,sizeof(base));
output_obj_address(&base,sizeof(base));
typedef void (*pClassFunc1)(void*);//类成员函数指针
((pClassFunc1**)&base)[0][0](&base);
((pClassFunc1**)&base)[0][1](&base);//报错
//有两个析构函数，一个是调用析构，一个是做析构和内存释放
/*
  void (*pFun)()=&func2;//1.函数指针
  （*pFun）();
  typedef void (*pFun2)();//2 typedef 定义的函数指针类型
  typedef void (*pFun1)(int);
  pFun1 pfun1=&func1;
  pFun1 pfun11=&func11;
  pFun2 pfun2=&func2;
  pfun1(1);
  pfun11(11);
  pfun2();
  pFun2 sFunc=&Base::staticFunc;
  sFunc();
  typedef void (Base::*pClassFunc1)();//2 typedef 定义的函数指针类型
  typedef void (Base::*pClassFunc2)(int);//function<void*,int>
  pClasssFunc1 pclassfunc1=&Base::test;
  pClassFunc2 pclassfunc2=&Base::testInt;
  Base base;
  (base.*pclassfunc1)();
  (base.*pclassfunc2)(123);
  void (Base::*pclassFunVoid)()=&Base::test;
   void (Base::*pclassFunInt)(int)=&Base::testInt;
   (base.*pclassFunVoid)();
  (base.*pclassFunInt)(123);
  return 0;
}
*/

常用关键字总结：

auto在就旧标准的作用是具有自动存储期的变量
auto作用在编译器
1.不能作为函数模板
2.不能作为模板参数(c++14以后可以)
3。无法定义数组
4.不能用于非静态成员变量

constexpr与const关键字的区别是一个是编译阶段的常量，一个是运行阶段的常量
1.修饰函数
2.修饰普通函数
3.修饰构造函数

final
禁止类继承
禁止虚函数重写