关于C ++中的多态

Question

I'm learning about polymorphism and this is a small game. I have a representative class Character here, I want to program so that from a Character people can choose Warrior or Archer to continue the game.

#pragma once
#include <iostream>
using namespace std;
#include <string>

class Warrior;
class Archer;

class Character {
   public:
   Character(void);
   ~Character(void);

Character* creatCharacter(int choice, string CharacterName) {

    if (choice == 1)
        return (Character*)new Warrior(CharacterName);

    if (choice == 2)
        return (Character*)new Archer(CharacterName);

      return NULL;
   }

   virtual void Skill_Cast() {};
};

class Warrior :public Character {
private:
   string name;
public:
   Warrior(void);
   ~Warrior(void);

   Warrior(string CharacterName) {
      name = CharacterName;
   }


  void Skill_Cast() {
      cout << "Punch!" << endl;
  }

 };

class Archer : public Character
{ 
private:
    string name;
public:
Archer(void);
~Archer(void);

Archer(string CharacterName) {
    name = CharacterName;
}

   void Skill_Cast() {
    cout << "Shoot!" << endl;
   }

};

In the main function:

int main() {
   cout <<"Enter character's name: ";
   string name;
   getline(cin, name, '\n');
   cout <<"Enter your character class by number (1),(2),(3): ";
   int choice;
   cin >> choice;

   Character* YourChar;



  YourChar = YourChar->creatCharacter(choice, name);

  YourChar->Skill_Cast();
}

And this is ERRORS:

 Error  1   error C2512: 'Warrior' : class has no constructors  
 Error  2   error C2514: 'Archer' : class has no constructors   

Can you explain me the errors and help me fix that, by the way, Is this a kind of "Abstract Factory Design Pattern" ? Thanks so much. (sorry for my bad English)

Answer 1

Rearrange your files into header/source files. It will make your code much cleaner and easier to read and it will also solve your problem.

// Archer.h
#pragma once 

#include "Character.h"

class Archer : public Character
{ 
public:
    Archer(void);
    Archer(std::string CharacterName);
    ~Archer(void);

    void Skill_Cast();

private:
    std::string name;
};

// Character.h
#pragma once

#include <string>

class Character 
{
public:
    Character(void);
    ~Character(void);

   Character* creatCharacter(int choice, std::string CharacterName);

   virtual void Skill_Cast() {};
};

// Character.cpp
#include "Warrior.h"
#include "Archer.h"

Character* Character::creatCharacter(int choice, std::string CharacterName)
{
    if (choice == 1)
        return (Character*)new Warrior(CharacterName);

    if (choice == 2)
        return (Character*)new Archer(CharacterName);

    return NULL;
}

I haven't done all the work for you but this should point you in the right direction.

Answer 2

If you are set on using Abstract Factory (which is rarely useful), do it right. You should not have your createChracater (defined within Character class - base class should not know anything about it's descendants). Instead, you should have a separate file, with separate function, like following:

CharacterFactory.h

#include <character.h>
#include <memory>
std::unique_ptr<Character> make_character(int type, std::string name);

CharacterFactory.cpp

#include <warrior.h>
#include <archer.h>
#include <stdexcept>

std::unique_ptr<Character> make_character(int type, std::string name) {
    if (type == 1)
        return std::unique_ptr<Character>(new Archer(name));
    if (type == 2)
        return std::unique_ptr<Character>(new Warrior(name));
    throw std::runtime_error("Unknown character type requested!");
}

Answer 3

In this snippet ... you need not (and should not) cast the derived instance back to the base class:

Character* creatCharacter(int choice, string CharacterName) 
{
    if (choice == 1)
        return (Character*)new Warrior(CharacterName);

    if (choice == 2)
        return (Character*)new Archer(CharacterName);
   return NULL;
}

For polymorphism to work, your derived classes must inherit from the base. It looks like your base class is "Character", so this code should be more like the following. The idea is that Warrior is-a Character (as Archer is-a Character), so you need not (shall not) cast.

Character* creatCharacter(int choice, string CharacterName) 
{
    if (choice == 1)
        return (new Warrior(CharacterName));

    if (choice == 2)
        return (new Archer(CharacterName));

   return NULL;
}

When used, simply invoke the Character action you wish.

For example, assume Character has the method

virtual void Character::action1(){ ... do stuff };  // body in .cc file

Then, with a warrior instance, you can invoke action1() as in:

Warrior warrior;
warrior.action1();   // because warrior "is-a" 'Character'.

Or, more typically, from a pointer in an array of Character.

std::vector<Character*>  actionFigures;

for ( << maybe all figures in vector >> )
   actionFigures[i]->action1();  

The above invokes Character::action1() only if the derived instance does not replace the method.

If Warrior re-defines action1(), then its version of the action1() method will be invoked.

---

There is also another somewhat bigger (though very common) mistake you have started down: the point of polymorphism is that the base class does NOT (shall NOT, CAN NOT) know what might be derived from it. Derived classes might be added many code versions later, with possibly NO changes to the base class. (ie code re-use)

This function is 'broken' in the sense that for every new derived Character you will have to modify this function, re-test everything, etc. (not code re-use)

---

This is just additional guidance, not trying to write the code for you.

---

Good luck.