为什么STL容器没有虚拟析构函数？

Question

有谁知道为什么STL容器没有虚拟析构函数？

据我所知，唯一的好处是：

• 它由一个指针（到虚拟方法表）和
• 减少一个实例的大小它使破坏和结构的小位更快。

缺点是以通常的方式子集化容器是不安全的。

编辑： 也许我的问题可以改写为什么不是STL容器设计允许继承？

因为它们不支持继承，所以当想要有一个需要STL功能的新容器加上少量附加功能时（例如，使用默认值的专门构造函数或新访问器对地图，或其他）：

• 组成和接口复制：使拥有该STL容器作为私有成员，每种方法STL的一个交叉联方法一个新的模板或类。这与继承一样有效，避免了虚拟方法表（在重要的情况下）的成本。不幸的是，STL容器有相当宽泛的接口，所以这需要许多代码来完成一些看起来应该很容易的事情。
• 只是使功能：使用裸（可能模板化）文件范围的功能，而不是尝试添加成员函数。在某些方面，这可能是一个很好的方法，但封装的好处将会丢失。
• 具有公共STL访问的组合：让STL容器的所有者允许用户访问STL容器本身（可能通过访问者保护）。这需要库编程人员的最少编码，但对用户来说不太方便。组合的最大卖点之一是可以减少代码中的耦合，但是该解决方案将STL容器与所有者容器完全耦合（因为所有者返回了真正的STL容器）。
• 编译时多态性：写操作可能有点棘手，需要一些代码体操，并且不适合所有情况。

作为一个方面的问题：是否有与非虚析构函数（我们假设我不希望覆盖任何方法，只是我要添加新的）继承的标准安全方式？我的印象是，如果没有能力改变定义非虚拟类的代码，那么没有通用的和安全的方法来做到这一点。

编辑2：

作为@doc points out，C++ 11的发烧友using声明低的组合物的成本有所。

Answer 1

我想它遵循不支付你不使用的功能的C++哲学。根据平台的不同，如果您不关心虚拟析构函数，虚拟表的指针可能会带来巨大的代价。

Answer 2

虚拟析构函数仅用于继承场景。 STL容器不是为了继承而设计的（也不是支持的场景）。因此他们没有虚拟析构函数。

Answer 3

没有虚拟析构函数阻止该类正确地作为子类。

Answer 4

我认为斯特劳斯在他神奇的纸间接地回答了这个问题：Why C++ is not just an ObjectOriented Programming Language：

7闭幕词
高于 提出的各种 设施面向对象的或没有？哪个？ 使用什么定义 面向对象？在大多数情况下，我认为这些都是错误的问题。 重要的是什么想法，你可以 表达清楚，多么容易，你可以从 不同 源相结合，软件，以及如何高效， 维护所产生的程序 是。换句话说，你如何支持 好的编程技巧和好的 设计技术比 更重要的标签和热门词汇。根本的想法仅仅是通过抽象来改进设计和编程。你想要隐藏的细节，你想 利用系统中的任何共同点， ，你想让这个负担得起。 我想鼓励你不要让 使面向对象无意义的 术语。通过 具有良好的等同它，

- - 通过一个单一的语言等同 ，或

- 的'面向对象' 概念过于频繁地贬低

通过 接受一切， 面向对象。

我认为 有 - 并且必须是 - 有用的 技术超出了面向对象的 编程和设计。然而， 避免被误解完全，我 想强调的是，我 不会使用一种编程语言， 没有至少支持经典 概念对象编程的是严肃认真的项目 。 除了支持设施 对象编程，我想 - 和C++提供了 - 那去 超出他们的 的概念直接表达和 关系支持功能。

STL主要以三个概念工具为主。 泛型编程+功能风格+数据抽象== STL风格。 OOP不是代表数据结构&算法库的方式并不奇怪。尽管在标准库的其他部分使用了OOP，但STL的设计人员看到，上述三种技术的组合优于单独使用OOP 。简而言之，这个库并不是用OOP设计的，在C++中如果你不使用它，它不会与你的代码捆绑在一起。你不支付你不使用的东西。类std :: vector，std :: list，...是而不是 Java/C＃意义上的OOP概念。他们只是抽象数据类型在最好的解释。

Answer 5

正如已经指出的那样，STL容器并非设计为可继承的。没有虚拟方法，所有数据成员都是私有的，没有受保护的getters/setters/helpers ..并且正如你所发现的，没有虚拟析构函数..

我建议你真的应该通过合成来使用容器，而不是实现继承，采用“一种”方式而不是“一种”方式。

Answer 6

你不应该盲目地为每个类添加一个虚拟析构函数。如果是这样的话，这种语言不会让你有任何其他选择。将虚拟方法添加到没有任何其他虚拟方法的类中时，只需按指针大小（通常为4个字节）增加类实例的大小。这很贵，取决于你在做什么。尺寸增加是因为创建了一个v表来保存虚拟方法列表，并且每个实例都需要一个指向v表的指针。它通常位于实例的第一个单元格中。

Answer 7

为什么STL容器设计不允许继承？

在我的愚见中他们是。如果他们不这样做，他们已经取得最后的。当我看着stl_vector.h源我可以看到我的STL实现使用保护继承_Vector_base<_Tp, _Alloc>授予派生类的访问：

template<typename _Tp, typename _Alloc = allocator<_Tp> > 
class vector : protected _Vector_base<_Tp, _Alloc> 

那岂不是用私人继承，如果子类是不欢迎？

---

有非虚析构函数（我们假设我不希望覆盖任何方法，只是我要添加新的）继承的标准安全方式？

为什么不使用protected或private继承与using关键字暴露接口的所需部分？

class MyVector : private std::vector<int> 
{ 
    typedef std::vector<int> Parent; 

    public: 
     using Parent::size; 
     using Parent::push_back; 
     using Parent::clear; 
     //and so on + of course required ctors, dtors and operators. 
}; 

这种做法确保了类的用户不会垂头丧气实例std::vector<int>，他是安全的，因为与非虚析构函数的唯一问题是，它不会叫得出的一个，当对象被删除作为父类的一个实例。

...我也有一个松散的想法，即使你的类没有析构函数，你甚至可能会公开地继承它。异端？

Answer 8

另一种能够从STL容器中进行子类化的解决方案是由Bo Qian使用智能指针提供的。

Advanced C++: Virtual Destructor and Smart Destructor

class Dog { 
public: 
    ~Dog() {cout << "Dog is destroyed"; } 
}; 

class Yellowdog : public Dog { 
public: 
    ~Yellowdog() {cout << "Yellow dog destroyed." << endl; } 
}; 


class DogFactory { 
public: 
    static shared_ptr<Dog> createYellowDog() { 
     return shared_ptr<Yellowdog>(new Yellowdog()); 
    }  
}; 

int main() { 
    shared_ptr<Dog> pd = DogFactory::createYellowDog(); 

    return 0; 
} 

这避免了与完全虚拟的析构函数面临的困境。

Answer 9

如果你确实需要虚拟析构函数，你可以将它添加到从矢量<>派生的类中，然后在需要虚拟接口的任何地方使用这个类作为基类。通过这样做，编译器会从你的基类中调用虚拟析构函数，而后者将从矢量类中调用非虚拟析构函数。

例子：

#include <vector> 
#include <iostream> 

using namespace std; 

class Test 
{ 
    int val; 
public: 
    Test(int val) : val(val) 
    { 
     cout << "Creating Test " << val << endl; 
    } 
    Test(const Test& other) : val(other.val) 
    { 
     cout << "Creating copy of Test " << val << endl; 
    } 
    ~Test() 
    { 
     cout << "Destructing Test " << val << endl; 
    } 
}; 

class BaseVector : public vector<Test> 
{ 
public: 
    BaseVector() 
    { 
     cout << "Creating BaseVector" << endl; 
    } 
    virtual ~BaseVector() 
    { 
     cout << "Destructing BaseVector" << endl; 
    } 
}; 

class FooVector : public BaseVector 
{ 
public: 
    FooVector() 
    { 
     cout << "Creating FooVector" << endl; 
    } 
    virtual ~FooVector() 
    { 
     cout << "Destructing FooVector" << endl; 
    } 
}; 

int main() 
{ 
    BaseVector* ptr = new FooVector(); 
    ptr->push_back(Test(1)); 
    delete ptr; 

    return 0; 
} 

该代码给出了下面的输出：

Creating BaseVector 
Creating FooVector 
Creating Test 1 
Creating copy of Test 1 
Destructing Test 1 
Destructing FooVector 
Destructing BaseVector 
Destructing Test 1