vector of objects with inheritance in C++

Question

class IFeature
{
public:
  virtual std::string string() = 0;
};

class Feature2D
{
public:
  virtual std::string string() { .... }
};

class Feature3D
{
public:
  virtual std::string string() { .... }
};

void print(std::vector<IFeature*> & v)
{
  for (size_t i=0; i<v.size(); i++)
    std::cout << v[i]->string() << std::endl;
}

void main()
{
  std::vector<Feature2D*> v2d;
  // push...
  print(v2d); // compile error 

  std::vector<Feature3D*> v3d;
  // push...
  print(v3d); // compile error 
}

Any suggestions on how I can obtain this print function? (maybe using another data structure different by std::vector)

Thanks

You can (and should) pass your vectors to print by const reference. Also, the inheritance statement is missing on your FeatureXD class declarations. — Alexandre C.
– Alexandre C., Commented Feb 17, 2011 at 12:02
@Stefan - please don't suggest edits to the code posted in questions. It may well be that any errors are the cause of the problem the OP is seeing. — ChrisF
– ChrisF, Commented Feb 17, 2011 at 12:47

Erik · Accepted Answer · 2011-02-17 11:54:08Z

2

Use a template.

template<typename T> void print(std::vector<T *> const & v) {
  for (size_t i=0; i<v.size(); i++)
    std::cout << v[i]->string() << std::endl;
}

Or, use a virtual print member function:

class IFeature
{
public:
  virtual std::string string() = 0;
  virtual void print(std::ostream & Dest) const = 0;
};

void print(std::vector<IFeature *> const & v) {
  for (size_t i=0; i<v.size(); i++) {
    v[i]->print(cout);
    cout << endl;
  }
}

Optionally combine with an operator<<

inline std::ostream & operator<<(std::ostream & Dest, IFeature const & v) {
  v.print(Dest);
  return Dest;

void print(std::vector<IFeature *> const & v) {
  for (size_t i=0; i<v.size(); i++)
    std::cout << *(v[i]) << std::endl;
}

answered Feb 17, 2011 at 11:54

Erik

91.8k13 gold badges203 silver badges192 bronze badges

Sign up to request clarification or add additional context in comments.

2 Comments

yelo3 Over a year ago

Thank you very much! What that "const" is for?

Erik Over a year ago

It indicates that the print will not modify v.

Olli Etuaho · Accepted Answer · 2011-02-17 12:09:03Z

2

Just make the vectors IFeature* -vectors. You can store pointers for inherited classes in them just fine.

std::vector<IFeature*> v2d;
v2d.push_back(new Feature2D());
print(v2d);

No need to use templates. Pointers to the superclass are the way to go when you need to access common virtual functions. This way you can also mix different subclasses inside the same vector:

std::vector<IFeature*> vMixed;
vMixed.push_back(new Feature2D());
vMixed.push_back(new Feature3D());
print(vMixed);

Of course, if you also need pointers for the inherited classes, things get a bit more tricky. One option is to store them elsewhere separately. You can also downcast, but that is not usually recommendable.

edited Feb 17, 2011 at 12:09

answered Feb 17, 2011 at 11:56

Olli Etuaho

3034 silver badges9 bronze badges

1 Comment

Thomas Over a year ago

This won't work if you need to access the inherited class through the vector, though. (You'd need ugly downcasts.)

Stefan Dragnev · Accepted Answer · 2011-02-17 12:16:14Z

1

For the sake of completeness, I'll add that you can reinterpret_cast the vectors, since all vector share the same binary code.

print(reinterpret_cast<std::vector<IFeature*>&>(v2d));

C++ doesn't have covariance for template parameters, but you can simulate it partly if you know what it does under the hood. I found reinterpret_cast to be also useful to convert vector<T*>& to vector<const T*>& for contravariance.

Granted, this is very ugly.

edited Feb 17, 2011 at 12:16

answered Feb 17, 2011 at 12:05

Stefan Dragnev

14.5k6 gold badges51 silver badges56 bronze badges

Comments

Thomas · Accepted Answer · 2011-02-17 12:21:27Z

1

You can make print itself into a template:

template<typename T>
void print(T const &v)
{
  for (size_t i=0; i<v.size(); i++)
    std::cout << v[i]->string() << std::endl;
}

Better yet, use iterators, then it'll work on most other standard containers as well:

template<typename T>
void print(T const &v)
{
  for (T::const_iterator i = v.begin(); i != v.end(); ++i)
    std::cout << (*i)->string() << std::endl;
}

Even better (thanks Pedro), pass the iterators themselves:

template<typename Iter>
void print(Iter begin, Iter end) {
  for (Iter i = begin; i != end; ++i)
    std::cout << (*i)->string() << std::endl;
}

edited Feb 17, 2011 at 12:21

answered Feb 17, 2011 at 11:57

Thomas

183k57 gold badges383 silver badges510 bronze badges

1 Comment

Pedro d'Aquino Over a year ago

I'd go one step further and suggest you operate on iterators rather than on a const reference to T. So: template <typename InputIterator> void print(InputIterator begin, InputIterator end) { ... }

TDaver · Accepted Answer · 2011-02-17 11:57:21Z

0

What you are looking for here is interface covariance, which (as far as I know) is not possible on C++ classes. You need to make print also a Templated function (replace IFeature* with T*).

answered Feb 17, 2011 at 11:57

TDaver

7,2745 gold badges50 silver badges96 bronze badges

Collectives™ on Stack Overflow

vector of objects with inheritance in C++

5 Answers 5

2 Comments

1 Comment

Comments

1 Comment

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

5 Answers 5

2 Comments

1 Comment

Comments

1 Comment

Comments

Your Answer

Sign up or log in

Post as a guest

Related