实用指南：用于快速回顾之前遗漏或者补充C++知识。

C++ 快速回顾（一）

• 前言
• 一、InLine 内联函数
• 二、类继承的私有保护公开关系
• • Public
  • Protected
  • Private
• 三、多继承、菱形继承、虚继承
• • 多继承
  • 菱形继承 和 虚继承

---

前言

用于快速回顾之前遗漏或者补充C++知识

一、InLine 内联函数

形式如下

需要注意内联函数体需要：简单、不能有循环或递归

二、类继承的私有保护公开关系

Public

公开继承基类，和我们正常认知一样

class TestBase
{
private:
void FuncPrivate(){
}
protected:
void FuncProtected(){
}
public:
void FuncPublic(){
}
};
class TestChild01
: public TestBase
{
void TestFunc() {
FuncProtected();
FuncPublic();
}
};
int main()
{
TestChild01 test01;
test01.FuncPublic();
}

Protected

protected 继承变成了TestChild01 的保护成员

class TestBase
{
private:
void FuncPrivate(){
}
protected:
void FuncProtected(){
}
public:
void FuncPublic(){
}
};
class TestChild01
: protected TestBase
{
void TestFunc() {
FuncProtected();
FuncPublic();
}
};
int main()
{
TestChild01 test01;
//test01.FuncPublic(); // protected 继承变成了TestChild01 的保护成员
}

Private

看下面的代码是看不出来private继承父类和保护继承有什么区别

class TestBase
{
private:
void FuncPrivate(){
}
protected:
void FuncProtected(){
}
public:
void FuncPublic(){
}
};
class TestChild01
: private TestBase
{
void TestFunc() {
FuncProtected();
FuncPublic();
}
};
int main()
{
TestChild01 test01;
}

保护变成了TestChild01 的私有
公共也变成了TestChild01 的私有

class TestBase
{
private:
void FuncPrivate(){
}
protected:
void FuncProtected(){
}
public:
void FuncPublic(){
}
};
class TestChild01
: private TestBase
{
void TestFunc() {
FuncProtected();
FuncPublic();
}
};
class TestChild02
: public TestChild01
{
void TestFunc() {
//FuncProtected(); // 保护变成了TestChild01 的私有
//FuncPublic(); // 公共也变成了TestChild01 的私有
}
};
int main()
{
TestChild01 test01;
}

三、多继承、菱形继承、虚继承

多继承

总结一句话就是当接口去用即可，对具体的功能抽象

菱形继承 和 虚继承

轻易不要去写这种，但是要学会去看

class A
{
public:
A()
{
printf("A Ctor.\r\n");
}
};
class B
: public A
{
};
class C
: public A
{
};
class D
: public B, public C
{
};
int main()
{
D d;
system("pause");
}

输出结果如下，由于B、C都继承了A，D继承了B、C导致会触发两次A的构造

如下代码片段是菱形继承导致不知道调用谁的函数

class A
{
public:
A()
{
printf("A Ctor.\r\n");
}
void TestFunc()
{
printf("TestFunc.\r\n");
}
};
class B
: public A
{
};
class C
: public A
{
};
class D
: public B, public C
{
};
int main()
{
D d;
//d.TestFunc(); 不清楚要调用谁的 B的？C的？还是A的？
system("pause");
}

使用虚继承可以解决上面的问题虚继承导致只有A的一份副本，只调用一次A的构造

class A
{
public:
A()
{
printf("A Ctor.\r\n");
}
void TestFunc()
{
printf("TestFunc.\r\n");
}
};
class B
: virtual public A
{
};
class C
: virtual public A
{
};
class D
: public B, public C
{
};
int main()
{
D d;
d.TestFunc();
system("pause");
}

输出结果：