How to hold pointers/refernces to an abstract class?

[Absurd]

Hi.
I need some advice regarding the following:
I have an abstract class named Terrain, and a class named RoadMap, which supposed to hold an N*N array of Terrains.
But I'm not sure what type should the RoadMap class hold:

#ifndef TERRAIN_H
#define TERRAIN_H


class Terrain {
public:
    virtual ~Terrain(){}
    virtual unsigned getCost()=0;
};


#endif /* TERRAIN_H */

and:

#ifndef ROADMAP_H
#define ROADMAP_H
#include"Terrain.h"

class RoadMap {
public:
    RoadMap(int size); // to be determined at runtime
    virtual ~RoadMap();
private:
    /* Two dimentional array of size*size Terrains */
    int terrain_size;
};



#endif /* ROADMAP_H */

I can't use an array of refernces here, so I tried this:

Terrain** terrain;

and then I thought this was the way to go:

Terrain (*terrain)[];

But now I'm not sure.

The N*N matrix size supposed to be determined according to a given input...
What type should I use there?

[grumpy]

There are a few options, all with different trade-offs.

"Terrain **terrain" requires you to manage all the memory allocations and deallocations explicitly. It would emulate a 1D array of pointers. A 2D array of pointers might be done using "Terrain ***terrain" - but bear in mind that a larger set of allocations and deallocations to be explicitly managed.

"std::vector<Terrain *>" will manage an array of pointers dynamically, but require you to explicitly manage the lifetimes of the objects the pointers point at. The vector would need to be sized to hold N*N elements. If you want to access particular terrain objects using two integers you will need to map those two integers into a single value (i.e. terrain[i][j]->getCost() won't work, but a mapping like terrain[i + N*j]->getCost() would).

"std::vector<std::vector<Terrain *> > will allow you to emulate a 2D array of pointers (vector of vectors of pointers). The difficulty is that you need to initialize lots of vectors (i.e. more code to construct your object, and more code if you ever need to resize) but the advantage is that you can treat it like a 2D array of pointers. (i.e. terrain[i][j]->getCost() will work if you have correctly set up all the vectors and contained pointers)

If you are using C++11 (i.e. a recent compiler/library) you will be able to use "std::vector<std::unique_pointer<Terrain> >" (for a 1D array) or "std::vector<std::vector<std::unique_pointer<Terra in> > >" (for a 2D array). The advantage of unique_pointer is that it manages lifetimes of the contained Terrain objects - assuming they are allocated dynamically (i.e. with operator new).


Where I've used "std::vector<>" above, any standard container will do (std::list, std::array, etc). The choice of container depends on what you're doing with the container, but vector is often a good default choice. All standard containers keep track of their own size, so you wouldn't necessarily need a separate variable to track the size.

[Absurd]

Great answer, thanks.