C++面向对象编程

多态:使用相同的调用方法,调用不同对象,自己类里面函数

人类用手吃饭是本能;
英国人用刀叉吃饭;
中国人用筷子吃饭;
我们问“这个人怎么吃饭的?”,
应该根据其国别来回答,而不是简单地说“用手吃”。
这就是多态。

C++面向对象编程
 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 }
View Code

原理:
对于虚函数,采用动态联编:有虚函数的对象里有一个指针,指向虚函数表;
调用虚函数时,会根据对象里的指针找到表,从表中取出函数来执行
对于非虚函数,采用静态联编:编译时就确定调用哪个函数
差别:
静态联编效率高,动态联编支持多态

注意:由于继承了Human所以对应的与Human中函数相同的函数也为虚函数

C++面向对象编程
 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 }
View Code

C++面向对象编程

多态的限制:

1.test_func(Human* h):
 test_func(Human& h):使用指针或引用来使用对象时,才有多态
 test_func(Human h):传值时,无多态

2.只有类的成员函数才能声明为虚函数

3.静态成员函数不能是虚函数

4.内联函数不能是虚函数(使用inline关键字的函数)

5.构造函数不能是虚函数

6.析构函数一般都声明为虚函数

7.重载:函数参数不同,不可设为虚函数

覆盖:函数参数、返回值相同,可以设为虚函数

8.返回值例外:

函数参数相同,但是返回值是当前对象的指针或引用时,
也可以设为虚函数(除此之外不可以设置为虚函数,否则会出现错误)

C++面向对象编程
 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 }
View Code

对应第六点

C++面向对象编程
 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 }
View Code

对应第八点

C++面向对象编程
 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 }
View Code

类型转换:

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的类型是一样的。

 对应第十四天的文件夹

上一篇:jvm学习笔记


下一篇:公共数据库信息汇总