问如何在分配不同区域而不重复循环的情况下，make_shared计数时间？

EN

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
);

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