STL 容器与 std：：unique_ptr vs boost：:p tr_container

我决定编写一个简短的程序，将一些多态对象放入一个容器中（通过指向堆的指针），然后将该容器与std:：算法一起使用。我选择std::remove_if作为一个例子。

以下是我如何使用vector<unique_ptr<T>>:

#include <vector>
#include <memory>
#include <iostream>
class Animal
{
public:
    Animal() = default;
    Animal(const Animal&) = delete;
    Animal& operator=(const Animal&) = delete;
    virtual ~Animal() = default;
    virtual void speak() const = 0;
};
class Cat
    : public Animal
{
public:
    virtual void speak() const {std::cout << "Meown";}
    virtual ~Cat() {std::cout << "destruct Catn";}
};
class Dog
    : public Animal
{
public:
    virtual void speak() const {std::cout << "Barkn";}
    virtual ~Dog() {std::cout << "destruct Dogn";}
};
class Sheep
    : public Animal
{
public:
    virtual void speak() const {std::cout << "Baan";}
    virtual ~Sheep() {std::cout << "destruct Sheepn";}
};
int main()
{
    typedef std::unique_ptr<Animal> Ptr;
    std::vector<Ptr> v;
    v.push_back(Ptr(new Cat));
    v.push_back(Ptr(new Sheep));
    v.push_back(Ptr(new Dog));
    v.push_back(Ptr(new Sheep));
    v.push_back(Ptr(new Cat));
    v.push_back(Ptr(new Dog));
    for (auto const& p : v)
        p->speak();
    std::cout << "Remove all sheepn";
    v.erase(
        std::remove_if(v.begin(), v.end(),
                       [](Ptr& p)
                           {return dynamic_cast<Sheep*>(p.get());}),
        v.end());
    for (auto const& p : v)
        p->speak();
}

该输出：

Meow
Baa
Bark
Baa
Meow
Bark
Remove all sheep
destruct Sheep
destruct Sheep
Meow
Bark
Meow
Bark
destruct Dog
destruct Cat
destruct Dog
destruct Cat

这对我来说很好。然而，我发现将其翻译成ptr_vector有问题：

boost::ptr_vector<Animal> v;
v.push_back(new Cat);
v.push_back(new Sheep);
v.push_back(new Dog);
v.push_back(new Sheep);
v.push_back(new Cat);
v.push_back(new Dog);
for (auto const& p : v)
    p.speak();
std::cout << "Remove all sheepn";
v.erase(
    std::remove_if(v.begin(), v.end(),
                   [](Animal& p)
                       {return dynamic_cast<Sheep*>(&p);}),
    v.end());
for (auto const& p : v)
    p.speak();
algorithm:1897:26: error: overload resolution selected deleted operator '='
                *__first = _VSTD::move(*__i);
                ~~~~~~~~ ^ ~~~~~~~~~~~~~~~~~
test.cpp:75:9: note: in instantiation of function template specialization 'std::__1::remove_if<boost::void_ptr_iterator<std::__1::__wrap_iter<void
      **>, Animal>, Sheep *(^)(Animal &)>' requested here
        std::remove_if(v.begin(), v.end(),
        ^
test.cpp:12:13: note: candidate function has been explicitly deleted
    Animal& operator=(const Animal&) = delete;
            ^
1 error generated.

问题是boost::ptr_vector的一个特性：迭代器不返回内部存储的指针。它们返回被取消引用的指针。因此，当容器与std::algorithms一起使用时，算法试图复制存储的对象，而不是存储的指向对象的指针。

如果不小心忘记了使多态对象不可复制，那么会自动提供复制语义，从而导致运行时错误而不是编译时错误：

class Animal
{
public:
    Animal() = default;
    virtual ~Animal() = default;
    virtual void speak() const = 0;
};

这导致了错误的输出：

Meow
Baa
Bark
Baa
Meow
Bark
Remove all sheep
destruct Cat
destruct Dog
Meow
Baa
Bark
Baa
destruct Cat
destruct Sheep
destruct Dog
destruct Sheep

使用vector<unique_ptr>时不会发生此运行时错误。

存储指针容器但呈现引用容器的阻抗不匹配似乎与使用通用算法安全使用容器不一致。事实上，这就是ptr_container带有许多算法的自定义版本的原因。使用ptr_containers完成此项工作的正确方法是仅使用那些成员算法：

v.erase_if([](Animal& p)
                 {return dynamic_cast<Sheep*>(&p);});

如果您需要一个不是作为ptr_containers成员提供的变异序列算法，请不要尝试使用<algorithm>中的算法，或其他第三方提供的通用算法。

总之，当唯一的其他实用选项是std::vector<boost::shared_ptr<T>>时，boost:：ptr_containers满足了真正的需求。然而，现在有了std::vector<std::unique_ptr<T>>，开销参数就消失了。C++11解决方案似乎具有安全性和灵活性两方面的优势。如果您需要"克隆语义"，我会认真考虑编写自己的clone_ptr<T>，并将其用于std容器和算法。

重用std:：lib将使容器的选项比boost lib更开放（例如，unordered_set/map、forward_list），并使std:：算法的选项尽可能广泛地开放。

也就是说，如果您已经使用boost:：ptr_containers对代码进行了工作和调试，那么就没有迫切需要更改它