码迷,mamicode.com
首页 > 其他好文 > 详细

第十二章 继承

时间:2014-05-19 16:37:22      阅读:269      评论:0      收藏:0      [点我收藏+]

标签:style   blog   class   code   c   java   

第十二章 继承

1.  什么是继承和派生?

继承:bubuko.com,布布扣

派生:bubuko.com,布布扣

bubuko.com,布布扣   

2.  复杂的继承和派生.

3.  继承和派生如何在C++中实现.

 bubuko.com,布布扣

4.  单一继承.

在实际应用中可以将 基类和派生类视为一个整体

5.  保护成员.

 bubuko.com,布布扣

封装的含义:

 bubuko.com,布布扣

为了解决这个问题我们引进了protected。

 bubuko.com,布布扣

6.  公有派生的公有成员.

 bubuko.com,布布扣

子类可以直接调用

7.  公有派生的保护成员.

 bubuko.com,布布扣

子类可以通过自己间接访问

8.  公有派生的私有成员.

 bubuko.com,布布扣

子类只能通过父类间接访问

 bubuko.com,布布扣

在派生类中对基类成员的访问限定 其中public protected private的意思是可以访问 但是访问来的基类成员变成了相应的public protected private类型成员

9.  继承的赋值.

只能小的调用大的,父类调用子类

到底是类型转换还是赋值??????????????????

见程序12-3-1

10.  私有派生.

11.  多重继承.

 bubuko.com,布布扣 

12.  继承的构造与析构.

 bubuko.com,布布扣 

bubuko.com,布布扣

//单一继承的构造顺序:先父类后子类

 bubuko.com,布布扣

//多重继承的构造顺序:e,b,c,d,a

13.  向基类构造函数传递参数.

 bubuko.com,布布扣

只调用父类无参构造函数

弊端: 这样导致成员变量必须要protected

调用父类有参构造函数

优势: 成员变量可以使private

 bubuko.com,布布扣 

还有子类成员在花括号内定义

 bubuko.com,布布扣

14.  多重继承容易产生两义性.

产生原因: 当多个基类中有相同的函数, 用子类定义的类调用该函数时

解决方法:加作用域限定符

① bubuko.com,布布扣

② bubuko.com,布布扣

9.  继承中的重载.

子类会屏蔽掉父类的同名函数,不论参数是否不同.

 bubuko.com,布布扣 

bubuko.com,布布扣说明const也可以成为重载标示符

16.  两义性的归属问题.

产生原因: 当子类继承类father mother ,而father mother又从human类继承 , 用子类定义的类调用human中的函数

 bubuko.com,布布扣

解决办法 见 14两种

③还可以单一继承

17.  虚基类不会产生两义性.

④在中间父类加virtual

 bubuko.com,布布扣

本章总结:

1.  继承:***********************①

派生方式                            基类的访问限定                                 派生类中对基类成员的访问限定                                     主函数中访问派生类对象的基类成员

共有派生                            public                                                      public                                                                                          可以直接访问

                                       protected                                                 protected                                                                                    不可直接访问

                                       private                                                 不可直接访问                                                                              不可直接访问

私有派生                            public                                                      private                                                                                         不可直接访问

                                       protected                                                 private                                                                                         不可直接访问

                                       private                                                    不可直接访问                                                                              不可直接访问

2.  继承的赋值:只能小的调用大的,父类调用子类(虚函数处有用)

Father        A;                                           A=B           √

Father        *f;                                          B=A           ×     //B.operator=(B       &r){}//r用A传,A填不满B

Son    B;                                                    f=&B         √

Son    *s;                                                  S=&A        ×     //S的范围大,要是移动的话,就超出A对象了。就会出错

3.  子类会屏蔽掉父类的同名重载函数(见word文档)**********************②

4.  解决两义性的方法:

①子类中添加同名函数

②加作用域限定符class Son:class father,class mother{};    Son XiaoMing; XiaoMing.father::x();

③单一继承

④虚基类virtual(见word文档)

                   class human{public: stand(){cout<<”人可以直立行走\n”;}};

                   class father:virtual public human{public};

                   class mother:virtual public human{public};

                   class son:public father,pblic mother{public};

                   son XiaoMing;

                   XiaoMing.stand();

5.  继承的构造与析构

①单一继承的构造顺序:先父类后子类。(父类的构造函数,不论有无调用都要构造一遍)

②class f:public e,public b, public c

多重继承的构造顺序:e, b, c

  1. 基类的构造函数,一般由派生类传递初始值。

派生类成员一般在{}内定义,用于增加代码的可读性。

Son::Son(int x, int y, int z, int t):Fobject(x,y){c=z;d=t;}

7.                        重载                                                                   覆盖                                                                       隐藏

共同点:         函数名相同                                                                                        

不同点:         同类、参数类型、数量不同 或 有无const                 不同类,同参,有基virtual                             不同类,同参,且无virtual

                                                                                                                                                        不同类,不同参(不论有无virtual)

体现:              由函数调用(静态联编)                                    取决于object(动态联编)                             取决于pointer(不能体现多态性)

bubuko.com,布布扣
 1 /**
 2 1.继承:***********************①
 3 派生方式            基类的访问限定                派生类中对基类成员的访问限定                主函数中访问派生类对象的基类成员
 4 共有派生            public                        public                                        可以直接访问
 5                     protected                    protected                                    不可直接访问
 6                     private                        不可直接访问                                不可直接访问
 7 私有派生            public                        private                                        不可直接访问
 8                     protected                    private                                        不可直接访问
 9                     private                        不可直接访问                                不可直接访问
10 2.继承的赋值:只能小的调用大的,父类调用子类(虚函数处有用)
11 3.子类会屏蔽掉父类的同名重载函数(见word文档)**********************②
12 4.解决两义性的方法:①子类中添加同名函数②添加作用域限定符③单一继承④虚基类virtual(见word文档)**********************③
13 */
14 
15 #include"iostream"
16 using namespace std;
17 class father
18 {
19 private:
20     int a;
21 protected:
22     int pa;
23 public:
24     father(){cout<<"father的无参构造\n";}
25     father(int m,int n){a=m;pa=n;cout<<"father的有参构造"<<a<<" "<<pa<<endl;}
26     ~father(){cout<<"father的析构\n";}
27 };
28 
29 class son:public father//class son::virtual public father 虚基类
30 {
31 private:
32     int b;
33 protected:
34     int pb;
35     father Fobject;
36 public:
37     son(){cout<<"son的无参构造\n";}
38     son(int x,int y,int z,int t);
39     //派生类中初始化基类构造函数(有优势)
40     //不初始化就会调用father的无参构造函数    
41     ~son(){cout<<"son的析构\n";}
42 };
43 son::son(int x,int y,int z,int t):b(z),Fobject(x,y)
44     {pb=t;cout<<"son的有参构造"<<b<<" "<<pb<<endl;}
45 int main()
46 {
47     son Sobject(3,4,5,6);//为什么这里要调用无参的构造函数?
48 
49     return 0;
50 }
bubuko.com,布布扣

 

第十二章 继承,布布扣,bubuko.com

第十二章 继承

标签:style   blog   class   code   c   java   

原文地址:http://www.cnblogs.com/zenseven/p/3735028.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!