如何创建包含三种不同类型向量的向量

Question

I have three structs (Foo, Bar, Fruit) and I want a vector to hold each struct like vector<Foo> Foo_holder; vector<Bar> Bar_holder; vector<Fruit> Fruit holder; vector<Foo> Foo_holder; vector<Bar> Bar_holder; vector<Fruit> Fruit holder; and then I want to try and put all three of those vectors into one vector. So it should end up like this with Vector_holder being the top level vector that I wish to know how to create:

Vector_holder

--- Foo_Holder
------Instance of Foo

--- Bar_holder
------Instance of Bar

--- Fruit_holder
------Instance of Fruit

How do I go about doing this?

The possible duplicate question lists a problem that the vectors must be the same size or the code breaks, and the vectors in my question will be shifting size a whole lot. I also feel this would help beginner C++ learners more than the other question. The solution I found here works for me and is overall alot simpler than the nearly essay long answer. I'm more of a beginner in C++ and as such appreciate the easier to understand answer here.

Answer 1

Whenever such a grouping makes sense, I tend to put it into a struct and hence name it. In this case,

struct FooBarFruitHolder {
    std::vector<Foo> foos;
    std::vector<Bar> bars;
    std::vector<Fruit> fruits;
};

which you can then use as

std::vector<FooBarFruitHolder> vec;

vec.emplace_back();

and eg fill it with objects:

/* Add a Foo element to all FooBarFruitHolder instances. */
for (auto&& fooBarFruitHolder : vec)
    fooBarFruitHolder.foos.emplace_back(/* Arguments passed to Foo ctor */);

The naming is essential here, so choose what fits best in your application. Initialization might also be easier to read when you pass parts of this nested datastructure into functions which setup the member variables, eg

void initialize(std::vector<Foo>& foos)
{
    foos.emplace_back(/* Arguments for first Foo object */);
    foos.emplace_back(/* Arguments for second Foo object */);
}

initialize(vec.front().foos);

Answer 2

vector to hold each struct like vector Foo_holder; vector Bar_holder; vector Fruit holder; and then I want to try and put all three of those vectors into one vector.

One way to interpret your (somewhat ambiguous) statement is that you also want a single vector that holds all N element types in it. (But I suspect you will like lubgr's answer better.)

For this the third vector, I suggest you consider Polymorphism.

---

If you derive each of your structs from an interface class, perhaps

class FooBarFruit_t 
{
    //...
    virtual void whistle() = 0;
    virtual void bounce()  = 0;
    virtual void f1()      = 0;
    virtual void f2()      = 0;
    virtual void f3()      = 0;
    virtual void reflect();

    //...
}

then you can easily create a vector where any of the N types can be loaded

std::vector<FooBarFruit_t*> holder;  

The next challenge will be to create virtual methods that each derived class can support.

a) They may be abstract, f1(), f2() ...

b) They may be very specific, such as whistle(), which is something that only foo can do (and bars and fruit would take no action on being commanded to whistle()).

[I'm not sure what kind of behavior these typically in-animate instances might take, but software is where abstraction really helps.]

---

What this buys you is, at run time, you do not have to know what kind of FooBarFruit_t you are commanding to action.

By invoking f3(), each instance (foo or bar or fruit) will do what what you ask, and each f3() simply fulfills the expectation you have for that type.

If the instance does not reflect(), you can either implement a method that a) does nothing, or b) invokes FooBarFruit_t::reflect(). Or several other options.

Consider that you might want to display all objects:

 for (auto fbf : holder)  fbf->show();

 for (auto fbf : holder)  fbf->diagnostic();  // or diagnostic

 for (auto fbf : holder)  fbf->reset();       // or reset

Any reason these need to be considered different?

---

There should not be a place where you feel the need to do something specific based on type:

 void something() {
 for (auto fbf : holder) {

    switch(fbf.type())
    { // vvvvv - enumeration of types
       case   Foo: foosomething(); break;
       case Fruit: fruitsomething(); break;
       case   Bar: barsomething(); break;
       default : assert(0); break;
    }
 }
 }

But no one will stop you from doing so you think you must.

Answer 3

You could use Boost's zip iterator to "zip together" the different vectors:

vector<Foo> Foo_holder; 
vector<Bar> Bar_holder; 
vector<Fruit> Fruit holder; 

/* ... insert elements etc. */

auto start = boost::make_zip_iterator(
    std::make_tuple(ia.begin(), d.begin(), ib.begin())
    );
auto end = boost::make_zip_iterator(
    std::make_tuple(ia.end(), d.end(), ib.end())
    );

Now, this doesn't result in a vector, just a pair of iterators. But now you can use them with STL algoritms. For example:

std::for_each(start, end, [](auto a_foo, auto a_bar, auto a_fruit) {
    std::cout << "The Foo   element is " << foo << "\n";
    std::cout << "The Bar   element is " << bar << "\n";
    std::cout << "The Fruit element is " << fruit << "\n";
}

and you can also use these iterators to create a single range object. This is described, for example, in this answer by @leemes to a related question of mine.