尝试将用户定义的Vector类型插入用户定义的Vectors中

Question

I'm trying to make a vector of vectors in a spell system for a small RPG battle simulation. The main goal I'm trying to accomplish is have a vector of Spells that the player can access and select what type of Spells they want to cast: Fire, Ice, etc. and then choose the name of the spell: burn, frost, etc.

The code below is what I've declared Spell and FireSpell as. I'm trying to insert a vector of FireSpells into a vector of type vector spells, however, it does not insert. Is there a way to make it insert?

I've tried the push_back on a FireSpell into a vector of Spells and it works fine, however, it always returns an error when I push_back a FireSpell vector into a vector of type vector Spell.

Magic.h

struct Fire
{
    int damage;
    int dps;
}; 

struct Spell
{
    int cost;
    string name;
};

struct FireSpell : Spell, Fire
{

};

Magic.cpp

#include <iostream>
#include "MagicSys.h"
#include <vector>
#include <string>
#include "Magic.h"

using std::cout;
using std::vector;

FireSpell burn;
FireSpell inferno;
FireSpell volcano;


int mainfunc()
{
    vector<vector<Spell>> PlayerSpells;
    vector<FireSpell> PlayerFSpells;
    PlayerFSpells.push_back(burn);
    PlayerFSpells.push_back(inferno);
    PlayerFSpells.push_back(volcano);

 /*Trying to insert FireSpell Vector into the end of the vector of Spell vectors*/

    PlayerSpells.push_back(PlayerFSpells);

    vector<vector<Spell>>::iterator it;
    for (it = PlayerSpells.begin(); it!=PlayerSpells.end(); ++it)
        cout << &it << " ";

    return 0;
}

I expected the inner FireSpell vector to insert into the outer Spell vector on the line: PlayerSpells.push_back(PlayerFSpells); , however, it gives me the error message:

no instance of overloaded function "std::vector<_Ty, _Alloc>::push_back
[with _Ty=std::vector<Spell, std::allocator<Spell>>,
_Alloc=std::allocator<std::vector<Spell, std::allocator<Spell>>>]"
matches the argument list

Answer 1

If you come from some other languages, you may be used to treat mutable values as implicit references. In those languages, you typically gain the ability to easily construct collections of different types, which may or may not share an interface, and you may or may not treat them polymorphically (late binding).

In C++, however, objects are not references: they are the actual objects in memory, which requires them to have a compile-time-known size. You can still rather easily create polymorphic collections through a pointer or a reference, though, or even have collections of objects without a common interface; but you have to be explicit about it -- and know the rules of the language to prevent gotchas like slicing (see What is object slicing? for instance).

Answer 2

Having

 vector<vector<Spell>> PlayerSpells; vector<FireSpell> PlayerFSpells; 

you cannot do

 PlayerSpells.push_back(PlayerFSpells); 

because a vector<FireSpell> is not a vector<Spell>