Question

我有一个非常简单的构造函数的类：

\1foo)

class mystream { public: mystream(size_t buffersize,size_t index) : buffersize(buffersize),index(index){} size_t buffersize; size_t index; };实例有一个唯一的id，与其在管理类的向量中的位置相对应：

mystream

如何构造向量并使用索引的升序值初始化其元素？

Answer 1

一种简洁，清晰且易于调试的方法是将向量的构造推迟到静态类函数：

class mystreammanager
{
public:
   mystreammanager() : streams{ generate_streams(1024, 8) }
   {
   }

private:
  static std::vector<mystream> generate_streams(size_t buffersize, size_t qty)
  {
    std::vector<mystream> result;
    result.reserve(qty);
    for(size_t i = 0 ; i < qty ; ++qty) {
      result.emplace_back(buffersize, i); 
    }
    return result;
  } 

  std::vector<mystream> streams;
};

这是最佳效率，因为：

RVO导致向量构建
避免列表初始化意味着没有冗余副本。

Answer 2

只需使用循环：

mystreammanager() {
    streams.reserve(8);
    for (int i = 0; i < 8; ++i) {
        streams.emplace_back(1024, i);
    }
}

Answer 3

编译时间版本：）

需要c++14，但肯定可以适应c++11

#include <cstddef>
#include <vector>
#include <utility>

class mystream
{
public:
  mystream(size_t buffersize,size_t index) : buffersize(buffersize),index(index){}

  size_t buffersize;
  size_t index;
};

template<size_t... Indexes>
std::initializer_list<mystream>    mystream_maker_impl(std::index_sequence<Indexes...>)
{
  return {{1024, Indexes}...};
}

template<size_t N>
std::initializer_list<mystream>    mystream_maker()
{
  return mystream_maker_impl(std::make_index_sequence<N>());
}

class mystreammanager
{
public:
  mystreammanager() : streams(mystream_maker<8>())
  {
  }

  std::vector<mystream> streams;
};

Answer 4

你可以这样做：

class mystreammanager
{
public:
   mystreammanager() : streams{{1024, 0}, {1024, 1}, {1024, 2}, {1024, 3},
                               {1024, 4}, {1024, 5}, {1024, 6}, {1024, 7}}
   {
   }

  std::vector<mystream> streams;
};

但是做一个循环似乎更安全/更简单。

Answer 5

我使用了@RichardHodges的答案，因为我对我的第一选择不满意。我想出了这个模板：

\\.

它可以帮助我避免冗余。从理论上来看，我最喜欢@Drax解决方案，因为它在编译期间做了大部分工作。

在类构造函数中设置std :: vector，使用元素构造函数的不同值

5 个答案: