C++: Multidimensional Array of different types - c++

Question

I am just starting to practice some C++ and a cool project i picked up (maybe too ambitious) is to build a Ecosystem Simulator. Basically i want to have a world of Plants, Rabbits and Foxes. Rabbits eat plants and Foxes eat Rabbits. I was thinking of having different classes just like this:
struct pos{
int x;
int y;
};
class Plant{
pos posit;
int growrate;
bool alive;
};
class Rabbit {
pos posit;
int age;
int speed;
int viewradius;
//other stuff
public:
Rabbit(pos,int,int);
void move();
void eat(Plant);
void die();
Rabbit mate(Rabbit);
};
class Fox{
//other stuff here
};
I want to have a 2D Array in which every element can be a Fox, a Rabbit, a Plant or a Plant with a Rabbit on. How can i do that? Is there an easy way?

Answer 1

As a first order approximation, you could define a structure with three optionals.
struct Square {
std::optional<Plant> plant;
std::optional<Rabbit> rabbit;
std::optional<Fox> fox;
};
This structure now can hold one of the three or both a plant and rabbit. It also allows for invalid combinations, but this is the simplest representation of what you asked.
For the 2-dimensional array, you could use a sparse representation using nested maps, if an actual array is not required.
typedef std::map<int, std::map<int, Square>> Grid;
Alternatively, you could map a pos directly to a Square.

Answer 2

Many possible/valid ways to design this. I'd do something like this:
struct Rabbit {};
struct Fox {};
struct Plant {};
struct Cell {
std::shared_ptr<Rabbit> rabbit;
std::shared_ptr<Fox> fox;
std::shared_ptr<Plant> plant;
bool hasRabbit() const { return !!rabbit; }
bool hasFox() const { return !!fox; }
bool hasPlant() const { return !!plant; }
};
using Grid = std::array<std::array<Cell, 100>, 100>;
int main()
{
Grid grid;
grid[2][3].rabbit = std::make_shared<Rabbit>();
grid[2][3].plant = std::make_shared<Plant>();
Cell& cell2_3 = grid[2][3];
if (cell2_3.hasRabbit() && cell2_3.hasPlant()) {
// Eat plant
cell2_3.rabbit->eat(cell2_3.plant);
cell2_3.plant.reset();
}
}

Answer 3

I would strongly prefer the combination of std::variant & std::visit. Since your classes are concrete types and exposes non polymorphic behavior, I suggest not using a polymorphic class hierarchy: you could hardly bubble up all classes member functions into pure virtual functions in an abstract base class (let's say Animal). For example, there would be no sensible overriding implementation for void eat(Plant) in the class Plant. Also if you choose not to pull member functions as pure virtual functions into an abstract base class (Animal), then any useful operation on the base class would require overusing of dynamic downcast, which is against good programming practices; see ES.48: Avoid casts from the cppcoreguidelines.
std::variant is implemented as a tagged union, so it makes it possible to initialize and assign it from an object of different alternative types at runtime. For example, you could define using Animal = std::variant<Plant, Rabbit, Fox>;. Now, when you use a variant object, you normally want to execute different operations depending of the type of the object contained in the variant. The canonical way to do this is by using std::visit which takes as first parameter a visitor (a function object with with overloaded operators() for each types of the variant), and the second parameter is the variant. Also, as an advice, pass your parameters by reference. Otherwise calling Rabbit::eat(plant) will make the rabbit eat a copy of the plant and not the plant itself. Try the following minimal working example (I used gcc10.2 with cpp17 flag), I chose to define an EatingVisitor but you can define as many visitors as you want:
#include <iostream>
#include <variant>
struct pos{
int x;
int y;
};
class Plant{
pos posit;
int growrate;
bool alive;
};
class Rabbit {
pos posit;
int age;
int speed;
int viewradius;
//other stuff
public:
Rabbit() = default;
Rabbit(pos,int,int);
void move();
void eat(Plant&) { std::cout << "rabbit eat plant\n"; }
void die();
Rabbit mate(Rabbit&);
};
class Fox{
public:
void eat(Rabbit&) { std::cout << "fox eat rabbit\n"; }//other stuff here
};
using Animal = std::variant<Plant, Fox, Rabbit>;
struct EatingVisitor
{
Animal& animal;
void operator()(Rabbit& rab) const {
if (auto pplant = std::get_if<Plant>(&animal))
rab.eat(*pplant);
}
void operator()(Plant& rab) const {
// noop
}
void operator()(Fox& fox) const {
if (auto prab = std::get_if<Rabbit>(&animal))
fox.eat(*prab);
}
};
int main()
{
// The animal that is going to be eaten
Animal plan = Plant{};
// The eating animal
Animal rab = Rabbit{};
// The eating function object
EatingVisitor vis{plan};
// rab eats the animal referred to by vis
std::visit(vis, rab);
}
Also, a Plant with a Rabbit on it should be a relation between a Plant and a Rabbit, not a type by itself. There are different ways to express this but a possible implementation could be:
class Rabbit
{
void hop_on(Plant& plant) {
this->move(plant.position());
plant.host(this)
}
};
class Plant
{
void host(Rabbit* rab) {
this->host_rabbit = rab;
}
};