多态

一.动态绑定和静态绑定

(多态和重载)

静态绑定:编译器将所有事s()调用绑定到s()的代码处

 

 1 #include <iostream>
 2 using namespace std;
 3 
 4 void s() {}
 5 
 6 int main()
 7 {
 8     s();
 9     return 0;
10 }

 

动态绑定:直到程序运行时,才将函数名绑定到其入口,每个类都有虚函数表,所有虚函数的地址

 

二.虚函数(构造函数不行,静态函数不行)

 1 #include <iostream>
 2 using namespace std;
 3 
 4 class A
 5 {
 6 public:
 7     virtual void s() // 子类中即使无virtual 也自动成为虚函数,最好在子类中都声明为virtual,virtual仅在声明时需要
 8     {
 9         cout << "A" << endl;
10     }
11 };
12 
13 class B: public A
14 {
15 public:
16     virtual void s()
17     {
18         cout << "B" << endl;
19     }
20 };
21 
22 
23 class C: public A
24 {
25 public:
26     virtual void s()
27     {
28         cout << "C" << endl;
29     }
30 };
31 
32 
33 int main()
34 {
35     A *a;
36     a = new A;
37     a->s();//A
38     a = new B;
39     a->s();//B
40     a = new C;
41     a->s();//C
42 
43     B b;
44     A &a1 = b;
45     a1.s();//B
46     return 0;
47 }

 

在非构造函数,非析构函数中调用虚函数,是多态

在构造,析构函数中调用虚函数不是多态,编译时即可确定

 1 #include <iostream>
 2 using namespace std;
 3 
 4 class A
 5 {
 6 public:
 7     virtual void act1()
 8     {
 9         cout << "A::act1()" << endl;
10     }
11     void act2()
12     {
13         act1();
14     }
15 };
16 
17 class B: public A
18 {
19 public:
20     virtual void act1()
21     {
22         cout << "B::act1()" << endl;
23     }
24 };
25 
26 int main()
27 {
28     B b;
29     b.act2(); // "B::act1()"
30     return 0;
31 }

1.B是A的派生类,act1()是类A中的虚函数,B实际上调用A::act2(),在A::act2()中调用act1(),由于act1()是虚函数,产生动态联编,根据运行时情况选择了B::act1()

   void act2(A *this) {this -> act1()};很明显是多态。

2.把A::act1()改为非虚函数,结果为A::act1(),静态联编。

3. A::act2()改为void act2(){A::act1()}结果为A::act1()。由于加入了成员名限定,因此也是静态联编。

 

三.

1.C++使用vtable实现虚成员函数运行时绑定,vtable支持运行时查询,把函数名绑定到vtable中特定入口。vtable需要额外空间,对vtable进行查询也需要额外时间。

2.构造函数不可用是虚函数,但析构可以是。

 

 1 #include <iostream>
 2 using namespace std;
 3 
 4 class A
 5 {
 6 public:
 7     A()
 8     {
 9         cout << "A" << endl;
10         p = new char[500];
11     }
12     ~A()
13     {
14         cout << "~A" << endl;
15         delete[] p;
16     }
17 private:
18     char *p;
19 };
20 
21 class B: public A
22 {
23 public:
24     B()
25     {
26         cout << "B" << endl;
27         q = new char[500];
28     }
29     ~B()
30     {
31         cout << "~B" << endl;
32         delete[] q;
33     }
34 private:
35     char *q;
36 };
37 
38 void f()
39 {
40     A *p = new B();
41     delete p;
42 }
43 
44 int main()
45 {
46     f();//因为析构函数不是virtual,所以p的数据类型A*仅调用~A(),而没有调用~B(),没有释放B()中分配的字节。
47     /*
48     A
49     B
50     ~A
51     */
52     return 0;
53 }

 

 

 1 #include <iostream>
 2 using namespace std;
 3 
 4 class A
 5 {
 6 public:
 7     A()
 8     {
 9         cout << "A" << endl;
10         p = new char[500];
11     }
12     virtual ~A()
13     {
14         cout << "~A" << endl;
15         delete[] p;
16     }
17 private:
18     char *p;
19 };
20 
21 class B: public A
22 {
23 public:
24     B()
25     {
26         cout << "B" << endl;
27         q = new char[500];
28     }
29     ~B()
30     {
31         cout << "~B" << endl;
32         delete[] q;
33     }
34 private:
35     char *q;
36 };
37 
38 void f()
39 {
40     A *p = new B();
41     delete p;
42 }
43 
44 int main()
45 {
46     f();
47     /*
48     A
49     B
50     ~B
51     ~A
52     */
53     return 0;
54 }

 

 

四.重写和重载

重写函数签名完全相同,重载参数列表不同。

函数遮蔽:函数名相同,签名无所谓,虚函数同名,不同参也可遮蔽

 

 1 #include <iostream>
 2 using namespace std;
 3 
 4 class A
 5 {
 6 public:
 7     virtual void m(int x){}
 8 };
 9 
10 class B: public A
11 {
12 public:
13     void m(){}
14 };
15 
16 
17 int main()
18 {
19     A *p = new B();
20     B b;
21     p->m();//error,遮蔽
22     p->m(10);
23     b.A::m(3);
24     b.m();
25     b.m(3);//error,遮蔽
26     return 0;
27 }

 

 

 

五.抽象基类

纯虚函数(在派生类重新定义之前不能调用),virtual 函数=0,类中至少有一个纯虚函数,这个类是抽象类,不能被实例化。

A a;//error

A *a, &a;//ok

派生类中必须重定义基类纯虚函数,或继承纯虚函数。

派生类重定义所有基类纯虚函数才不是抽象类。

 

posted @ 2016-03-19 17:15  早杰  阅读(164)  评论(0编辑  收藏  举报