C++ 继承及实现

原创 2013年12月05日 17:11:18

如果想透彻了解C++基础,可看微学院的C++入门教程

http://see.xidian.edu.cn/cpp/biancheng/view/91.html

C++继承可以是单一继承或多重继承,每一个继承连接可以是public,protected,private也可以是virtual或non-virtual。然后是各个成员函数选项可以是virtual或non-virtual或pure virtual。本文仅仅作出一些关键点的验证。

private(私有)和protected(保护)都能实现类的封装性。private能够对外部和子类保密,即除了成员所在的类本身可以访问之外,别的都不能直接访问。protected能够对外部保密,但允许子类直接访问这些成员。public、private和protected对成员数据或成员函数的保护程度可以用下表来描述:



  public继承,例如下:

1 class base
2 {...}
3 class derived:public base
4 {...}
  如果这样写,编译器会理解成类型为derived的对象同时也是类型为base的对象,但类型为base的对象不是类型为derived的对象。这点很重要。那么函数形参为base类型适用于derived,形参为derived不适用于base。下面是验证代码,一个参数为base的函数,传入derived应该成功执行,相反,一个参数为derived的函数
复制代码
 1 #include <iostream>
 2 #include <stdio.h>
 3 
 4 class base
 5 {
 6     public:
 7     base()
 8     :baseName(""),baseData(0)
 9     {}
10     
11     base(std::string bn,int bd)
12     :baseName(bn),baseData(bd)
13     {}
14     
15     std::string getBaseName() const
16     {
17         return baseName;
18     }
19     
20     int getBaseData()const
21     {
22         return baseData;
23     }
24     
25     private:
26         std::string baseName;
27         int baseData;
28 };
29 
30 class derived:public base
31 {
32     public:
33         derived():base(),derivedName("")
34         {}
35         derived(std::string bn,int bd,std::string dn)
36         :base(bn,bd),derivedName(dn)
37         {}
38         std::string getDerivedName() const
39         {
40             return derivedName;
41         }
42     private:
43         std::string derivedName;
44 };
45 
46 void show(std::string& info,const base& b)
47 {
48     info.append("Name is ");
49     info.append(b.getBaseName());
50     info.append(", baseData is ");
51     char buffer[10];
52     sprintf(buffer,"%d",b.getBaseData());
53         info.append(buffer);
54 }
55 
56 int main(int argc,char* argv[])
57 {
58     base b("test",10);
59     std::string s;
60     show(s,b);
61     std::cout<<s<<std::endl;
62     derived d("btest",5,"dtest");
63     std::string ss;
64     show(ss,d);
65     std::cout<<ss<<std::endl;
66     return 0;
67 }
复制代码

运行结果为:

base:baseName is test, baseData is 10
base:baseName is btest, baseData is 5

下面改改代码,将函数参数变为derived

复制代码
void show2(std::string& info,const derived& d)
{
    info.append("Name is ");
    info.append(d.getBaseName());
    info.append(", baseData is ");
    char buffer[10];
    sprintf(buffer,"%d",d.getBaseData());
    info.append(buffer);
}
复制代码

调用show(ss,d);编译器报错

1 derived_class.cpp: In function `int main(int, char**)':
2 derived_class.cpp:84: error: invalid initialization of reference of type 'const derived&' from expression of type 'base'
3 derived_class.cpp:70: error: in passing argument 2 of `void show2(std::string&, const derived&)'

第二点对各种形式的继承作出验证,首先给出表格

继承方式\成员类型 public protected private
public public protected 无法继承
protected protected protected 无法继承
private private private 无法继承

这里解释一下,这里仅仅表达基类的成员,被public,protected,private三种方式继承后,在原基类为public,protectedc,private的成员在继承类里类型为表格里内容

复制代码
 1 class base
 2 {
 3     public:
 4         std::string testPublic()
 5         {
 6             return std::string("this is public base");
 7         }
 8     protected:
 9         std::string testProtected()
10         {
11             return std::string("this is protected base");
12         }
13     private:
14         std::string testPrivate()
15         {
16             return std::string("this is private base");
17         }
18 };
19 
20 class derivedPublic:public base
21 {
22     public:
23         std::string testPubPublic()
24         {
25             return testPublic()+= "in derived";
26         }
27         
28         std::string testProPublic()
29         {    
30             return testProtected()+= "in derived";
31         }
32         
33         std::string testPriPublic()                   
34         {    
35             return testPrivate()+= "in derived";
36         }
37 };
38 
39 int main(int argc,char* argv[])
40 41     derivedPublic dpub;
42     std::cout << dpub.testPublic() << std::endl; 
43
复制代码

报下面错误,说明testPrivate()不是derived私有函数而是base的私有函数

derived11.cpp:16: error: `std::string base::testPrivate()' is private
derived11.cpp:36: error: within this context

这样验证private类型成员无法被继承(public,private,protected)注:private,protected略去不做证明

下面只要验证 testProtected 能被第三层继承类继承,但是无法被第三层类直接调用就说明是public继承后继承类型为protected,而基类为Public类型成员则即可被继承又可以直接调用。

复制代码
 1 #include <iostream>
 2 #include <string>
 3 
 4 class base
 5 {
 6     public:
 7         std::string testPublic()
 8         {
 9             return std::string("this is public base");
10         }
11     protected:
12         std::string testProtected()
13         {
14             return std::string("this is protected base");
15         }
16     private:
17         std::string testPrivate()
18         {
19             return std::string("this is private base");
20         }
21 };
22 
23 class derivedPublic:public base
24 {
25     public:
26         std::string testPubPublic()
27         {
28             return testPublic()+= "in derived";
29         }
30         
31         std::string testProPublic()
32         {    
33             return testProtected()+= "in derived";
34         }
35         
36 //        std::string testPriPublic()                   
37 //        {    
38 //            return testPrivate()+= "in derived";
39 //        }
40 };
41 
42 class deepDerived:public derivedPublic
43 {
44     public:
45         std::string deepProtected()
46         {
47             return testProtected() +="in deep";
48         }
49         
50         std::string deepPublic()
51         {
52             return testPublic() +="indeep";
53         }
54 };
55 
56 int main(int argc,char* argv[])
57 {
58     derivedPublic dpub;
59     std::cout << dpub.testProtected() << std::endl; 
60     deepDerived deepdpub;
61     std::cout<<deepdpub.testPublic() <<std::endl;
62     std::cout<<deepdpub.testProtected() <<std::endl;
63     std::cout<<deepdpub.deepProtected() <<std::endl;
64     std::cout<<deepdpub.deepPublic() <<std::endl;
65 }
复制代码

这里服务器报错

derived12.cpp:13: error: `std::string base::testProtected()' is protected
derived12.cpp:62: error: within this context
这样就验证了一个是public,一个是protected,protected是不能直接调用的,但是被继承后是可以被public成员调用的。
下面的已经证明,详细步骤就略去如果对该部分验证感兴趣,可以看下面代码。
复制代码
  1 #include <iostream>
  2 #include <string>
  3 class base
  4 {
  5     public:
  6         std::string testPublic()
  7         {
  8             return std::string("this is public base");
  9         }
 10     protected:
 11         std::string testProtected()
 12         {
 13             return std::string("this is protected base");
 14         }
 15     private:
 16         std::string testPrivate()
 17         {
 18             return std::string("this is private base");
 19         }
 20 };
 21 
 22 class derivedPublic:public base
 23 {
 24     public:
 25         std::string testPubPublic()
 26         {
 27             return testPublic()+= "in derived";
 28         }
 29         
 30         std::string testProPublic()
 31         {    
 32             return testProtected()+= "in derived";
 33         }
 34         
 35 //        std::string testPriPublic()                   //私有成员并没有被继承下来
 36 //        {    
 37 //            return testPrivate()+= "in derived";
 38 //        }
 39 };
 40 
 41 class deepDerived:public derivedPublic
 42 {
 43     public:
 44         std::string test()
 45         {
 46             return testPublic() +="in 3";
 47         }
 48 };
 49 
 50 class derivedProtected:protected base
 51 {
 52     public:
 53         std::string testPubProtected()
 54         {
 55             return testPublic()+= "in derived";
 56         }
 57         
 58         std::string testProProtected()
 59         {    
 60             return testProtected()+= "in derived";
 61         }
 62 };
 63 
 64 class deepDerived2:public derivedProtected
 65 {
 66     public:
 67         std::string test()
 68         {
 69             return testPublic() +="in 3";
 70         }
 71 };
 72 
 73 class derivedPrivate:private base
 74 {
 75     public:
 76         std::string testPubPirvate()
 77         {
 78             return testPublic()+= "in derived";
 79         }
 80         
 81         std::string testProPrivate()
 82         {    
 83             return testProtected()+= "in derived";
 84         }
 85         
 86 };
 87 
 88 //class deepDerived3:public derivedPrivate
 89 //{
 90 //    public:
 91 //        std::string test()
 92 //        {
 93 //            return testPublic() +="in 3";
 94 //        }
 95 //};
 96 
 97 int main(int argc,char* argv[])
 98 {
 99     derivedPublic dpub;
100     //derivedProtected dpro;
101     //derivedPrivate dpri;
102     std::cout<<dpub.testPublic()<<std::endl;       //
103     //std::cout<<dpub.testProtected()<<std::endl;    //用户被继承也是无法使用
104     //cout<<dpub.testPrivate()<<std::endl;         //基类都是私有函数
105     std::cout<<dpub.testPubPublic()<<std::endl;
106     std::cout<<dpub.testProPublic()<<std::endl;
107     //std::cout<<dpub.testPriPrivate()<<std::endl; //没有被继承
108     
109     deepDerived dd;
110     std::cout<<dd.test()<<std::endl;
111         
112     derivedProtected dpro;
113     //std::cout<<dpro.testPublic()<<std::endl;        //变成protected类型
114     std::cout<<dpro.testPubProtected()<<std::endl;
115     std::cout<<dpro.testProProtected()<<std::endl;
116         
117     deepDerived2 dd2;
118     std::cout<<dd2.test()<<std::endl;
119         
120     derivedPrivate dpri;
121     std::cout<<dpri.testPubPirvate()<<std::endl;
122     std::cout<<dpri.testProPrivate()<<std::endl;
123     
124 //    deepDerived3 dd3;
125 //    std::cout<<dd3.test()<<std::endl;
126
复制代码

[C++]接口继承与实现继承

 接口继承与实现继承MoaKap所谓接口继承,就是派生类只继承函数的接口,也就是声明;而实现继承,就是派生类同时继承函数的接口和实现。我们都很清楚C++中有几个基本的概念,虚函数、纯虚函数、非虚函数。...
  • ljinddlj
  • ljinddlj
  • 2007年12月07日 11:45
  • 8777

C++中继承与派生是如何实现的?

面向对象编程的主要目的之一就是提供可重用的代码,强调可重用性。当我们在面临一个大的工程的时候,一般都会重用以前的代码,首先我们使用现有的代码可以节省编码时间,我们称重复的编码为重复的造轮子,重复的代码...
  • lidiya007
  • lidiya007
  • 2016年10月10日 16:50
  • 560

【C++拾遗】 从内存布局看C++虚继承的实现原理

准备工作 1、VS2012使用命令行选项查看对象的内存布局 微软的Visual Studio提供给用户显示C++对象在内存中的布局的选项:/d1reportSingleClassLayout。使用...
  • Xiejingfa
  • Xiejingfa
  • 2015年08月27日 16:49
  • 2729

C++接口继承与实现继承的区别和选择

1.接口继承与实现继承的区别《Effective C++》条款三十四:区分接口继承和实现继承中介绍的比较啰嗦,概括地说需要理解三点: (1)纯虚函数只提供接口继承,但可以被实现; (2)虚函数既提...
  • K346K346
  • K346K346
  • 2017年02月13日 16:34
  • 714

C语言模式实现C++继承和多态

这个问题主要考察的是C和C++的区别,以及C++中继承和多态的概念。C和C++的区别C语言是面向过程的语言,而C++是面向对象的过程。什么是面向对象和面向过程? 面向过程就是分析解决问题的步骤,然后用...
  • wenqiang1208
  • wenqiang1208
  • 2017年07月28日 12:36
  • 698

C++ - 接口继承(interface) 和 实现继承(implementation) 详解

接口继承(interface) 和 实现继承(implementation) 详解 本文地址: http://blog.csdn.net/caroline_wendy/article/detail...
  • u012515223
  • u012515223
  • 2014年04月01日 17:44
  • 7654

C++的封装、多态、继承在C中的对应实现方式

C++的特点:封装、多态、继承 1.封装是面向对象最重要的特征之一(C++中的类class),封装就是指隐藏。 对象隐藏了数据(例如private属性),避免了其他对象可以直接访问使用对象属性而...
  • yyf_it
  • yyf_it
  • 2016年08月11日 17:40
  • 684

C语言模拟实现C++的继承与多态

一、面向过程编程与面向对象编程的区别 众所周知,C语言是一种典型的面向过程编程语言,而C++确实在它的基础上改进的一款面向对象编程语言,那么,面向过程与面向对象到底有什么样的区别呢?【...
  • snow_5288
  • snow_5288
  • 2017年04月16日 21:28
  • 1166

C++继承时权限

C++中类的三种访问权限: 公用(public):访问权限最高;派生类,外部函数,对象也可以直接访问(无论是成员变量还是成员函数)。 私有(private):访问权限最低;只能是该类内部函数互相...
  • chixipeng
  • chixipeng
  • 2016年07月26日 16:47
  • 439

C++浅谈组合和继承

C++有三大特性:封装、继承和多态。 之前提到过继承是为了实现代码的复用,如果子类继承了父类那么就会继承父类所有的数据成员及成员函数,在公有继承的时候保持is-a原则,即每个子类的对象也是父类对象。 ...
  • persistence_s
  • persistence_s
  • 2017年03月08日 22:44
  • 443
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:C++ 继承及实现
举报原因:
原因补充:

(最多只允许输入30个字)