c++ - 使用工厂填充元组并避免复制

Question

我正在尝试编写一个 (C++98) 程序，其中出现以下模式:我有一个非常简单的通用元组类，我需要用使用工厂构造的值填充它。最小示例代码如下:

#include <iostream>

class diagnostics
{
private:
  int payload;
public:
  diagnostics(int a)
    : payload(a)
  {
    std::cout << "constructor\n";
  }

  diagnostics(const diagnostics& o)
    : payload(o.payload)
  {
    std::cout << "copy constructor\n";
  }

  ~diagnostics()
  {
    std::cout << "destructor [" << payload << "]\n";
  }
};

struct creator
{
  static diagnostics create()
  {
    static int i = 0;
    return diagnostics(++i);
  }
};

template<class Head, class Tail>
struct tuple
{
  Head head;
  Tail tail;
  typedef Head head_t;
  typedef Tail tail_t;

  tuple(const Head& h, const Tail& t)
    : head(h), tail(t)
  {
  }
};
struct empty_tuple { };

template<class Tuple, class Create>
struct create_helper
{
  static Tuple create()
  {
    return Tuple(Create::create(),
        create_helper<typename Tuple::tail_t, Create>::create());
  }
};
template<class Create>
struct create_helper<empty_tuple, Create>
{
  static empty_tuple create()
  {
    return empty_tuple();
  }
};
template<class Tuple, class Create>
Tuple create()
{
  //return Tuple(Create::create(), empty_tuple()); //(*)
  return create_helper<Tuple, Create>::create();
}

int main()
{
  typedef tuple<diagnostics, empty_tuple> tuple_t;
  tuple_t a = create<tuple_t, creator>();
}

输出是

constructor
copy constructor
destructor [1]
destructor [1]

我想去掉中间的两行。

为了简化讨论，我们可以在上面的代码中取消注释标记(*)的行；这会破坏通用性，但不会破坏程序。

现在回答我的主要问题:我该如何解决这种情况？标准中是否有阻止 RVO 的东西(大概 RVO 必须在这里递归完成)？如果不是，接受编译器不够好，有没有办法让我以明确的方式发生这种情况？我可以让 create() 的调用端复杂化，但我不想使元组中的对象复杂化(特别是，其中一些不能默认构造，我不想引入额外的“未初始化”对他们说)。放置新的可能有帮助吗？

以下问题似乎相关，但最终没有帮助:Why does not RVO happen here? )

Answer 1

我觉得在五分钟后回答我自己的问题有点愚蠢，但这似乎是获得以下信息的最合适方式:

这是一种解决方案。我们可以将创建代码转移到元组类本身:

struct FILLIT { };

template<class Head, class Tail>
struct tuple
{
  Head head;
  Tail tail;
  typedef Head head_t;
  typedef Tail tail_t;

  tuple(const Head& h, const Tail& t)
    : head(h), tail(t)
  {
  }

  tuple(const tuple& o)
    : head(o.head), tail(o.tail)
  {
    std::cout << "tuple copy\n";
  }

  template<class Create>
  tuple(FILLIT, Create c)
      : head(Create::create()), tail(FILLIT(), c)
  {
  }
};
struct empty_tuple
{
  empty_tuple() {};
  template<class C>
  empty_tuple(FILLIT, C) {};
};

创建的兼容实现是

template<class Tuple, class Create>
Tuple create()
{
  return Tuple(FILLIT(), Create());
}

我仍然对其他方法感兴趣。