用于将shared_ptr的向量填充到Base和Derived对象的函数模板

Question

Consider the following:

#include <memory>
#include <utility>
#include <vector>

class Base
{
public:
    Base()
        : x(0)
    {}
    int x;
    virtual ~Base() = default;
};

class Derived : public Base
{
public:
    Derived(double z0)
        : Base{}
        , z{ z0 }
    {}
    double z;
};

template<class T> // T might be either a Base or a Derived class.
std::vector<std::shared_ptr<Base>> MakeVector(std::size_t numElements)
{
    std::vector<std::shared_ptr<Base>> vec;
    for(auto &i : numElements) {     // Compiler error occurs here.
        vec.push_back(std::make_shared<T>());
    }
    return vec;
}

class Foo
{
public:
    Foo(std::size_t num_elements,
        std::vector<std::shared_ptr<Base>> bars = {})
    : m_bars{bars.empty() ? MakeVector<Base>(num_elements) : std::move(bars)}
    {}

    std::vector<std::shared_ptr<Base>> m_bars;
};

int main()
{
    const std::size_t foo1Size = 4;
    const std::size_t foo2Size = 5;

    // Create a vector of shared_ptr to 4 Base objects:
    Foo foo1 {foo1Size};

    // Create a vector of shared_ptr to 5 Derived objects:
    Foo foo2 {foo2Size, MakeVector<Derived>(foo2Size)};
}

The objective here is to create a requested number of Base or Derived objects, and populate a std::vector with shared_ptr s to those objects.

I am getting a compiler error on the for statement:

error: there are no arguments to 'begin' that depend on a template parameter, so a declaration of 'begin' must be available [-fpermissive]

If I use a std::iterator with begin and end , unfortunately the iterator becomes invalid with each push_back . And I need to iterate a specific number of times, anyway, to populate the vector.

Is there an obvious solution to this problem?

Answer 1

1. You can't use range-based for loop on an std::size_t . You could change

    for(auto &i : numElements) { 

   to

    for (std::size_t i = 0; i < numElements; i++) { 

2. Derived doesn't have default constructor; you need to pass the argument to it for constructing, otherwise std::make_shared<T>() would fail. You can change MakeVector to the following with parameter pack :

    template<class T, class... Types> // T might be either a Base or a Derived class. std::vector<std::shared_ptr<Base>> MakeVector(std::size_t numElements, Types... args) { std::vector<std::shared_ptr<Base>> vec; for (std::size_t i = 0; i < numElements; i++) { vec.push_back(std::make_shared<T>(args...)); } return vec; } 

   then use it like

    // Create a vector of shared_ptr to 5 Derived objects: Foo foo2 {foo2Size, MakeVector<Derived>(foo2Size, 42)}; 

Answer 2

The numElements is a std::size_t type which has no begin and end iterator defined (which is defined for standard containers and user-defined types, not for primitive types), which are required for a range-based for loop . Therefore you need either a classical for loop

for(std::size_t index{ 0 }; index  < numElements; index ++) 
{ 
    vec.push_back(std::make_shared<T>());
}

or simply a while loop:

while(numElements--)
{
    vec.push_back(std::make_shared<T>());
}

---

Secondly, as @songyuanyao pointed out, Derived class must have a default constructor for the MakeVector to work. You can default one like:

Derived() = default;
// or
// Derived(double z0 = 0.0): Base{}, z{ z0 } {}

or the best like in @songyuanyao 's answer , provide an extra varidic-template-args for the constructor parameters.

Answer 3

for(auto &i : numElements) {     // Compiler error occurs here.
        vec.push_back(std::make_shared<T>());
    }

The for range is for container. Here numElements is a number, use a classical for loop.

for(std::size_t i = 0; i < numElements; i++) { 
        vec.push_back(std::make_shared<T>());
    }

Answer 4

You can't use a range-based for loop on arbitrary type. The type should work with definition from standard,

// for ( range_declaration : range_expression ) loop_statement

{
  auto && __range = range_expression ; 
  for (auto __begin = begin_expr, __end = end_expr; __begin != __end; ++__begin) 
  { 
    range_declaration = *__begin; 
    loop_statement 
  } 
}

ie it should have defined begin , end , as well as increment, dereference and comparison operators, which isn't a case for trivial integral types. In your case usual for is required, unless you want to define a type that describes range.

for (auto i = 0; i < numElements; ++i)

Ofc, one may be creative and use range for with just about any type. Something like this (this is no way a recommendation, just an example):

#include <utility> 
#include <iostream>

// Those should be in same namespace
template<class T, template<typename,T,T> class iT, T _b, T _e>
iT<T,_b,_e> begin(iT<T,_b,_e> v)
{
    return iT<T,_b,_e> {_b};
}

template<class T, template<typename,T,T> class iT, T _b, T _e>
iT<T,_b,_e> end(iT<T,_b,_e> v)
{
    return iT<T,_b,_e> {_e};
}

template<class T, T begin, T end> 
struct range {
    static const T _begin = T{begin};
    static const T _end = T{end};

    T value;

    range& operator++() { //prefix
        ++value;
        return *this;
    }

    T operator+(T inc) {
        return range<T,begin,end>{value + inc};
    }

    T operator-(T inc) {
        return range<T,begin,end>{value - inc};
    }

    T operator*() {return value;}

    bool operator != (range arg) { return value != arg.value; }
};

template<class T, T _b, T _e>
range<T,_b,_e> operator++(range<T,_b,_e> &v, int) //postfix
{ 
        range<T,_b,_e> result {v};
        ++v;
        return result;
}

int main()
{
    typedef range<size_t, 3, 10> SomeRange;

    for(auto i : SomeRange())
    {
        std::cout << i << std::endl;
    }
}

Derived class needs at least a default constructor, or your populating method MakeVector should be changed to emplace proper values