Effective C++ 阅读笔记（二）public继承与继承中的函数覆盖

public继承 is-a的关系

　　public继承是一种is-a关系。也就是说适用于base classes（基类）身上的每一件事都一定适用于derived classes（继承类），每一个derived classes对象都是一个derived classes对象。

class A{
void func();
...
}

class B : public A{
...
}

void func1(A a)
{
...
}

B b;
B.func(); // can call the func of A

func1(B); // auto chuange to A

　　上面的例子中，每一个B都是一个A对象，故我们可以调用A中的函数，而且对于一个操作A的函数，我们也可以直接用B作为参数，这时，B会自动转换为A对象。

　　也就是说，public继承导致了功能的扩展，在基类可以使用的地方，继承类都可以。反之，如果你想在使用继承类的地方用基类来替换，那就很可能出现错误。他们的关系大概是这样的：

避免掩饰继承而来的名称

　这个问题其实与继承无关。 看一个关于全局变量和局部变量的例子：

int x;                                   //global变量
void someFunc()
{
double x;                       //local变量
std::cin>>x;                   // double x
}

　　这里的int x为全局变量，double x为局部变量。

　　在继承中，当位于一个derived class成员函数需要使用base class内的内容时，编译器就要找出我们需要的内容，这是由于derived class作用域被嵌套在base class作用域内。

class Base{
private:
int x;
public:
virtual void mf1() = 0;
virtual void mf2();
...
};

class Derived : public Base{
public:
virtual void mf1();
void mf4();
...
};

用图形来表示大概是这样的：



　　编译器在查找目标内容时，首先在local作用域中查找，就是途中的Derived作用域，如果没有找到我们需要的内容，就会向外移动，在Base作用域中开始查找。

　　但这里会有一个问题，如果名称相同，无论参数是什么的（无论是需函数还是非虚函数），都会被覆盖。注意：这里与函数重载是不同的～！！！！

如下：

class Base{
private:
int x;
public:
virtual void mf1() = 0;
virtual void mf1(int);
virtual void mf2();
void mf3();
void mf3(double);
...
};

class Derived : public Base{
public:
virtual void mf1();
void mf2();
void mf4();
}

Derived d;
int x;

d.mf1();    //Derived::mf1()
d.mf1(x);  //error
d.mf2();    //Derived::mf2()
d.mf3();    //Derived::mf3()
d.mf3(x);  //error

　　上面出现的错误的原因在于，Derived class中的同名函数覆盖了Base class的。

　　那怎么解决这个问题呢？

可以使用using生命表达目标内容

转交函数

class Base{
private:
int x;
public:
virtual void mf1() = 0;
virtual void mf1(int);
virtual void mf2();
void mf3();
void mf3(double);
...
};

class Derived : public Base{
public:
using Base::mf1;
using Base::mf3;
virtual void mf1();
void mf2();
void mf4();
}

　　通过使用using声明式，修改后我们就可以调用Base class内的同名函数了。

class Base{
private:
int x;
public:
virtual void mf1() = 0;
virtual void mf1(int);
virtual void mf2();
void mf3();
void mf3(double);
...
};

class Derived : private Base{
public:
virtual void mf1(){ Base::mf1(); };
void mf2();
void mf4();
}

Derived d;
int x;
d.mf1();   //Deriver::mf1()
d.mf1(x);  //error

　　通过私有继承private，实现了Base class中函数的掩盖，然后通过Base::mf1来调用Base class中某个函数，实现了具体的功能掩盖和实现。