Question

我有一个关于多态性和可能其他技术的问题。请考虑以下方案：

#include <vector>
#include <memory>

using namespace std;

struct Base
{ };

struct Derived : Base
{ };

class group
{
    private:
        vector< unique_ptr<Base> > V;
    public:
        group( /* what to put here? */ )
        : V( /* again: how to construct V? */ )
        { }
}

这里，我有三个类：一个名为Base的基类;派生类，称为Derived;以及最后一个类group，它将作为保存Base指针的包装器。但我想实现以下目标：

使用移动语义。不应该涉及副本。调用者应该能够为构造函数提供几个 temporaries ，因为构造函数会窃取它们：
```
group my_wonderful_group( Base( /* parameters */ ) , Derived ( /* ... */ ) , Derived ( /* ... */ ) );
```
在初始化列表中初始化V 。这样，V可以 const - 限定（尽管在初始化列表中初始化成员对象具有所有其他好处）。

我尝试了几件事，但它们要么不合适，要么在概念上远离我的目标：

initializer_list s'元素不可移动; unique_ptr是仅限于移动。
可变参数模板似乎无法满足制作V const 的目标。由于initializer_list s不能保存不同类型的对象（就像vector s），我首先考虑过它们，但是，如何？在阅读了很多例子后，我仍然无法弄清楚如何制作可变参数模板构造函数，或者即使没有解决方法也可以这样做（即：创建一些 init（）< / em>使用Base，Derived，...并使用它的功能。）

创建一个返回unique_ptr<Base>的函数，并将其参数转发给Derived的构造函数，从而充当group类的用户友好包装器。然而，这确实没有意义，正如我用下面的代码说明的那样。

这就是我所拥有的：

#include <string> #include <vector> #include <memory> #include <initializer_list> #include <iostream> using namespace std; struct Base { string s; Base(Base && b) : s(move(b.s)) { } Base(const string & S) : s( S ) { } }; struct Derived : Base { Derived(const string & S) : Base( S ) { } }; unique_ptr<Base> BASE ( const string & S ) { return unique_ptr<Base>( new Base(S) ); } unique_ptr<Base> DERIVED ( const string & S ) { return unique_ptr<Base>( new Derived(S) ); } class C { private: vector< unique_ptr<Base> > V; public: template<typename ... T> C ( T ... t ) : V({ t... }) { } void print ( void ) { for ( const auto & x : this->V ) cout << x->s << endl; } ; }; int main(void) { C c( BASE("hola") , DERIVED("der1") , DERIVED("bor3") ); c.print(); return 0; }

然而，当unique_ptr的构造函数中的参数包被扩展并以逗号分隔放入{时，它抱怨使用被调用的group的[已删除]复制构造函数{1}} 将用于初始化initializer_list。

我想我的问题归结为V，事实上，可以应用于vector。我认为这之前必须已经解决，因为多态性是基本的C ++，而派生类的持有对象似乎是它的一种非常常见的用法。请注意，我使用vector<unique_ptr<Base>>( /* initialize with derived classes */ )。

提前致谢。最好的祝福， Kalrish

P.S。：我刚读过this question，这似乎部分地解决了我的问题。

Answer 1

以下内容应解决您的所有问题：

#include <iostream>
#include <memory>
#include <string>
#include <vector>

using namespace std;

struct Base
{
    string s;
    Base(const Base& b) = delete;
    Base(Base && b) : s(move(b.s)) { }
    Base(const string & S) : s( S ) { }
};

struct Derived : Base
{
    Derived(const string & S) : Base( S ) { }
};

#if 1 // not in C++11
template <typename T, typename ... Ts>
std::unique_ptr<T> make_unique(Ts&&...args)
{
    return std::unique_ptr<T>(new T{std::forward<Ts>(args)...});
}
#endif

// vector<move_only> cannot be construct from initializer list :-/
// Use this work around
template <typename Base, typename ... Ts>
std::vector<std::unique_ptr<Base>> make_vector_of_unique(Ts&&... ts)
{
    std::unique_ptr<Base> init[] = {make_unique<Ts>(std::forward<Ts>(ts))...};
    return std::vector<std::unique_ptr<Base>> {
        std::make_move_iterator(std::begin(init)),
        std::make_move_iterator(std::end(init))};
}

class C
{
private:
    const std::vector< std::unique_ptr<Base> > V;
public:
    template<typename ... Ts>
    C(Ts&& ... t) : V(make_vector_of_unique<Base>(std::forward<Ts>(t)...))
    {}

    void print()
    {
        for (const auto & x : this->V)
            std::cout << x->s << std::endl;
    }
};

int main() {
    C c( Base("hola") , Derived("der1") , Derived("bor3") );
    c.print();
    return 0;
}

C ++ - 多态：使用派生类初始化容器类

1 个答案: