Copy constructor between derived classes

Question

How do you copy a derived class to another?

I'm terminologically deficient, so I'll try to illustrate with an example.

We are playing a card game with a computer player and human player. Card and Command are other classes.

class Player
{
    Card *Hand[4];
    // etc...
};

class Human: public Player
{
    Command getCommand();
    void PlayCard(Card card);
    void quit();
    // etc...
};

class Computer: public Player
{
    Command ai();
    void PlayCard(Card card);
    // etc...
};

And somewhere in the main function we have ...

// ...
Human p1; // Assume initialized and usable.
if(p1.getCommand() == QUIT)
{
    cout << "PLAYER 1 RAGEQUITS WHAT A NOOB LOL << endl;
    cout << "A COMPUTER WILL NOW TAKE OVER." << endl;
    p1.quit()
    p1 = new Computer(); // THE IDEA BEING THAT WE WANT TO PRESERVE p1's MEMBERS.
}
// ...

What I am trying to do is converting p1 to a "Computer" while preserving the state of its members.

Do we use a copy constructor to do this? If not, what methods do you use?

EDIT: Is this the way to use the assignment operator?

Computer& Human::operator=(const Human &h) // Assignment operator
{
    Hand = h.Hand;
    member2 = h.member2;
    member3 = h.member3;
    ...

    return *this;
}

Do we need to delete/free anything in the main?

Good news: you spelled "terminologically" right :) – BoltClock Jul 21 '11 at 22:45 — BoltClock, Jul 21 '11 at 22:45
It's `class`, not `Class`; and `public`, not `Public` – Praetorian Jul 21 '11 at 22:45 — Praetorian, Jul 21 '11 at 22:45

Peter Alexander · Accepted Answer · 2011-07-21T23:00:33.877

5

You have a design problem here. If you want to switch a player from a Human to a Computer while maintaining the common member variables then you should structure your classes in that way.

class Player
{ 
public:
    friend class Human;    // These friends are necessary if the controllers
    friend class Computer; // need access to Player's private data.

    Card hand[4];
    Controller* controller;
};

class Controller
{
public:
    virtual Command getCommand(Player const&) = 0;
};

class Human : public Controller
{
public:
    Command getCommand(Player const&) { /* get command from user input */ }
};

class Computer : public Controller
{
public:
    Command getCommand(Player const&) { /* get command from AI */ }
};

Then, when you need to switch from Human to Computer, just change the controller.

p1->controller = new Computer();

This way, the cards will be maintained, only the control mechanism will be changed.

edited Jul 21 '11 at 23:00

answered Jul 21 '11 at 22:52

Peter Alexander

53,344
14
119
168

That's another reasonable approach, although the `Controller` probably needs read access to the `Player`'s private data somehow. – Ben Voigt Jul 21 '11 at 22:53
In that case, either the Player could expose that data, or you could make the Controller a friend of the Player. That's what friends are for :) – Peter Alexander Jul 21 '11 at 22:54
It's not just an issue of access specifier, a pointer to the instance is also needed. But this is easily solved also. – Ben Voigt Jul 21 '11 at 23:02
@Ben Voigt: Yep, just realised that was what you meant. I've added the Player ref to the getCommand call :-) – Peter Alexander Jul 21 '11 at 23:04
Just add a player context and pass the controller an immutable reference to it. – Captain Obvlious Jul 21 '11 at 23:09
Careful about leaking the old controller, of course. Using `scoped_ptr` would probably be good here. – Ben Voigt Jul 21 '11 at 23:16

score 2 · Answer 2 · edited Jul 21 '11 at 23:17

2

You could use a constructor. For this particular case I'd probably have a method called something like "CopyGameState".

edited Jul 21 '11 at 23:17

Peter Mortensen

30,738
21
105
131

answered Jul 21 '11 at 22:47

Keith Nicholas

43,549
15
93
156

score 2 · Answer 3 · answered Jul 21 '11 at 22:48

2

Copy constructor is used to copy an existing object a new instance of the same class.

What you need is an assignment operator (operator=), which allows assigning the value of a different type to your existing class object.

answered Jul 21 '11 at 22:48

littleadv

20,100
2
36
50

This is completely backwards, since it won't replace the vtable. – Ben Voigt Jul 21 '11 at 23:00
@Ben - you can't replace vtable of a constructed class. – littleadv Jul 21 '11 at 23:12
Not without creating a new object... which is why the assignment operator isn't a good solution here. He needs a new object, with a new vtable. – Ben Voigt Jul 21 '11 at 23:15
@Ben - he needs a redesign. I didn't clearly understand what the *real* problem is until after I read Peter's answer. – littleadv Jul 21 '11 at 23:17
He wants `p1->PlayCard()` to start using `Computer::PlayCard` instead of `Human::PlayCard`, while keeping the member data intact. Either @Peter's answer or mine will get him there. – Ben Voigt Jul 21 '11 at 23:18

score 2 · Answer 4 · edited May 23 '17 at 12:26

2

It wouldn't be a copy constructor, but a converting constructor. Something like:

Computer::Computer(const Player& had_to_go) : Player(had_to_go) {}

This will use Player's copy constructor to preserve the members in the common base class.

Of course, you'd better make Player::Player(const Player&) work right, following the "rule of three" and all.

In the end, you'd do something like:

p1.quit();
Computer* replacement = new Computer(p1);
delete p1;
p1 = replacement;

edited May 23 '17 at 12:26

Community

1
1

answered Jul 21 '11 at 22:51

Ben Voigt

277,958
43
419
720

Can you explain to me what the "rule of three" is :P, also, is Player::Player(const Player&) Player's copy constuctor? – cozos Jul 21 '11 at 23:07
@Ir Win: Yes, it's `Player`'s copy constructor, and the rule of three says that if you have a custom copy constructor, assignment operator, or destructor, you need all three. In this case, it's because of the `Card*` stored in `Player`. The compiler-provided copy will copy the pointer, which means you'll eventually delete it twice. Not good. There's a very good explanation in the C++-FAQ tag. I'll add a link to it from my answer. – Ben Voigt Jul 21 '11 at 23:14

Copy constructor between derived classes

4 Answers4