C++ 快速回顾（一）

---

前言

用于快速回顾之前遗漏或者补充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");
}

输出结果：