如何 make_shared 计算次数，分配不同的区域而不重复循环？

Question

如何make_shared计算次数，分配不同的区域不重复循环？

我有以下代码：

for( unsigned int count = 0; count < demandedSize; ++count  )
{   
   m_connectionList.push_back( std::make_shared< Foo >( m_ip, m_port )); 
}

如何在没有循环的情况下缩短这个？

我知道 std::vector 接收第二个参数作为 const T&，但在那种情况下所有 shared_ptrs 指向相同的地址（值被复制）。

std::vector< std::shared_ptr<Foo> > vet( demandedSize, std::make_shared<Foo>( m_ip, m_port ) );

如何执行 make_shared count 次，并分配不同的区域作为结果而不返回循环

Answer 1

这应该可以解决问题：

std::generate_n( back_inserter( m_connectionList ), demandedSize, [this]{
    return std::make_shared< Foo >( m_ip, m_port ) );
});

Live Example on Coliru.

Answer 2

template<class X>
struct arrow_helper_t {
  X x;
  auto operator->()&& { return std::addressof(x); }
};
template<class X>
arrow_helper_t<X> arrow_helper(X&& x){ return {std::forward<X>(x)}; }

template<class F>
struct generator_iterator_t {
  std::size_t i = 0;
  F f;
  generator_iterator_t()=default;
  generator_iterator_t(generator_iterator_t const&)=default;
  generator_iterator_t(generator_iterator_t &&)=default;
  generator_iterator_t& operator=(generator_iterator_t const&)=default;
  generator_iterator_t& operator=(generator_iterator_t &&)=default;
  using iterator_category = std::input_iterator_tag;
  using reference=decltype(std::declval<F const&>()(std::declval<std::size_t const&>()));
  using value_type = std::decay_t<reference>;
  using pointer = arrow_helper_t<reference>;
  using difference_type = std::ptrdiff_t;
  using self_t = generator_iterator_t;
  friend bool operator!=(self_t const& lhs, self_t const& rhs) { return lhs.i != rhs.i; }
  friend bool operator==(self_t const& lhs, self_t const& rhs) { return lhs.i == rhs.i; }
  decltype(auto) operator*()const { return f(i); }
  auto operator->() const { return arrow_helper(**this); }
  self_t& operator++() { ++i; return *this; }
  self_t operator++(int) { auto r = *this; ++i; return r; }
};
template<class F>
generator_iterator_t<F>
generator_iterator( F f, std::size_t i ) {
  return {i, std::move(f)};
}
template<class F>
auto generator_range( F f, std::size_t i ) {
  return std::make_pair(
    generator_iterator(f, 0),
    generator_iterator(f, i)
  );
}

auto range = generator_range([&](auto){return std::make_shared< Foo >( m_ip, m_port );}, demandedSize);
m_connectionList.reserve( m_connectionList.size()+demandedSize );
m_connectionList.insert(m_connectionList.end(),
  range.first, range.second
);

之类的。 boost 可能做得更好。

live example.

如何 make_shared 计算次数，分配不同的区域而不重复循环？

How to make_shared count times, with different areas allocated without recur to a loop?

c++

smart-pointers

c++11