在基类中，public和private标号具有普通含义：用户代码可以访问类的public成员而不能访问private成员，private成员只能由基类的成员和友元访问。可以认为protected标号是private和public的混合:1）像private成员一样，protected成员不能被类的用户访问；2）像public成员一样，protected成员可以被该类的派生类访问；3）派生类只能通过派生类对象访问其基类的protected成员，派生类对其基类类型的protected成员没有特殊的访问权限。

基类本生指定对自身成员的最小访问控制。如果成员在基类中为private，则只有基类和基类的友元可以访问该成员。派生类不能访问基类的private成员，也不能使自己的用户能访问那些成员。如果基类成员为public或者protected，则派生列表中使用的访问标号决定该成员在派生类中的访问级别：

（1）public继承，基类成员保持自己的访问级别：基类的public成员为派生类的public成员，基类的protected成员为派生类的protected成员。

（2）private继承，基类的public成员和protected成员在派生类中为private成员。

（3）protected继承：基类的public和protected成员在派生类中为protected成员。

2、继承中的构造函数和复制控制成员

构造函数和复制控制成员不能继承，每个类定义自己的构造函数和复制控制成员。像任何类一样，如果类不定义自己的默认构造函数和复制控制成员，就将使用合成版本。

（1）派生类的构造函数

class Item_base{
public:
    Item_base(const std::string &book="",double sales_price=0.0):isbn(book),price(sales_price){}
    std::string book() const{return isbn;}
    virtual double net_price(std::size_t n)const {return n*price;}
    virtual ~Item_base(){}
private:
    std::string isbn;
protected:
    double price;
};

class Bulk_item:public Item_base{
public:
    double net_price(std::size_t) const;
private:
    std::size_t min_qty;
    double discount;    
};

派生类的默认构造函数和非派生类的构造函数只有一点不同：除了初始化派生类的数据成员外，它还初始化派生类对象的基类部分。基类部分由基类的默认构造函数初始化。对于Bulk_item类，合成的默认构造函数会这样执行：调用Item_base的默认构造函数，将isbn初始化为空串，将price成员初始化为0。接着用常规变量初始化规则初始化Bulk_item的成员，也就是说，min_qty和discount成员会是未初始化的。因为Buik_item具有内置类型的成员，所以应该定义自己的默认构造函数。

class Bulk_item:public Item_base{
public:
    Buik_item():min_qty(0),discount(0.0){}
    double net_price(std::size_t) const;
private:
    std::size_t min_qty;
    double discount;    
};

这个函数使用参数初始化表初始化min_qty和discount成员。这个构造函数的运行效果是首先使用item_base的默认构造函数初始化Item_base部分，那个构造函数将isbn置为空串并将price置为0。Item_base构造函数执行完毕之后，再初始化Buik_item部分的成员，并执行构造函数的函数体。除了默认构造函数外，Item_base类还能使用户能够初始化isbn和price成员，事实上，我们希望用户能够指定整个Bulk_item的值，包括折扣率和数量。派生类的构造函数的初始化表只能初始化派生类的成员，不能直接初始化继承成员。派生类构造函数通过将基类包含在构造函数初始化列表中来间接初始化继承成员。

class Bulk_item : public Item_base{
public:
    Bulk_item(const std::string& book,double sales_price,std::size_t qty=0,double disc_rate = 0.0):
              Item_base(book,sales_price),min_qty(qty),discount(disc_rate){}
    ...
private:
    ...
};

注意：派生类中只能初始化直接基类，不能初始化间接基类。

（2）复制控制和继承

只包含类类型的成员或内置类型数据成员、不含指针的类一般可以使用合成操作，复制、赋值、析构这样的操作不需要特殊控制。具有指针成员的类一般需要定义自己的复制控制来管理这些成员。如果派生类定义了自己的复制构造函数，该复制构造函数一般应显式使用基类复制构造函数初始化对象的基类部分：

class Base{...};
class Derived:public Base{
public:
    Derived(const Derived& d):Base(d),...{...}

}

初始化函数Base(d)将派生类对象d转换为它的基类部分的引用，并调用基类复制构造函数。如果省略基类初始化函数Base(d)，效果是运行Base的默认构造函数初始化对象的基类部分。此时新构造的对象具有奇怪的配置：它的Base部分将保存默认值，它的Derived成员是另一对象的副本。赋值操作符通常和复制构造函数类似：如果派生类定义了自己的赋值操作符，则该操作符必须对基类部分进行显式赋值。

Derived &Derived::operator=(const Derived &rhs)
{
    if(ths!=rhs){
        Base::operator=(rhs);
        //clean up old vlaue
        //assign member from the derived
    }
    return *this;
}

析构函数的工作和复制构造函数和赋值操作符不同：派生类析构函数不负责撤销基类对象的成员。编译器总是显式调用派生类对象基类部分的析构函数，每个析构函数只负责清除自己的成员。

class Derived : public Base{
public:
    ~Derived(){}
    //Base::~Base();

}

对象的撤销顺序和构造顺序相反：首先运行派生类的析构函数，然后按层次依次向上调用各基类析构函数。

3、虚函数和多态

（1）virtual和虚函数

通过继承我们能够定义这样的类，它们对类型之间的关系建模，共享公共的东西，仅仅特化本质上不同的东西。派生类能够继承基类定义的成员，派生类可以无需改变而使用那些与派生类型具体特性不相关的操作，派生类可以重定义那些与派生类型相关的成员函数，将函数特化，考虑派生类的特性。最后，除了从基类继承的成员以外，派生类还可以定义更多的成员。在C++中，基类必须指出希望派生类重定义的那些函数，定义为virtual的函数是基类期待派生类重定义的，基类希望派生类继承的函数不能成功定义为虚函数。除了构造函数外，任意非static成员函数都可以是虚函数。保留的关键字virtual只在类内部的成员函数出现，不能在类定义体外部出现的函数定义上。

在C++中通过基类的引用（或指针）调用虚函数时，发生动态绑定。引用或指针既可以指向基类对象也可以指向派生类对象，这一事实是动态绑定的关键。对非虚函数的调用在编译时确定，如果调用非虚函数，则无论实际对象是什么类型，都执行基类类型所定义的函数，如果调用虚函数，则直到运行时才能确定调用哪个函数。被调用的虚函数是引用或指针所指对象的实际类型所定义的。一旦函数在基类中声明为虚函数，它就一直为虚函数，派生类无法改变虚函数这一个事实。此外，派生类的虚函数声明必须和基类中的定义方式完全匹配，但有一个例外：返回对基类类型的引用（或指针）的虚函数。派生类的虚函数可以返回基类函数所返回类型的派生类的引用（或指针）。

（2）派生类到基类的转换

因为每个派生类对象都包含基类的部分，所以可以将基类类型的引用绑定到派生类对象的基类部分，也可以用指向基类的指针指向派生类对象。因为这个原因，使用基类类型的指针或引用时，不知道指针或引用所绑定的对象类型：基类类型的引用或指针可以引用基类类型对象，也可以引用派生类类型对象。无论实际对象具有哪种类型，编译器都将它当做基类类型对象。

将基类类型的引用或指针绑定到派生类对象对派生类对象没有影响，对象本身不会改变，仍为派生类对象。对象的实际类型可能不同于该对象引用或指针的静态类型，这时C++中动态绑定的关键。通过引用或指针调用虚函数时，编译器将生成代码，在运行时确定调用哪个函数。被调用的是与动态类型相对应的函数。

如果有一个派生类对象，则可以使用它的地址对基类类型的指针进行赋值或初始化，也可以使用派生类对象的引用初始化基类类型的引用。严格来说，编译器不会自动将派生类对象转换为基类类型的对象，但是，一般可以用派生类对象对基类对象进行赋值或初始化。注意：对对象进行初始化或赋值以及可以自动转换引用或指针，这之间是由区别的。

1）引用转换不同于转换对象：

将派生类对象传给希望接收基类引用的函数时，引用直接绑定到该对象，对象本身未被复制，并且转换不会在任何方面改变派生类型对象，该对象仍然是派生类对象。将派生类对象传给希望接受基类类型对象（而不是引用）的函数时，形参的类型是固定的，在编译和运行时形参都是基类类型对象，如果用派生类类型对象调用这样的函数，则该派生类对象的基类部分被复制到形参。一个是将派生类对象转换为基类类型引用，一个是用派生类对象对基类对象进行初始化或赋值。

2）派生类对象对基类对象进行赋值或初始化：

用派生类对象对基类进行初始化或赋值时，首先会将派生类对象转换为基类对象的引用，然后将该引用作为实参传递给基类的复制构造函数或赋值操作符。

3）基类到派生类的自动转换是不存在的。

（3）纯虚函数

如果只对基类的虚函数进行声明但不进行定义，那么这个虚函数称为纯虚函数。在函数形参后面写上=0以指定纯虚函数。

class Disc_item:public Item_base{
public:
    double net_price(std::size_t) const = 0;
    ...
private:
    ...
};

该函数定义为纯虚函数能够说明，该函数为后代类型提供了可以覆盖的接口，但是这个类中的版本绝不会调用。重要的是，用户不能创建Disc_item类型的对象。含有（或继承）一个或多个纯虚函数的类时抽象基类。除了作为抽象基类的派生类的对象的组成部分，不能创建抽象基类的对象。

（4）虚函数可以是私有的吗？

虚函数可以是私有的，也可以是公有的。虚函数在基类公有在派生类私有，或者虚函数在基类私有在派生类公有，或者在基类和派生类同时为私有或者公有都行，不影响使用。

#include<iostream>
using namespace std;

class A{
public:
	void foo() { bar(); }
private:
	virtual void bar() { cout << "virtual A"<<endl; }
};

class B : public A
{
private:
	virtual void bar() { cout << "virtual B"<<endl; }
};

void Test() {
	A a;
	A *p = &a;
	B b;
	p = &b;
	p->foo();	
}

（5）为什么静态成员函数不能为虚函数

static成员不属于任何类对象或类实例，所以即使给此函数加上virutal也是没有任何意义的。
静态与非静态成员函数之间有一个主要的区别。那就是静态成员函数没有this指针。

虚函数依靠vptr和vtable来处理。vptr是一个指针，在类的构造函数中创建生成，并且只能用this指针来访问它，因为它是类的一个成员，并且vptr指向保存虚函数地址的vtable。对于静态成员函数，它没有this指针，所以无法访问vptr. 这就是为何static函数不能为virtual。虚函数的调用关系：this -> vptr -> vtable ->virtual function。

4、构造函数、析构函数和虚函数关系

（1）构造函数可以为虚函数吗？

构造函数绝对不能为虚函数。因为每个虚函数对应虚表（vtable）上的一项，这个vtable实际上式存储在对象的内存空间的，如果构造函数是虚的，就需要通过虚表来调用，可是对象还没有实例化，也就是内存空间还没有，无法找到虚表，所以构造函数不能是虚函数。

（2）析构函数可以为虚函数吗？

基类中的析构函数必须为虚函数。因为删除指向动态分配对象的指针时，需要运行析构函数在释放对象的内存前清除对象。处理继承层次中的对象时，指针的静态类型可能与被删除对象的动态类型不同，可能会删除实际指向派生类对象的基类类型的指针。如果删除基类指针，则需要运行基类析构函数并清除基类的成员，如果对象实际是派生类型的，则没有定义该行为。要保证运行适当的析构函数，基类中析构函数必须为虚函数。如果析构函数为虚函数，那么通过指针调用，运行哪个析构函数将因指针所指对象类型的不同而不同。

（3）构造函数和析构函数中可以调用虚函数吗？

构造函数和析构函数中都不能调用虚函数。构造派生类对象时，首先运行基类构造函数初始化对象的基类部分。执行基类构造函数时，派生类部分是未初始化的。撤销派生类对象时，首先撤销它的派生类部分，然后按照与构造顺序逆序撤销它的基类部分。在这两种情况下，运行构造函数或析构函数时，对象都是不完整的。为了适应这种不完整，编译器将对象的类型视为在构造或析构期间发生了变化。在基类构造函数或析构函数中，将派生类对象当做基类对象对待。构造或析构期间的对象类型对虚函数的绑定有影响。如果在构造函数或析构函数中调用虚函数，则运行的是为构造函数或析构函数自身类型定义的版本。

#include<iostream>
using namespace std;
class Base
{
public:
	Base(){	Fuction();}
	virtual void Fuction(){	cout << "Base::Fuction" << endl;}
};

class A : public Base
{
public:
	A(){Fuction();}
	virtual void Fuction(){	cout << "A::Fuction" << endl;}
};

void Test() {
	A a;
}

输出为：

Base::Fuction
A::Fuction

参考：《C++ primer》

收录于