Создайте коллекцию абстрактного типа класса, абстрактный класс вектора shared_ptr - PullRequest
0 голосов
/ 16 апреля 2019

Error

е / с ++ / v1 / алгоритм: 642: /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/include/c++/v1/utility:321:9: ошибка:

тип поля 'Space' - абстрактный класс _T2 секунда; ^

/ Applications / Xcode.app / Содержание / Разработчик / Наборы инструментов / XcodeDefault.xctoolchain / usr / include / c ++ / v1 / map: 624: 16: примечание:

Вопрос

Как определить std::vector типа Space, который является абстрактным классом, а затем заполнить этот вектор экземплярами производных классов Empty, Snake, Ladder.

Контекст

Я знаю, что абстрактные классы в C ++ не могут быть созданы. Вместо этого я прочитал в нескольких постах на этом и других сайтах, что вы можете создать коллекцию абстрактного типа, если этот тип определен как указатель типа * или любой из типов данных <memory> управляемых указателей, таких как std::unqiue_ptr<T>. Я пытался использовать shared_ptr<Space> в моем случае, но все еще не смог правильно определить коллекцию. Я скомпилировал свой код, используя g++ -std=c++17 main.cpp && ./a.out.

Код

#include <cstdlib>
#include <cmath>
#include <iostream>
#include <map>
#include <memory>
#include <typeinfo>
#include <queue>
#include <string>
#include <vector>

class Player
{
    private:
        int m_current_space = 1;
    public:
        Player() {}
        void role_dice() {
            m_current_space += floor( (rand()%10 + 1) / 3 );
        }
        int const get_current_space() {
            return m_current_space;
        }
        void set_current_space(int current_space) {
            m_current_space = current_space;
        }
};

class Space
{
    protected:
        int m_id;
        std::vector<Space> m_paths;
    public:
        Space() {} // requied to use [] operator in map
        Space(int id) : m_id(id) {}
        void add_path(Space& s) {
            m_paths.push_back(s);
        }
        int get_id() {
            return m_id;
        }
        virtual std::string class_type() = 0;
};
class Empty : public Space
{
    public:
        Empty(int id) : Space(id) {}
        std::string class_type() {
            return "Empty";
        }
};
class Ladder : public Space
{
    public:
        Ladder(int id) : Space(id) {}
        virtual void event(Player& p) {
            p.set_current_space(1);
        }
        std::string class_type() {
            return "Ladder";
        }
};
class Snake : public Space
{
    public:
        Snake(int id) : Space(id) {}
        virtual void event(Player& p) {
            p.set_current_space(4);
        }
        std::string class_type() {
            return "Snake";
        }
};

class Board
{
    private:
        std::map<int, Space> m_board;
    public:
        void add_space(Space& s) {
            m_board[s.get_id()] = s;
        }
        void draw_board() {
            int i = 1;
            for(auto const& [space_key, space] : m_board) {
                if(i%3 == 0) {
                    std::cout << "○\n";
                }
                else if(typeid(space) == typeid(Snake)) {
                    std::cout << "○-";
                }
                else {
                    std::cout << "○ ";
                }
                ++i;
            }
        }
        void update_player_on_board(int position) {
            int i = 1;
            for(auto const& [space_key, space] : m_board) {
                if(i%3 == 0) {
                    if (space_key == position) {
                        std::cout << "●\n";
                    }
                    else {
                        std::cout << "○\n";
                    }
                }
                else if(typeid(space) == typeid(Snake)) {
                    std::cout << "○-";
                }
                else {
                    if (space_key == position) {
                        std::cout << "● ";
                    }
                    else {
                        std::cout << "○ ";
                    }
                }
                ++i;
            }
        }
        const std::map<int, Space> get_board() {
            return m_board;
        }
        friend std::ostream &operator<<(std::ostream& os, const Board& b) {
            return os;
        }
};

class GameStateManager
{
    private:
        std::string m_state = "game over";
        bool m_playing = false;
    public:
        std::string const get_state() {
            return m_state;
        }
        void set_state(std::string state) {
            m_state = state;
        }
};

int main()
{
    std::cout << "Welcome to Bowser's 9 board game\n";
    std::cout << "Start? y(yes) n(no)\n";

        GameStateManager game_manager;
        game_manager.set_state("playing");


        auto space1 = std::make_shared<Space>(1);
        auto space2 = std::make_shared<Space>(2);
        auto space3 = std::make_shared<Space>(3);
        auto space4 = std::make_shared<Space>(4);
        auto space5 = std::make_shared<Space>(5);
        auto space6 = std::make_shared<Space>(6);
        auto space7 = std::make_shared<Space>(7);
        auto space8 = std::make_shared<Space>(8);
        auto space9 = std::make_shared<Space>(9);

        std::vector<std::shared_ptr<Space>> v {
            space1, space2, space3,
            space4, space5, space6,
            space7, space8, space9
        };

        Board bowsers_bigbad_laddersnake;
        for(int i = 0; i < 10; ++i) {
            bowsers_bigbad_laddersnake.add_space(*(v[i]));
        }
        bowsers_bigbad_laddersnake.draw_board();

        Player mario;

        int turn = 0;
        while(game_manager.get_state() == "playing") {
            std::cin.get();
            std::cout << "-- Turn " << ++turn << " --" << '\n';
            mario.role_dice();
            bowsers_bigbad_laddersnake.update_player_on_board(mario.get_current_space());
            if (mario.get_current_space() >= 9) {
                game_manager.set_state("game over");
            }
        }

        std::cout << "Thanks a so much for to playing!\nPress any key to continue . . .\n";
        std::cin.get();



    return 0;
}

1 Ответ

1 голос
/ 16 апреля 2019

Вы, кажется, удалили много кода, чтобы войти в детали здесь. Имейте указатель Space (умный или сырой). Создайте конкретное пространство, которое вам нужно, укажите на него указателем типа Space. Пример std::shared_ptr<Space> pointerToSpace = std::make_shared<Snake> ("I'm a snake"); Теперь, без потери общности, вы можете распечатать содержимое (конкретного типа), просто указав на пробел pointerToSpace->class_type(). Да, вы можете иметь коллекцию shared_ptr s в контейнере.

...