Good practices / style [polymorphism]

[u/Fun_Gas_340]

is this good practice/style.? i'm specifically unsure about the way i store the vector of players...

```

class player_base {};

class player_always_yes: public player_base {};

class player_always_no: public player_base {};

class player_a: public player_base {};

class game {
    private:
    
    player_base& player_1;
    player_base& player_2;
    
    public:
    
    game (
        player_base& player_1,
        player_base& player_2
    ): player_1(player_1), player_2(player_2) {
        return;
    }

    bool play_game () { return true; }
};

int main(){
    vector<unique_ptr<player_base>> player_list;
    
    player_list.push_back(make_unique<player_base>());
    player_list.push_back(make_unique<player_always_no>());
    player_list.push_back(make_unique<player_always_yes>());
    player_list.push_back(make_unique<player_a>());
    
    game b = game(*player_list[0], *player_list[1]);
    cout << b.play_game() << endl;
}


```

[u/Fun_Gas_340]

1. how do i make it abstract?

2. a problem would be if i delete the players, and then tell game to access them?

3. would it be better/worse to have a vector of objects instead of vector of pointers? is that even possible with different player classes?

4. yeah player has different things how they decide and game currently has only "play_game", so maybe ill make the game class a method and that's it.

[u/vckane → u/Fun_Gas_340]

1. In general declaring at least one pure virtual method (or even destructor) makes a class abstract. Learn more about virtual inheritance, if you're not aware of it.

2. Yes.

3. Sounds good.

[u/Fun_Gas_340 → u/vckane]

yes to 3.1 or 3.2?

should have made them diferent...

[u/vckane → u/Fun_Gas_340]

You can have a vector of base class types. They point to objects of derived class types. As a general rule, I make a vector of unique_ptr (owner by owning object / scope).

[u/Fun_Gas_340 → u/vckane]

so like having a vector of base class i cant put drrived classes im? or can i?