学步园

非自动继承的函数 
构造函数、析构函数和赋值函数（operator=）不能被继承。

私有继承的目的 
private继承的目的是什么，因为在类中选择创建一个private对象似乎更合适。将private继承包含在该语言中只是为了语言的完整性。但是，如果没有其他理由，则应当减少混淆，所以通常建议用private成员而不是private继承。 
然而，private继承也不是一无用处。 
这里可能偶然有这种情况，即可能想产生像基类接口一样的接口，而不允许处理该对象像处理基类对象一样。private继承提供了这个功能。

引申

能对私有继承成员公有化吗？ 
当私有继承时，基类的所有public成员都变成了private。如果希望它们中的任何一个是可视的，可以办到吗？答案是可以的，只要用派生类的public选项声明它们的名字即可（新的标准中使用using关键字）。

#include <iostream>
class base {
public:
    char f() const { return 'a'; }
    int g() const { return 2; }
    float h() const { return 3.0; }
};
class derived : base {
public:
    using base::f; // Name publicizes member
    using base::h; 
};
int main() {
    derived d;
    d.f();
    d.h();
 // d.g(); // error -- private function
    return 0;
}

这样，如果想要隐藏这个类的基类部分的功能，则private继承是有用的。

多重继承注意向上映射的二义性。比如base（有个f()方法）有两个子对象d1和d2，且都重写了base的f()方法，此时子类dd如果也有f()方法则不能同时继承自d1和d2，因为f()方法存在二义性，不知道该继承哪个f()方法。 
解决方法是对dd类中的f()方法重新定义以消除二义性，比如明确指定使用d1的f()方法。 
当然也不能将dd类向上映射为base类，这可以通过使用虚继承解决，关键字virtual，base中的f()方法改成虚函数且d1和d2的继承都改为虚继承，当然dd继承d1和d2用public继承即可。

C语言中如何关闭assert断言功能？ 
头文件：<assert.h>或<cassert> 
在开发过程中，使用它们，完成后用#define NDEBUG使之失效，以便推出产品，注意必须在头文件之前关闭才有效。

#define NDEBUG
#include <cassert>

C++如何实现动态捆绑？—即多态的实现（很重要） 
C++中为了实现多态，编译器对每个包含虚函数的类创建一个表（称为VTABLE，虚表）。在 VTABLE中，编译器放置特定类的虚函数地址。在每个带有虚函数的类中，编译器秘密地置一指针，称为vpointer（缩写为VPTR），指向这个对象的VTABLE。通过基类指针做虚函数调用时（也就是做多态调用时），编译器静态地插入取得这个VPTR，并在VTABLE表中查找函数地址的代码，这样就能调用正确的函数使晚捆绑发生。 
为每个类设置VTABLE、初始化VPTR、为虚函数调用插入代码，所有这些都是自动发生的，所以我们不必担心这些。利用虚函数，这个对象的合适的函数就能被调用，哪怕在编译器还不知道这个对象的特定类型的情况下。

在vtable表中，编译器放置了在这个类中或在它的基类中所有已声明为virtual的函数的地址。如果在这个派生类中没有对在基类中声明为virtual的函数进行重新定义，编译器就使用基类的这个虚函数地址。 
下面举个例子说明：

#include <iostream>
enum note { middleC, Csharp, Cflat };
class instrument {
public:
    virtual void play(note) const {
        cout << "instrument::play" << endl;
    }
    virtual char* what() const {
        return "instrument";
    }
    // assume this will modify the object:
    virtual void adjust(int) {}
};
class wind : public instrument {
public:
    void play(note) const {
        cout << "wind::play" << endl;
    }
    char* what() const {
        return "wind";
    }
    void adjust(int) {}
};
class percussion : public instrument {
public:
    void play(note) const {
        cout << "percussion::play" << endl;
    }
    char* what() const {
        return "percussion";
    }
    void adjust(int) {}
};
class string : public instrument {
public:
    void play(note) const {
        cout << "string::play" << endl;
    }
    char* what() const {
        return "string";
    }
    void adjust(int) {}
};
class brass : public wind {
public:
    void play(note) const {
        cout << "brass::play" << endl;
    }
    char* what() const {
        return "brass";
    }
};
class woodwind : public wind {
public:
    void play(note) const {
        cout << "woodwind::play" << endl;
    }
    char* what() const {
        return "woodwind";
    }
};
instrument *A[] = {
    new wind,
    new percussion,
    new string,
    new brass
};

下图画的是指针数组A[]。

下面看到的是通过instrument指针对于brass调用adjust()。instrument引用产生如下结果：

编译器从这个instrument指针开始，这个指针指向这个对象的起始地址。所有的instrument对象或由instrument派生的对象都有它们的VPTR，它在对象的相同的位置（常常在对象的开头），所以编译器能够取出这个对象的VPTR。VPTR指向VTABLE的开始地址。所有的VTABLE有相同的顺序，不管何种类型的对象。 play()是第一个，what()是第二个，adjust()是第三个。所以编译器知道adjust()函数必在VPTR + 2处。这样，不是“以instrument :: adjust地址调用这个函数”（这是早捆绑，是错误活动），而是产生代码，“在VPTR + 2处调用这个函数”。因为VPTR的效果和实际函数地址的确定发生在运行时，所以这样就得到了所希望的晚捆绑。向这个对象发送消息，这个对象能断定它应当做什么。

引申 — 对象切片

当多态地处理对象时，传地址与传值有明显的不同。所有在这里已经看到的例子和将会看到的例子都是传地址的，而不是传值的。这是因为地址都有相同的长度，传派生类型（它通常稍大一些）对象的地址和传基类（它通常小一点）对象的地址是相同的。如前面解释的，使用多态的目的是让对基类对象操作的代码也能操作派生类对象。 
如果使用对象而不是使用地址或引用进行向上映射，发生的事情会使我们吃惊：这个对象 被“切片”，直到所剩下来的是适合于目的的子对象。在下面例子中可以看到通过检查这个对象的长度切片剩下来的部分。

#include <iostream>
using namespace std;
class base {
    int i;
public:
    base(int I = 0) : i(I) {}
    virtual int sum() const { return i; }
};
class derived : public base {
    int j;
public:
    derived(int I = 0, int J = 0) : base(I), j(J) {}
    virtual int sum() const { return base::sum() + j; }
};
void call(base b) {
    cout << "sum = " << b.sum() << endl;
}
main() {
    base b(10);
    derived d(10, 47);
    call(b);
    call(d);
}

函数call( )通过传值传递一个类型为base的对象。然后对于这base对象调用虚函数sum( )。 我们可能希望第一次调用产生10，第二次调用产生57。实际上，两次都产生10。 在这个程序中，有两件事情发生了。

• 第一，call( )接受的只是一个base对象，所以所有在这个函数体内的代码都将只操作与base相关的数。 对call( )的任何调用都将引起一个与base大小相同的对象压栈并在调用后清除。这意味着，如果一个由base派生来类对象被传给call，编译器接受它，但只拷贝这个对象对应于base的部分，切除这个对象的派生部分，如图： 
  
  现在，我们可能对这个虚函数调用感到奇怪：这里，这个虚函数既使用了base（它仍存在）， 又使用了derived的部分（derived不再存在了，因为它被切片）。 其实我们已经从灾难中被解救出来，这个对象正安全地以值传递。因为这时编译器认为它知道这个对象的确切的类型（这个对象的额外特征有用的任何信息都已经失去）。
• 另外，用值传递时，它对base对象使用拷贝构造函数，该构造函数初始化vptr指向base vtable，并且只拷贝这个对象的base部分。这里没有显式的拷贝构造函数，所以编译器自动地为我们合成一个。由于上述诸原因，这个对象在切片期间变成了一个base对象。

对象切片实际上是去掉了对象的一部分，而不是象使用指针或引用那样简单地改变地址的内容。因此，对象向上映射不常做，事实上，通常要提防或防止这种操作。我们可以通过在基 类中放置纯虚函数来防止对象切片。这时如果进行对象切片就将引起编译时的出错信息。

最后注意：虚机制在构造函数中不工作。即在构造函数中调用虚函数没有结果。

RTTI—运行时类型识别（很重要）

• 概念

  运行时类型识别（Run-time type identification, RTTI）是在我们只有一个指向基类的指针或引用时确定一个对象的准确类型。

• 使用方法 
  一般情况下，我们并不需要知道一个类的确切类型，虚函数机制可以实现那种类型的正确行为。但是有些时候，我们有指向某个对象的基类指针，确定该对象的准确类型是很有用的。 
  RTTI与异常一样，依赖驻留在虚函数表中的类型信息。如果试图在一个没有虚函数的类上用RTTI，就得不到预期的结果。

  RTTI的两种使用方法

  • 第一种使用typeid()，就像sizeof()一样，看上都像一个函数。但实际上它是由编译器实现的。typeid()带有一个参数，它可以是一个对象引用或指针，返回全局typeinfo类的常量对象的一个引用。可以用运算符“==”和“!=”来互相比较这些对象。也可以用name()来获得类型的名称。注意，如果给typeid( )传递一个shape*型参数，它会认为类型为shape*，所以如果想知道一个指针所指对象的精确类型，我们必须逆向引用这个指针。比如，s是个shape*, 那么：

    cout << typeid(*s).name()<<endl;

    将显示出s所指向的对象类型。 
    也可以用before(typeinfo&)查询一个typeinfo对象是否在另一个typeinfo对象的前面（以定义实现的排列顺序），它将返回true或false。如果写：

    if(typeid(me).before(typeid(you))) //...

    那么表示我们正在查询me在排列顺序中是否在you之前。

  • RTTI的第二个用法叫“安全类型向下映射”。使用dynamic_cast<>模板。

  两种方法的使用举例如下：

  #include <iostream>
  #include <typeinfo>
  using namespace std;
  class base {
      int i;
  public:
      base(int I = 0) : i(I) {}
      virtual int sum() const { return i; }
  };
  class derived : public base {
      int j;
  public:
      derived(int I = 0, int J = 0) : base(I), j(J) {}
      virtual int sum() const { return base::sum() + j; }
  };
  main() {
      base *b = new derived(10, 47);
      // rtti method1
      cout << typeid(b).name() << endl; // P4base
      cout << typeid(*b).name() << endl; // 7derived
      if(typeid(b).before(typeid(*b)))
          cout << "b is before *b" << endl;
      else
          cout << "*b is before b" << endl;
      // rtti method2
      derived *d = dynamic_cast<derived*>(d);
      if(d) cout << "cast successful" << endl;
  }

  注意1：这里如果没有多态机制，则RTTI可能运行的结果不是我们想要的，比如如果没有虚函数，则这里两个都显示base，一般希望RTTI用于多态类。 
  注意2：运行时类型的识别对一个void型指针不起作用。void *确实意味着“根本没有类型信息”。

  void *v = new stimpy;
  stimpy* s = dynamic_cast<stimpy*>(v);  // error
  cout << typeid(*v).name() << endl;     // error

• RTTI的实现 
  **典型的RTTI是通过在VTABLE中放一个额外的指针来实现的。这个指针指向一个描述该特定类型的typeinfo结构（每个新类只产生一个typeinfo的实例），所以typeid( )表达式的作用实际上很简单。**VPTR用来取typeinfo的指针，然后产生一个结果typeinfo结构的一个引用—这是一个决定性的步骤—我们已经知道它要花多少时间。

  对于dynamic_cast<目标* > <源指针>，多数情况下是很容易的，先恢复源指针的RTTI信息再取出目标*的类型RTTI信息，然后调用库中的一个例程判断源指针是否与目标*相同或者是目标*类型的基类。它可能对返回的指针做了一点小的改动，因为目的指针类可能存在多重继承的情况，而源指针类型并不是派生类的第一个基类。在多重继承时情况会变得复杂些，因为一个基类在继承层次中可能出现一次以上，并且可能有虚基类。 
  用于动态映射的库例程必须检查一串长长的基类列表，所以动态映射的开销比typeid()要大（当然我们得到的信息也不同，这对于我们的问题来说可能很关键），并且这是非确定性的，因为查找一个基类要比查找一个派生类花更多的时间。另外动态映射允许我们比较任何类型，不限于在同一个继承层次中比较两个类。这使得动态映射调用的库例程开销更高了。

  映射类型	含义
  static_cast	为了“行为良好”和“行为较好”而使用的映射，包括一些我们可能现在不用的映射（如向上映射和自动类型转换）
  const_cast	用于映射常量和变量（const和volatile）
  const_cast	为了安全类型的向下映射（本章前面已经介绍）
  reinterpret_cast	为了映射到一个完全不同的意思。这个关键词在我们需要把类型映射回原有类型时要用到它。我们映射到的类型仅仅是为了故弄玄虚和其他目的。这是所有映射中最危险的

  注意：如果想把一个const 转换为非const，或把一个volatile转换成一个非volatile（勿遗忘这种情况），就要用到const_cast。这是可以用const_cast的唯一转换。如果还有其他的转换牵涉进来，它必须分开来指定，否则会有一个编译错误。