处理 stl 容器中的智能指针

Question

我有一个 Foo 类，它有一个指向 Shape 派生类的智能指针向量。 我正在尝试实现 at(index) 成员函数。以下是我直观地要做的事情：

Foo<float> myfoo;
std::unique_ptr<Shape<float>> shape_ptr = myfoo.at(i);
shape_ptr->doSomething(param1, param2, ...);

定义 at(index) 函数时，我收到编译器错误消息。请注意，移动构造函数已定义，并且 Shape 基类是抽象的。下面，我给出一些代码用于说明目的。

此外，我最近在网上发现了一个关于如何使用 std::move 重载赋值运算符的示例。我通常遵循复制交换习惯用法。重载上述运算符的两种方法中哪一种对我的情况有意义？下面，我还说明了该函数的定义。

template < typename T >
class Foo{

    public:

        Foo();
        Foo( Foo && );
        ~Foo();

        void swap(Foo<T> &);
        //Foo<T> & operator =( Foo<T> );
        Foo<T> & operator =( Foo<T> && );

        std::unique_ptr<Shape<T> > at ( int ) const; // error here!

        int size() const;

    private:

        std::vector< std::unique_ptr<Shape<T> > > m_Bank;
};

template < typename T >
Foo<T>::Foo( Foo && other)
    :m_Bank(std::move(other.m_Bank))
{

}

/*template < typename T >
void Filterbank<T>::swap(Filterbank<T> & refBank ){

    using std::swap;
    swap(m_Bank, refBank.m_Bank);
}

template < typename T >
Foo<T> & Filterbank<T>::operator =( Foo<T> bank ){

    bank.swap(*this);
    return (*this);
}*/

template < typename T >
Foo<T> & Foo<T>::operator =( Foo<T> && bank ){

    //bank.swap(*this);
    m_Bank = std::move(bank.m_Bank);
    return (*this);
}

template < typename T >
std::unique_ptr<Shape<T> > Foo<T>::at( int index ) const{
    return m_Bank[index]; // Error here! => error C2248: 'std::unique_ptr<_Ty>::unique_ptr' : cannot access private member declared in class 'std::unique_ptr<_Ty>'
}

Answer 1

使用 Boost 的指针容器而不是标准容器与 unique_ptr。它们是为这种用途而设计的。

Answer 2

问题 1：如何使用 Foo::at( int ) const 以便您可以：

myfoo.at(i)->doSomething(param1, param2, ...);

无需将所有权转移出 vector>> >。

A1: Foo::at( int ) const 应该返回一个 const std::unique_ptr; >&：

template < typename T >
const std::unique_ptr<Shape<T> >&
Foo<T>::at( int index ) const
{
    return m_Bank[index];
}

现在您可以取消引用 const unique_ptr 并调用它们想要的 Shape 的任何成员（const 或非 const）。如果他们不小心尝试复制unique_ptr（这会将所有权转移出Foo），他们将收到编译时错误。

此解决方案比返回对 unique_ptr 的非常量引用更好，因为它捕获了 Foo 中意外的所有权转移。但是，如果您希望允许通过 at 从 Foo 转移所有权，那么非常量引用会更合适。

Q2：此外，我最近在网上发现了一个关于如何使用 std::move 重载赋值运算符的示例。我通常遵循复制交换习惯用法。重载上述运算符的两种方法中哪一种对我的情况有意义？

A2：我不确定 ~Foo() 的作用。如果它没有做任何事情，您可以将其删除，然后（假设完全符合 C++11）您将自动获得正确且最佳的移动构造函数和移动赋值运算符（以及正确的删除复制语义）。

如果您无法删除 ~Foo() （因为它做了一些重要的事情），或者您的编译器尚未实现自动移动生成，您可以显式提供它们，就像您在问题中所做的那样。

您的移动构造函数是正确的：移动构造成员。

您的移动分配应该类似（如果 ~Foo() 是隐式的，则会自动生成）： 移动分配成员：

template < typename T >
Foo<T> & Foo<T>::operator =( Foo<T> && bank )
{
    m_Bank = std::move(bank.m_Bank);
    return (*this);
}

您的 Foo 设计适合于 < code>Swappable 也是如此，而且提供起来总是好的：

friend void swap(Foo& x, Foo& y) {x.m_Bank.swap(y.m_Bank);}

如果没有这个显式的 swap，您的 Foo 仍然是 Swappable 使用 < code>Foo 的移动构造函数和移动赋值。然而，这种显式交换的速度大约是隐式交换的两倍。

上述建议都是为了获得 Foo 的最高性能。如果需要，您可以在移动分配中使用复制交换习惯用法。它会是正确的并且稍微慢一些。不过，如果您确实小心的话，请不要通过 swap 调用移动赋值和移动赋值调用 swap 来获得无限递归！ :-) 事实上，这个陷阱只是干净（且最佳）分离交换和移动分配的另一个原因。

更新

假设Shape看起来像这个，这是一种方法为 Foo 编写移动构造函数、移动赋值、复制构造函数和复制赋值运算符，假设 Foo 有一个数据成员：

std::vector< std::unique_ptr< Shape > > m_Bank;

...

Foo::Foo(Foo&& other)
    : m_Bank(std::move(other.m_Bank))
{
}

Foo::Foo(const Foo& other)
{
    for (const auto& p: other.m_Bank)
        m_Bank.push_back(std::unique_ptr< Shape >(p ? p->clone() : nullptr));
}

Foo&
Foo::operator=(Foo&& other)
{
    m_Bank = std::move(other.m_Bank);
    return (*this);
}

Foo&
Foo::operator=(const Foo& other)
{
    if (this != &other)
    {
        m_Bank.clear();
        for (const auto& p: other.m_Bank)
            m_Bank.push_back(std::unique_ptr< Shape >(p ? p->clone() : nullptr));
    }
    return (*this);
}

如果您的编译器支持默认的移动成员 方式实现：

    Foo(Foo&&) = default;
    Foo& operator=(Foo&&) = default;

，同样的事情可以通过以下 移动构造函数和移动赋值运算符。

上述内容确保在任何时候每个 Shape 仅由一个智能指针/向量/Foo 拥有。如果您希望多个 Foo 共享 Shape 的所有权，那么您可以将其作为数据成员：

std::vector< std::shared_ptr< Shape > > m_Bank;

并且您可以默认所有移动构造函数、移动赋值、复制构造函数和复制赋值。

Answer 3

我认为你应该在这里使用 shared_ptr 。

只有一个 unique_ptr 可以拥有共享资源。如果您能够执行您想要的操作，即按值返回一个 unique_ptr，那么向量中的那个将被销毁，这可能是您不想要的。

Answer 4

看来你应该在这里返回一个引用：

Shape<T> & Foo<T>::at( int index ) const{
    return *m_Bank[index];
}