多态：使用相同的调用方法，调用不同对象，自己类里面函数
人类用手吃饭是本能；
英国人用刀叉吃饭；
中国人用筷子吃饭；
我们问“这个人怎么吃饭的？”，
应该根据其国别来回答，而不是简单地说“用手吃”。
这就是多态。
1 #include <iostream> 2 #include <string.h> 3 #include <unistd.h> 4 5 using namespace std; 6 7 class Human{ 8 9 private: 10 int a; 11 public: 12 virtual void eating(void){cout<<"use hand to eat"<<endl;}//用到时会被替换成当前的 13 14 15 }; 16 17 class Englishhuman : public Human{ 18 public: 19 void eating(void){cout<<"use knife to eat"<<endl;} 20 21 }; 22 23 class Chinese : public Human{ 24 public: 25 void eating(void){cout<<"use chopsticks to eat"<<endl;} 26 27 }; 28 29 void test_eating (Human &h) 30 { 31 h.eating(); 32 } 33 34 int main(int argc,char **argv) 35 { 36 Human h; 37 Englishhuman e; 38 Chinese c; 39 40 test_eating(h); 41 test_eating(e); 42 test_eating(c); 43 44 cout<<"sizeof(Human) = "<<sizeof(h)<<endl; 45 cout<<"sizeof(Englishhuan) = "<<sizeof(e)<<endl; 46 cout<<"sizeof(Chinese) = "<<sizeof(c)<<endl; 47 48 return 0; 49 }
原理：
对于虚函数，采用动态联编：有虚函数的对象里有一个指针，指向虚函数表；
调用虚函数时，会根据对象里的指针找到表，从表中取出函数来执行
对于非虚函数，采用静态联编：编译时就确定调用哪个函数
差别：
静态联编效率高，动态联编支持多态
注意：由于继承了Human所以对应的与Human中函数相同的函数也为虚函数
1 #include <iostream> 2 #include <string.h> 3 #include <unistd.h> 4 5 using namespace std; 6 7 class Human{ 8 public: 9 void eating(void){cout<<"use hand to eat"<<endl;} 10 11 12 }; 13 14 class Englishhuman : public Human{ 15 public: 16 void eating(void){cout<<"use knife to eat"<<endl;} 17 18 }; 19 20 class Chinese : public Human{ 21 public: 22 void eating(void){cout<<"use chopsticks to eat"<<endl;} 23 24 }; 25 26 void test_eating (Human &p) 27 { 28 h.eating(); 29 } 30 31 int main(int argc,char **argv) 32 { 33 Human h; 34 Englishhuman e; 35 Chinese c; 36 37 test_eating(h);/* Human &p = h里面的Person部分; 38 * p引用的是"h里面的Person部分" 39 */ 40 test_eating(e); 41 test_eating(c); 42 43 return 0; 44 }
多态的限制：
1.test_func(Human* h):
test_func(Human& h)：使用指针或引用来使用对象时，才有多态
test_func(Human h)：传值时，无多态
2.只有类的成员函数才能声明为虚函数
3.静态成员函数不能是虚函数
4.内联函数不能是虚函数（使用inline关键字的函数）
5.构造函数不能是虚函数
6.析构函数一般都声明为虚函数
7.重载：函数参数不同，不可设为虚函数
覆盖：函数参数、返回值相同，可以设为虚函数
8.返回值例外：
函数参数相同，但是返回值是当前对象的指针或引用时，
也可以设为虚函数（除此之外不可以设置为虚函数，否则会出现错误）
1 #include <iostream> 2 #include <string.h> 3 #include <unistd.h> 4 5 using namespace std; 6 7 class Human{ 8 9 private: 10 int a; 11 public: 12 virtual void eating(void){cout<<"use hand to eat"<<endl;}//用到时会被替换成当前的 13 14 15 }; 16 17 class Englishhuman : public Human{ 18 public: 19 void eating(void){cout<<"use knife to eat"<<endl;} 20 21 }; 22 23 class Chinese : public Human{ 24 public: 25 void eating(void){cout<<"use chopsticks to eat"<<endl;} 26 27 }; 28 29 void test_eating (Human h)//传值时没有对态 30 { 31 h.eating(); 32 } 33 34 int main(int argc,char **argv) 35 { 36 Human h; 37 Englishhuman e; 38 Chinese c; 39 40 test_eating(h); 41 test_eating(e); 42 test_eating(c); 43 44 cout<<"sizeof(Human) = "<<sizeof(h)<<endl; 45 cout<<"sizeof(Englishhuan) = "<<sizeof(e)<<endl; 46 cout<<"sizeof(Chinese) = "<<sizeof(c)<<endl; 47 48 return 0; 49 }
对应第六点
1 #include <iostream> 2 #include <string.h> 3 #include <unistd.h> 4 5 using namespace std; 6 7 class Human{ 8 9 private: 10 int a; 11 public: 12 virtual void eating(void){cout<<"use hand to eat"<<endl;}//用到时会被替换成当前的 13 virtual ~Human(){cout<<"~Human()"<<endl;} 14 15 16 }; 17 18 class Englishhuman : public Human{ 19 public: 20 void eating(void){cout<<"use knife to eat"<<endl;} 21 virtual ~Englishhuman(){cout<<"~Englishman()"<<endl;} 22 }; 23 24 class Chinese : public Human{ 25 public: 26 void eating(void){cout<<"use chopsticks to eat"<<endl;} 27 virtual ~Chinese(){cout<<"~Chinese()"<<endl;} 28 }; 29 30 void test_eating (Human h) 31 { 32 h.eating(); 33 } 34 35 int main(int argc,char **argv) 36 { 37 Human* h = new Human; 38 Englishhuman* e = new Englishhuman; 39 Chinese *c = new Chinese; 40 41 Human *p[3] = {h,e,c}; 42 int i; 43 44 for (i = 0; i < 3; i++) 45 { 46 p[i]->eating(); 47 delete p[i]; 48 } 49 50 return 0; 51 }
对应第八点
1 #include <iostream> 2 #include <string.h> 3 #include <unistd.h> 4 5 using namespace std; 6 7 class Human{ 8 9 private: 10 int a; 11 public: 12 virtual void eating(void){cout<<"use hand to eat"<<endl;} 13 virtual ~Human(){cout<<"~Human()"<<endl;} 14 virtual Human* test(void){cout <<"Human\'s test"<<endl;return this;} 15 16 17 }; 18 19 class Englishhuman : public Human{ 20 public: 21 void eating(void){cout<<"use knife to eat"<<endl;}//由于继承了Human所以次函数也为虚函数 22 virtual ~Englishhuman(){cout<<"~Englishman()"<<endl;} 23 virtual Englishhuman* test(void){cout<<"Englishman\'s test"<<endl;return this;} 24 }; 25 26 class Chinese : public Human{ 27 public: 28 void eating(void){cout<<"use chopsticks to eat"<<endl;}////由于继承了Human所以次函数也为虚函数 29 virtual ~Chinese(){cout<<"~Chinese()"<<endl;} 30 virtual Chinese* test(void){cout<<"Chinese\'s test"<<endl;return this;} 31 }; 32 33 void test_eating (Human &h) 34 { 35 h.eating(); 36 } 37 38 void test_return(Human &h) 39 { 40 h.test(); 41 } 42 43 int main(int argc,char **argv) 44 { 45 Human h; 46 Englishhuman e; 47 Chinese c; 48 49 test_return(h); 50 test_return(e); 51 test_return(c); 52 53 return 0; 54 }
类型转换：
C++中的类型转换：
dynamic_cast:
格式：dynamic_cast < type-id > ( expression )
该运算符把expression转换成type-id类型的对象。
Type-id必须是类的指针、类的引用或者void *；
如果type-id是类指针类型，那么expression也必须是一个指针；
如果type-id是一个引用，那么expression也必须是一个引用。
1. 用于多态场合，即：必须有虚函数
2. 主要用于类层次间的上行转换和下行转换，还可以用于类之间的交叉转换
3. 在类层次间进行上行转换时，dynamic_cast和static_cast的效果是一样的；
在进行下行转换时，dynamic_cast具有类型检查的功能，比static_cast更安全。
static_cast：
格式：static_cast < type-id > ( expression )
该运算符把expression转换为type-id类型，
但没有运行类型检查来保证转换的安全性。
1. 用于类层次结构中基类和子类之间指针或引用的转换。
2. 进行上行转换（把子类的指针或引用转换成基类表示）是安全的；
3. 进行下行转换（把基类指针或引用转换成子类指针或引用）时，由于没有动态类型检查，所以是不安全的。
4. 用于基本数据类型之间的转换，如把int转换成char，把int转换成enum：这种转换的安全性也要开发人员来保证。
5. 把void指针转换成目标类型的指针(不安全!!)
6. 把任何类型的表达式转换成void类型。
注意：static_cast不能转换掉expression的const、volitale、或者__unaligned属性。
reinterpret_cast：
格式：reinterpret_cast<type-id> (expression)
相当于C风格的用小括号"(type-id)"实现的强制类型转换
1. type-id必须是一个指针、引用、算术类型、函数指针或者成员指针
2. 它可以把一个指针转换成一个整数，也可以把一个整数转换成一个指针
3. 跟C风格的强制转换类似，没有安全性检查
const_cast：
格式：const_cast<type_id> (expression)
该运算符用来去除原来类型的const或volatile属性。
除了const 或volatile修饰之外， type_id和expression的类型是一样的。
对应第十四天的文件夹
