C++ 继承详解及实例代码

原创 已于 2026-04-29 04:09:16 修改 · 86 阅读 · 1 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
标签
#c++ #开发语言
于 2026-04-29 02:42:51 首次发布

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

　　public继承，例如下：

1 class base
2 ｛...｝
3 class derived:public base
4 ｛...｝

　　如果这样写，编译器会理解成类型为derived的对象同时也是类型为base的对象，但类型为base的对象不是类型为derived的对象。这点很重要。那么函数形参为base类型适用于derived，形参为derived不适用于base。下面是验证代码，一个参数为base的函数，传入derived应该成功执行，相反，一个参数为derived的函数

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

#include <iostream>

#include <stdio.h>

class base

{

  public:

  base()

  :baseName(""),baseData(0)

  {}

   

  base(std::string bn,int bd)

  :baseName(bn),baseData(bd)

  {}

   

  std::string getBaseName() const

  {

    return baseName;

  }

   

  int getBaseData()const

  {

    return baseData;

  }

   

  private:

    std::string baseName;

    int baseData;

};

class derived:public base

{

  public:

    derived():base(),derivedName("")

    {}

    derived(std::string bn,int bd,std::string dn)

    :base(bn,bd),derivedName(dn)

    {}

    std::string getDerivedName() const

    {

      return derivedName;

    }

  private:

    std::string derivedName;

};

void show(std::string& info,const base& b)

{

  info.append("Name is ");

  info.append(b.getBaseName());

  info.append(", baseData is ");

  char buffer[10];

  sprintf(buffer,"%d",b.getBaseData());

    info.append(buffer);

}

int main(int argc,char* argv[])

{

  base b("test",10);

  std::string s;

  show(s,b);

  std::cout<<s<<std::endl;

  derived d("btest",5,"dtest");

  std::string ss;

  show(ss,d);

  std::cout<<ss<<std::endl;

  return 0;

}

运行结果为：

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

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

1

2

3

4

5

6

7

8

9

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

2

3

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&)'

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

继承方式\成员类型publicprotectedprivate
publicpublicprotected无法继承
protectedprotectedprotected无法继承
privateprivateprivate无法继承

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

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

class base

{

  public:

    std::string testPublic()

    {

      return std::string("this is public base");

    }

  protected:

    std::string testProtected()

    {

      return std::string("this is protected base");

    }

  private:

    std::string testPrivate()

    {

      return std::string("this is private base");

    }

};

class derivedPublic:public base

{

  public:

    std::string testPubPublic()

    {

      return testPublic()+= "in derived";

    }

     

    std::string testProPublic()

    { 

      return testProtected()+= "in derived";

    }

     

    std::string testPriPublic()         

    { 

      return testPrivate()+= "in derived";

    }

};

int main(int argc,char* argv[])

｛

  derivedPublic dpub;

  std::cout << dpub.testPublic() << std::endl;

｝

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

1

2

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

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

#include <iostream>

#include <string>

class base

{

  public:

    std::string testPublic()

    {

      return std::string("this is public base");

    }

  protected:

    std::string testProtected()

    {

      return std::string("this is protected base");

    }

  private:

    std::string testPrivate()

    {

      return std::string("this is private base");

    }

};

class derivedPublic:public base

{

  public:

    std::string testPubPublic()

    {

      return testPublic()+= "in derived";

    }

     

    std::string testProPublic()

    { 

      return testProtected()+= "in derived";

    }

     

//    std::string testPriPublic()         

//    { 

//      return testPrivate()+= "in derived";

//    }

};

class deepDerived:public derivedPublic

{

  public:

    std::string deepProtected()

    {

      return testProtected() +="in deep";

    }

     

    std::string deepPublic()

    {

      return testPublic() +="indeep";

    }

};

int main(int argc,char* argv[])

{

  derivedPublic dpub;

  std::cout << dpub.testProtected() << std::endl;

  deepDerived deepdpub;

  std::cout<<deepdpub.testPublic() <<std::endl;

  std::cout<<deepdpub.testProtected() <<std::endl;

  std::cout<<deepdpub.deepProtected() <<std::endl;

  std::cout<<deepdpub.deepPublic() <<std::endl;

}

这里服务器报错

1

2

derived12.cpp:13: error: `std::string base::testProtected()' is protected

derived12.cpp:62: error: within this context

这样就验证了一个是public，一个是protected，protected是不能直接调用的，但是被继承后是可以被public成员调用的。
下面的已经证明，详细步骤就略去如果对该部分验证感兴趣，可以看下面代码。

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

#include <iostream>

#include <string>

class base

{

  public:

    std::string testPublic()

    {

      return std::string("this is public base");

    }

  protected:

    std::string testProtected()

    {

      return std::string("this is protected base");

    }

  private:

    std::string testPrivate()

    {

      return std::string("this is private base");

    }

};

class derivedPublic:public base

{

  public:

    std::string testPubPublic()

    {

      return testPublic()+= "in derived";

    }

     

    std::string testProPublic()

    { 

      return testProtected()+= "in derived";

    }

     

//    std::string testPriPublic()          //私有成员并没有被继承下来

//    { 

//      return testPrivate()+= "in derived";

//    }

};

class deepDerived:public derivedPublic

{

  public:

    std::string test()

    {

      return testPublic() +="in 3";

    }

};

class derivedProtected:protected base

{

  public:

    std::string testPubProtected()

    {

      return testPublic()+= "in derived";

    }

     

    std::string testProProtected()

    { 

      return testProtected()+= "in derived";

    }

};

class deepDerived2:public derivedProtected

{

  public:

    std::string test()

    {

      return testPublic() +="in 3";

    }

};

class derivedPrivate:private base

{

  public:

    std::string testPubPirvate()

    {

      return testPublic()+= "in derived";

    }

     

    std::string testProPrivate()

    { 

      return testProtected()+= "in derived";

    }

     

};

//class deepDerived3:public derivedPrivate

//{

//  public:

//    std::string test()

//    {

//      return testPublic() +="in 3";

//    }

//};

int main(int argc,char* argv[])

{

  derivedPublic dpub;

  //derivedProtected dpro;

  //derivedPrivate dpri;

  std::cout<<dpub.testPublic()<<std::endl;    //

  //std::cout<<dpub.testProtected()<<std::endl;  //用户被继承也是无法使用

  //cout<<dpub.testPrivate()<<std::endl;     //基类都是私有函数

  std::cout<<dpub.testPubPublic()<<std::endl;

  std::cout<<dpub.testProPublic()<<std::endl;

  //std::cout<<dpub.testPriPrivate()<<std::endl; //没有被继承

   

  deepDerived dd;

  std::cout<<dd.test()<<std::endl;

     

  derivedProtected dpro;

  //std::cout<<dpro.testPublic()<<std::endl;    //变成protected类型

  std::cout<<dpro.testPubProtected()<<std::endl;

  std::cout<<dpro.testProProtected()<<std::endl;

     

  deepDerived2 dd2;

  std::cout<<dd2.test()<<std::endl;

     

  derivedPrivate dpri;

  std::cout<<dpri.testPubPirvate()<<std::endl;

  std::cout<<dpri.testProPrivate()<<std::endl;

   

//  deepDerived3 dd3;

//  std::cout<<dd3.test()<<std::endl;

｝

以上就是对C++ j继承的资料整理，后续继续补充相关资料

sillyoung
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值