Question

我的代码使用了一些肮脏的技巧，使其显示为我认为一个不错的界面。最重要的类Worker旨在使调用者使用临时数构建它;然后构造函数将接受它们。我认为代码是不言自明的：

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

using namespace std;

struct Base
{
    virtual void
        print
        ( void )
        {
            cout << "Base" << endl;
        };
};

struct Derived1 : public Base
{
    virtual void
        print
        ( void )
        {
            cout << "Derived1" << endl;
        };
};

struct Derived2 : public Base
{
    virtual void
        print
        ( void )
        {
            cout << "Derived2" << endl;
        };
};

class Worker
{
    private:
        /* Arrays can't hold references, and
         * vectors are homogenous, so the
         * only option is to use (smart) pointers. */
        vector< unique_ptr<Base> >
            V
            ;

        /* The dirty trick I spoke about. */
        template<typename T> void
            init
            ( T && t )
            {
                V.emplace_back( new T( forward<T>(t) ) );
                return;
            };
        template<typename T , typename ... U> void
            init
            ( T && t , U && ... u )
            {
                V.emplace_back( new T( forward<T>(t) ) );
                    /* The usage of std::move() is explained below. */
                init(move(u)...);
                return;
            };

    public:
        template<typename ... T>
            Worker
            ( T && ... t )
            {
                    /* Use std::move() because, inside the body
                     * of the function, the arguments are lvalues.
                     * If I hadn't put std::move(), the compiler
                     * would complain about an attempt of using
                     * _new_ with a reference type (above). */
                init(move(t)...);
                return;
            };

        void
            work
            ( void )
            {
                for ( const auto & x : V )
                    x->print();
                return;
            };
};

int
main
    ( void )
{
    /* The goal: be able to create an instance of Worker
     * passing temporaries to the constructor. No initializer_list
     * is involved, no copies are made; clean, fast moves. */
    Worker worker{ Derived1() , Base() , Derived2() };
    /* This should print "Derived1\nBase\nDerived2\n". */
    worker.work();

    return 0;
}

即使它编译得很好（g ++ 4.8.1）并开箱即用，我觉得这不是实现目标的最佳方式，我想摆脱那种烦人的感觉。有没有人为此找到另一种解决方法？有没有更好的方法，我的设计有任何缺点？

提前致谢。代码应该编译得很好，并展示我如何设计我的界面以及为什么我已经使用了那些＆＃34;技巧＆＃34;。最好的祝福， Kalrish

Answer 1

虽然我仍然认为这个问题更适合Code Review，但这里是你的“肮脏伎俩”的替代版本

    template < typename T >
    int emplace_back(T&& t)
    {
        V.emplace_back( std::forward<T>(t) );
        return 0;
    }

    template<typename ... T>
        Worker
        ( T && ... t )
        {
            auto i = {emplace_back(new T{forward<T>(t)})...};
        };

或者，如果你想摆脱那个成员函数：

public:
    template<typename ... T>
        Worker
        ( T && ... t )
        {
            using up = std::unique_ptr<Base>;
            auto f = [&](up&& p)
                { V.emplace_back(std::move(p)); return 0; };

            auto i = {f( up{new T{forward<T>(t)}} )...};
        };

您可能会收到警告，因为i未使用。此变量仅用于构建初始化列表，其中允许包扩展。

通常情况下，我建议使用初始化列表而不是可变参数模板ctor（这就是它们的用途），但它们不支持移出元素，因为它们不拥有存储空间。 / p>

如果要在ctor的mem-initializer-list中初始化vector，则会出现同样的问题（通过上面的备选方案中的包扩展）。

同源容器，派生类，初始化列表和移动语义

1 个答案: