从标准中10.4节的抽象类第6段：
“可以从抽象类的构造函数（或析构函数）调用成员函数；但直接或间接地为正在从这样的构造函数（或析构函数）创建（或销毁）的对象做出虚函数调用以调用纯虚函数时的效果是未定义的。”
如果标准允许在构造函数（或析构函数）中调用非纯虚函数，为什么会有这种差异？
[编辑]有关纯虚函数的更多标准引用：
§ 10.4/2 通过在类定义中的函数声明中使用纯说明符（9.2），可以指定虚函数为纯函数。只有当使用限定符ID语法（5.1）调用、或像使用限定符ID语法一样调用（12.4）时，才需要定义纯虚函数。 [ 注意：函数声明不能同时提供纯说明符和定义 - 结束说明 ]
§ 12.4/9 可以声明虚构函数（10.3）或 纯虚函数（10.4）；如果在程序中创建了该类或任何派生类的任何对象，则必须定义析构函数。
需要回答的一些问题是：
如果没有为纯虚函数提供实现，这不应该是编译器或链接器错误吗？
如果为纯虚函数提供了实现，为什么在这种情况下不能将其定义良好并调用该函数?
由于虚函数调用永远不能调用纯虚函数--唯一的调用纯虚函数的方法是使用显式（限定）调用。
现在除了构造函数或析构函数外，这是由于您实际上永远无法拥有抽象类的对象。您必须拥有某个非抽象派生类的对象，该类覆盖了纯虚函数（如果没有覆盖它，则该类将是抽象类）。但是，在运行构造函数或析构函数时，您可能拥有中间状态的对象。但是，由于标准规定在此状态下虚拟调用纯虚函数会导致未定义的行为，因此编译器可以不必特殊处理以正确执行此操作，从而为实现纯虚函数提供了更大的灵活性。特别地，编译器可以像实现非纯虚函数一样来实现纯虚函数（无需特殊处理），并且如果您从构造函数/析构函数中调用纯虚函数，编译器可能会崩溃或以其他方式失败。
我认为这段代码是标准所引用的未定义行为的一个例子。尤其是，编译器很难注意到这个问题。
顺便说一下，当我说“编译器”时，实际上是指“编译器和链接器”，如果有任何困惑请谅解。
struct Abstract {
virtual void pure() = 0;
virtual void foo() {
pure();
}
Abstract() {
foo();
}
~Abstract() {
foo();
}
};
struct X : public Abstract {
virtual void pure() { cout << " X :: pure() " << endl; }
virtual void impure() { cout << " X :: impure() " << endl; }
};
int main() {
X x;
}
（this->*mem_fun）()，则不能指望它知道 mem_fun 定义得有多好。struct Base
{
virtual ~Base() { /* calling foo here would be undefined */}
virtual void foo() = 0;
};
struct Derived : public Base
{
~Derived() { foo(); }
virtual void foo() { }
};
讨论已经转向建议以下替代方案：
示例代码无疑会是这样的： class Base { // 其他内容 virtual void init() = 0; virtual void cleanup() = 0; };
Base::Base()
{
init(); // pure virtual function
}
Base::~Base()
{
cleanup(); // which is a pure virtual function. You can't do that! shouts the compiler.
}
很明显，你正在做的事情会让你陷入麻烦。一个好的编译器可能会发出警告。
另一种选择是寻找 Base::init() 和 Base::cleanup() 的定义，并在存在时调用它，否则将调用链接错误，即将清除操作视为构造函数和析构函数的非虚拟函数。
问题在于，如果你有一个非虚拟函数调用虚拟函数，这种方法就行不通了。
class Base
{
void init();
void cleanup();
// other stuff. Assume access given as appropriate in examples
virtual ~Base();
virtual void doinit() = 0;
virtual void docleanup() = 0;
};
Base::Base()
{
init(); // non-virtual function
}
Base::~Base()
{
cleanup();
}
void Base::init()
{
doinit();
}
void Base::cleanup()
{
docleanup();
}
Base::~Base()
{
someCollection.removeMe( this );
}
void CollectionType::removeMe( Base* base )
{
base->cleanup(); // ouch
}
=0;？那个信息是否可以记录在其他地方，甚至在另一个翻译单元中？如果实现可以在其他地方指定，那么它的“纯度”是否可以在其他地方指定？ - Aaron McDaid#include<iostream>
using namespace std;
struct Abstract {
virtual void pure() = 0;
virtual void impure() { cout << " Abstract :: impure() " << endl; }
Abstract() {
impure();
// pure(); // would be undefined
}
~Abstract() {
impure();
// pure(); // would be undefined
}
};
struct X : public Abstract {
virtual void pure() { cout << " X :: pure() " << endl; }
virtual void impure() { cout << " X :: impure() " << endl; }
};
int main() {
X x;
x.pure();
x.impure();
}
这个的输出是：
Abstract :: impure() // called while x is being constructed
X :: pure() // x.pure();
X :: impure() // x.impure();
Abstract :: impure() // called while x is being destructed.
x 是抽象类型的引用或指针，结果也将是相同的。impure() 的调用调用了 Abstract::impure()，而不是 X::impure()，即使正在构造的对象是类型为 X 的对象。析构函数中也是如此。X 的对象时，首先构造的只是一个 Abstract 对象，并且关键是它不知道它最终将成为一个 X 对象。销毁时也是同样的过程。Abstract :: pure 可以由构造函数或析构函数调用，因此尝试定义此行为（除了可能作为编译错误）是没有意义的。
更新：我刚刚发现在虚拟类中可以给一个纯虚方法提供实现。问题是：这有意义吗？
struct Abstract {
virtual void pure() = 0;
};
void Abstract :: pure() { cout << "How can I be called?!" << endl; }
永远不会有一个动态类型为Abstract的对象，因此您将无法通过正常调用abs.pure();或类似方法来执行此代码。那么，允许这样的定义有什么意义呢？
请参见this demo。编译器会发出警告，但现在可以从构造函数中调用Abstract::pure()方法。这是唯一可以调用Abstract::pure()的途径。
但是，这在技术上是未定义的。另一个编译器有权忽略Abstract::pure的实现，甚至做其他疯狂的事情。我不知道为什么这不被定义 - 但我写这篇文章是为了帮助澄清这个问题。
Abstract::pure() { cout << "Abstract pure" << endl; }，并保持声明 virtual void pure() = 0;。与 impure() 虚函数相比，有什么区别？ - Belloc