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");
}

输出结果：