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&)'
|
第二点对各种形式的继承作出验证，首先给出表格
| 继承方式\成员类型 | public | protected | private |
| public | public | protected | 无法继承 |
| protected | protected | protected | 无法继承 |
| private | private | private | 无法继承 |
这里解释一下，这里仅仅表达基类的成员，被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继承的资料整理，后续继续补充相关资料，谢谢大家对本站的支持！
如果您对该产品感兴趣，请填写办理（客服微信：xiaoxiongyidong）
发表评论
◎欢迎参与讨论，请在这里发表您的看法、交流您的观点。