Issue with pointer array not grabbing data from pointer function

Question

I'm coding a game for my class, and I'm having a segmentation fault when my map array tries to access the symbol of a piece of land to display on a map. I can't figure out how to word this, because I can't figure out where to start when fixing this issue. Any help is appreciated.

Map.h

    public:
        Map(Player &player) {
            ...
            //Create Map Array Using Size Parameters
            Land *map[map_X][map_Y];
            this->map = **↦

            //Generate Lands on Map
            BuildMap(player);
        }
    ...
    private:
        Land **map;
        ...
    }
};

Map.cpp

void Map::BuildMap(Player &player) {
    ...
    for(size_t i = 0; i < map_Y; i++) {
        for(size_t k = 0; k < map_X; k++) {
        
            //!TEST iteration; REMOVE
            std::cout << "BuildMap [" << k << "][" << i << "]" << std::endl;

            map[k][i] = *GetRandomLand();
        
            //!TEST land; REMOVE
            std::cout << "Symbol: \'" << map[k][i].GetSymbol() << "\'" << std::endl
                      << std::endl;

            //!TEST failsafe; REMOVE
            if(k > 100) {
                break;
            }
        }
    }
}

Land.cpp

Land* GetRandomLand() {
    srand(time(NULL));
    LandTypes selection = (LandTypes)(rand() % MAX_LAND_TYPES);

    switch(selection) {
        case LAKE:
            return new Lake;
            break;
        case FOREST:
            return new Forest;
            break;
        case DESERT:
            return new Desert;
            break;
        default;
            return new Forest;
            break;
    }
}

Edit: I forgot to show it here, but map is a Land pointer. Specifically, Land **map.

Answer 1

I tried to made two examples. One with size known at compile time (constant), and when dynamic. This following code is using C++ best practice of using RAII to avoid memory leakage.

class Map
{
    public:
    
        // Ctor for constant map.
        Map(Player& player);
        
        // Ctor for dynamic map.
        Map(Player& player, const std::size_t x, const std::size_t y);
    
    private:
    
        // Member private function to build the map with proper Land.
        // This will fill the 'constant' map.
        const std::size_t map_X = 10;
        const std::size_t map_Y = 10;    
        BuildMapConst(Player& player);
        
        
        // Member private function to build the map with proper Land.
        // This will fill the 'dynamic' map, which has been allocated in ctor.
        BuildMapDyn(Player& player);
    
        // If size is known at compile time, 2-dimension std::array should be the best.
        std::array<std::array<std::unique_ptr<Land>, map_Y>, map_X> m_const_map;
        
        // If size is unknown at compile time, 2-dimension dynamic container such as vector
        // is the way to go, since it will handle proper the deletion of the unique_ptrs.
        std::vector<std::vector<std::unique_ptr<Land>>> m_dyn_map;
    }
};


std::unique_ptr<Land> GetRandomLand() {
    srand(time(NULL));
    LandTypes selection = (LandTypes)(rand() % MAX_LAND_TYPES);

    switch(selection) {
        case LAKE:
            return std::make_unique<Lake>(); // note break are useless since you return.
        case FOREST:
            return std::make_unique<Forest>();
        case DESERT:
            return std::make_unique<Desert>();
        default;
            return std::make_unique<Forest>();
    }
}


Map::Map(Player &player) 
{
    // Constant map is allocated at compile time with fix size.
    BuildMapConst(player);      
}


void Map::BuildMapConst(Player& player) 
{        
    for(size_t i = 0; i < map_X; i++) {
        auto& map_ref = m_const_map[i];
        
        for(size_t k = 0; k < map_Y; k++) {                  
        
            //!TEST iteration; REMOVE
            std::cout << "BuildMap [" << i << "][" << k << "]" << std::endl;

            map_ref[k] = std::move(GetRandomLand());
        
            //!TEST land; REMOVE
            std::cout << "Symbol: \'" << map[k].GetSymbol() << "\'" << std::endl
                      << std::endl;

            //!TEST failsafe; REMOVE
            if(k > 100) {
                break;
            }
        }
    }
}


Map::Map(Player &player, const std::size_t x, const std::size_t y) 
{
    // Allocate properly the map.
    m_dyn_map.resize(x);
    for(std::size_t r = 0; r < x; ++r)
        m_dyn_map[r].resize(y);
    
    // Fill the dynamic map.
    BuildMapDyn(player);      
}

void Map::BuildMapDyn(Player& player) {
    
    const std::size_t rows = m_dyn_map.size();
    const std::size_t cols = m_dyn_map[0].size();
    
    for(size_t i = 0; i < rows; i++) {
        auto& map_ref = m_dyn_map[i];
        
        for(size_t k = 0; k < cols; k++) {      
            
        
            //!TEST iteration; REMOVE
            std::cout << "BuildMap [" << i << "][" << k << "]" << std::endl;

            map_ref[k] = std::move(GetRandomLand());
        
            //!TEST land; REMOVE
            std::cout << "Symbol: \'" << map[k].GetSymbol() << "\'" << std::endl
                      << std::endl;

            //!TEST failsafe; REMOVE
            if(k > 100) {
                break;
            }
        }
    }
}

EDIT

Here some reference for your question in the comments.

std::unique_ptr is holding the ownership of your base class Land.

std::unique_ptrdoesn't have copy-ctor, or assignment-copy ctor, it must be moved

RAII is used in order to allocate variable on stack and ensure deletion when out-of-scope.

Container element can be accessed via operator[] (same for std::array), a reference to the object element is provided. Which in our case is an std::vectorstd::unique_ptr>, for second dimension of the map.

Answer 2

The issue likely lies here

          map[k][i] = *GetRandomLand();

Since we are dereferencing the Land* returned by GetRandomLand, you are falling subject to the object slicing problem. See What is object slicing?

I assume we are doing that because map is not defined as a 2D array of pointers, but rather as a 2D array of objects.

To ensure you have an array of pointers instead of an array of objects you could use the following syntax. If you are passing the map, it could be Land* map[][] or Land***

Land map[10][10];
// vs
Land* map[10][10];

As others have noted in the comments, polymorphism only works when you have a pointer or a reference to the object. If you dereference the object to the base class, then it is likely that your base class implementation of GetSymbol is causing the crash.