Heap memory allocation for pointers to object/objects in C++

Question

I read a book about programming patterns in games, and decided I would give writing a small engine for fun/practice while I'm not taking classes, which makes a lot of use of object pointers.

I've created a Tile class to represent an area of the map (situated on a standard 2D coordinate plain, which is a 2D array of pointers to Tile objects) which has other types of objects (infamous tile traps, a character, and a ground type) as shown below, which holds pointers to the data the tile object will hold.

class Tile
{
public:
    enum TileType{
        WATER_DEEP,
        WATER_SHALLOW,
        GRASS,
        MUD
    };

    Trap* getTileTrap();
    GameObject* getTileObject();
    TileType* getTileType();

    Trap *tileTrap;
    GameObject *tileObject;
    TileType *tileType;

    Tile();
    virtual ~Tile();

protected:
private:
};

What I'm curious about is whether it is more efficient, memory/performance wise, to keep it how it is written, having this tile object (which is allocated on the heap) contain pointers to other objects, or should I scrap the pointers and simply return the objects?

If I keep it how it is written, are the objects the pointers point to created somewhere else on the heap? Will they be allocated somewhere random, or will they be allocated along with the space allotted to the Tile object when it is created?

This is less of an efficiency consideration and more of a design question. Do your objects have identity and mutable state? In that case, you can't simple "return the objects", since the copies that would result would be different objects. — Sebastian Redl
– Sebastian Redl, Commented Jul 3, 2017 at 8:31

Vittorio Romeo · Accepted Answer · 2017-07-03 08:33:22Z

it is more efficient, memory/performance wise, to keep it how it is written, having this tile object (which is allocated on the heap) contain pointers to other objects, or should I scrap the pointers and simply return the objects?

It's almost never more efficient to use indirection and dynamic allocation. It is only more efficient when the object you're storing are expensive to copy (e.g. copy-on-write strings). It's also "required" when you want to refer to the same object without copying it.

tl;dr:

Prefer values unless you have a good reason to introduce indirection.
Prefer references to pointers as they don't have a "null state".

Consider TileType: it's an enum whose size is very likely to be less or equal than sizeof(void*). You gain nothing and lose everything by storing it as a pointer and returning it by pointer.

If you store it via pointer, this means that you'll probably require dynamic allocation. Every time you access it you need to jump through a pointer.
Regarding Trap and GameObject: depending on their size and whether or not you want reference semantics you might want to use a std::unique_ptr or std::shared_ptr to store them, and return a Trap&/GameObject& to allow access.

If I keep it how it is written, are the objects the pointers point to created somewhere else on the heap? Will they be allocated somewhere random, or will they be allocated along with the space allotted to the Tile object when it is created?

It seems that you need to read a good C++ book and understand the basics of pointers and references. Unless you initialize your pointers, they will have garbage values.

You shouldn't use raw pointers for ownership. You should use smart pointers.
You shouldn't use dynamic allocation unless you have a good reason to do that.

riodoro1 · Accepted Answer · 2017-07-03 08:36:05Z

The pointer is useful when You want storage that does not expire with a function that creates it or can be "shared". You can think of them as sort of a global variable, it's accessible as long as You haven't forgotten the pointer or haven't freed the memory. You can for example have one Tile object create the GameObject and another object of Tile type share the pointer to the same GameObject. But a pointer is NOT an object, that means that in case of your Tile class you need to allocate all the members on the heap and then release them manually when appropriate.

For example I think there is no point to do TileType* getTileType(); because in the constructor you would have to call new and then in the destructor delete for a member tileType that takes almost no space and is not required to be shared.

You should familiarise yourself with what a pointer is and what it's useful for, it has its uses but also its limitations. Once You realise the potential that holding a pointer instead of a variable has You will be able to quickly judge which to use including the potential performance gain/penalty.

Collectives™ on Stack Overflow

Heap memory allocation for pointers to object/objects in C++

2 Answers 2

Comments

Comments

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

Comments

Comments

Related