实验五 模板类与多态

Person.hpp

#ifndef PERSON_HPP
#define PERSON_HPP

#include<string>
#include<iostream>

using namespace std;

class Person
{
    public:
        Person(string n="ole olsen",string t="13352196559",string e="none"):name{n},telephone{t},email{e} {}
        void change_phone(string t){telephone = t;}
        void change_email(string e){email = e;}
        friend ostream& operator<<(ostream &out,Person &p);
        friend istream& operator>>(istream &in,Person &p);
        friend bool operator==(Person &p1,Person &p2);
    private:
        string name,telephone,email;
};

ostream &operator<<(ostream &out,Person &p)
{
    out << p.name << "    " << p.telephone << "    " << p.email;
    return out;
}

istream &operator>>(istream &in,Person &p)
{
    getline(in,p.name);
    getline(in,p.telephone);
    getline(in,p.email);
    return in;
}

bool operator==(Person &p1,Person &p2)
{
    if(p1.name==p2.name&&p1.telephone==p2.telephone&&p1.email==p2.email)
    return true;
    else
    return false;
}

#endif

task2.cpp

#include<iostream>
#include<fstream>
#include<vector>
#include"Person.hpp"

int main()
{
    using namespace std;
    
    vector<Person>phone_book;
    
    Person p;
    
    while(cin>>p)
        phone_book.push_back(p);
        
    for(auto &i:phone_book)
        cout << i << endl;
        
    cout << boolalpha << (phone_book.at(0)==phone_book.at(1));
    
    ofstream fout;
    
    fout.open("phone_book.txt");
    
    if(!fout.is_open())
    {
        cerr << "fail to open file phone_book.txt\n";
        return 1; 
    }
    
    for(auto &i:phone_book)
        fout << i << endl;
        
    fout.close();
}

运行截图：

 

 

 

 

 

问题一回答：ostream &operator<<(ostream &out,Person &p)

{

out << p.name << "" << p.telephone << "" << p.email;

return out;

}

问题二回答：ofstream流的读写操作。

//=======================
//        swordsman.h
//=======================

// Derived from base class player
// For the job Swordsman

#include ";player.h";
class swordsman : public player/Ǜ_?????????        // subclass swordsman publicly inherited from base player
{
public:
    swordsman(int lv_in=1, string name_in=";Not Given";);    
        // constructor with default level of 1 and name of ";Not given";
    void isLevelUp();
    bool attack (player &p);
    bool specialatt(player &p);
        /* These three are derived from the pure virtual functions of base class
           The definition of them will be given in this subclass. */
    void AI(player &p);                // Computer opponent
};
 

//=======================
//        swordsman.cpp
//=======================

// constructor. default values don';t need to be repeated here

#include ";swordsman.h";
#include <iostream>

using namespace std;

swordsman::swordsman(int lv_in, string name_in)
{
    role=sw;    // enumerate type of job
    LV=lv_in;
    name=name_in;
    
    // Initialising the character';s properties, based on his level
    HPmax=150+8*(LV-1);        // HP increases 8 point2 per level
    HP=HPmax;
    MPmax=75+2*(LV-1);        // MP increases 2 points per level
    MP=MPmax;
    AP=25+4*(LV-1);            // AP increases 4 points per level
    DP=25+4*(LV-1);            // DP increases 4 points per level
    speed=25+2*(LV-1);        // speed increases 2 points per level
    
    playerdeath=0;
    EXP=LV*LV*75;
    bag.set(lv_in, lv_in);
}

void swordsman::isLevelUp()
{
    if(EXP>=LV*LV*75)
    {
        LV++;
        AP+=4;
        DP+=4;
        HPmax+=8;
        MPmax+=2;
        speed+=2;
        cout<<name<<"; Level UP!";<<endl;
        cout<<";HP improved 8 points to ";<<HPmax<<endl;
        cout<<";MP improved 2 points to ";<<MPmax<<endl;
        cout<<";Speed improved 2 points to ";<<speed<<endl;
        cout<<";AP improved 4 points to ";<<AP<<endl;
        cout<<";DP improved 5 points to ";<<DP<<endl;
        system(";pause";);
        isLevelUp();    // recursively call this function, so the character can level up multiple times if got enough exp
    }
}

bool swordsman::attack(player &p)
{
    double HPtemp=0;        // opponent';s HP decrement
    double EXPtemp=0;        // player obtained exp
    double hit=1;            // attach factor, probably give critical attack
    srand((unsigned)time(NULL));        // generating random seed based on system time

    // If speed greater than opponent, you have some possibility to do double attack
    if ((speed>p.speed) && (rand()%100<(speed-p.speed)))        // rand()%100 means generates a number no greater than 100
    {
        HPtemp=(int)(Ƒ.0*AP/p.DP)*AP*5/(rand()%4+10));        // opponent';s HP decrement calculated based their AP/DP, and uncertain chance
        cout<<name<<";';s quick strike hit ";<<p.name<<";, ";<<p.name<<";';s HP decreased ";<<HPtemp<<endl;
        p.HP=int(p.HP-HPtemp);
        EXPtemp=(int)(HPtemp*1.2);
    }

    // If speed smaller than opponent, the opponent has possibility to evade
    if ((speed<p.speed) && (rand()%50<1))
    {
        cout<<name<<";';s attack has been evaded by ";<<p.name<<endl;
        system(";pause";);
        return 1;
    }

    // 10% chance give critical attack
    if (rand()%100<=10)
    {
        hit=1.5;
        cout<<";Critical attack: ";;
    }

    // Normal attack
    HPtemp=(int)(Ƒ.0*AP/p.DP)*AP*5/(rand()%4+10));
    cout<<name<<"; uses bash, ";<<p.name<<";';s HP decreases ";<<HPtemp<<endl;
    EXPtemp=(int)(EXPtemp+HPtemp*1.2);
    p.HP=(int)(p.HP-HPtemp);
    cout<<name<<"; obtained ";<<EXPtemp<<"; experience.";<<endl;
    EXP=(int)(EXP+EXPtemp);
    system(";pause";);
    return 1;        // Attack success
}

bool swordsman::specialatt(player &p)
{
    if(MP<40)
    {
        cout<<";You don';t have enough magic points!";<<endl;
        system(";pause";);
        return 0;        // Attack failed
 

//=======================
//        container.h
//=======================

// The so-called inventory of a player in RPG games
// contains two items, heal and magic water

#ifndef CONTAINER_H        // Conditional compilation
#define CONTAINER_H

class container        // Inventory
{
protected:
    int numOfHeal;            // number of heal
    int numOfMW;            // number of magic water
public:
    container();            // constuctor
    void set(int heal_n, int mw_n);    // set the items numbers
    int nOfHeal();            // get the number of heal
    int nOfMW();            // get the number of magic water
    void display();            // display the items;
    bool useHeal();            // use heal
    bool useMW();            // use magic water
};

#endif
 

//=======================
//        container.cpp
//=======================

// default constructor initialise the inventory as empty

#include";container.h";
#include<iostream>

using namespace std;

container::container()
{
    setƐ,0);
}

// set the item numbers
void container::set(int heal_n, int mw_n)
{
    numOfHeal=heal_n;
    numOfMW=mw_n;
}

// get the number of heal
int container::nOfHeal()
{
    return numOfHeal;
}

// get the number of magic water
int container::nOfMW()
{
    return numOfMW;
}

// display the items;
void container::display()
{
    cout<<";Your bag contains: ";<<endl;
    cout<<";Heal(HP+100): ";<<numOfHeal<<endl;
    cout<<";Magic Water (MP+80): ";<<numOfMW<<endl;
}

//use heal
bool container::useHeal()
{
    /ǘ_????????
    numOfHeal--;
    return 1;        // use heal successfully
}

//use magic water
bool container::useMW()
{
    numOfMW--;
    return 1;        // use magic water successfully
}
 

//=======================
//        player.h
//=======================

// The base class of player
// including the general properties and methods related to a character

#ifndef _PLAYER
#define _PLAYER

#include <iomanip>        // use for setting field width
#include <time.h>        // use for generating random factor
#include ";container.h";
#include <string>

using namespace std;

enum job {sw, ar, mg};    /* define 3 jobs by enumerate type
                               sword man, archer, mage */
class player
{
    friend void showinfo(player &p1, player &p2);
    friend class swordsman;

protected:
    int HP, HPmax, MP, MPmax, AP, DP, speed, EXP, LV;
    // General properties of all characters
    string name;    // character name
    job role;        /* character';s job, one of swordman, archer and mage,
                       as defined by the enumerate type */
    container bag;    // character';s inventory

public:
    virtual bool attack(player &p)=0;    // normal attack
    virtual bool specialatt(player &p)=0;    //special attack
    virtual void isLevelUp()=0;            // level up judgement
    /* Attention!
    These three methods are called ";Pure virtual functions";.
    They have only declaration, but no definition.
    The class with pure virtual functions are called ";Abstract class";, which can only be used to inherited, but not to constructor objects. 
    The detailed definition of these pure virtual functions will be given in subclasses. */

    void reFill();        // character';s HP and MP resume
    bool death();        // report whether character is dead
    void isDead();        // check whether character is dead
    bool useHeal();        // consume heal, irrelevant to job
    bool useMW();        // consume magic water, irrelevant to job
    void transfer(player &p);    // possess opponent';s items after victory
    void showRole();    // display character';s job
    
private:
    bool playerdeath;            // whether character is dead, doesn';t need to be accessed or inherited
};

#endif
 

//=======================
//        player.cpp
//=======================


// character';s HP and MP resume

#include";player.h";
#include <iostream>

using namespace std;

void player::reFill()
{
    HP=HPmax;        // HP and MP fully recovered
    MP=MPmax;
}

// report whether character is dead
bool player::death()
{
    return playerdeath;
}

// check whether character is dead
void player::isDead()
{
    if(HP<=0)        // HP less than 0, character is dead
    {
        cout<<name<<"; is Dead."; <<endl;
        system(";pause";);
        playerdeath=1;    // give the label of death value 1
    }
}

// consume heal, irrelevant to job
bool player::useHeal()
{
    if(bag.nOfHeal()>0)
    {
        HP=HP+100;
        if(HP>HPmax)        // HP cannot be larger than maximum value
            HP=HPmax;        // so assign it to HPmax, if necessary
        cout<<name<<"; used Heal, HP increased by 100.";<<endl;
        bag.useHeal();        // use heal
        system(";pause";);
        return 1;    // usage of heal succeed
    }
    else                // If no more heal in bag, cannot use
    {
        cout<<";Sorry, you don';t have heal to use.";<<endl;
        system(";pause";);
        return 0;    // usage of heal failed
    }
}

// consume magic water, irrelevant to job
bool player::useMW()
{
    if(bag.nOfMW()>0)
    {
        MP=MP+100;
        if(MP>MPmax)
            MP=MPmax;
        cout<<name<<"; used Magic Water, MP increased by 100.";<<endl;
        bag.useMW();
        system(";pause";);
        return 1;    // usage of magic water succeed
    }
    else
    {
        cout<<";Sorry, you don';t have magic water to use.";<<endl;
        system(";pause";);
        return 0;    // usage of magic water failed
    }
}

// possess opponent';s items after victory
void player::transfer(player &p)
{
    cout<<name<<"; got";<<p.bag.nOfHeal()<<"; Heal, and ";<<p.bag.nOfMW()<<"; Magic Water.";<<endl;
    system(";pause";);
    /Ǚ_???????????
     bag.set(bag.nOfHeal() + p.bag.nOfHeal(), bag.nOfMW() + p.bag.nOfMW());
    // set the character';s bag, get opponent';s items
}

// display character';s job
void player::showRole()
{
    switch(role)
    {
    case sw:
        cout<<";Swordsman";;
        break;
    case ar:
        cout<<";Archer";;
        break;
    case mg:
        cout<<";Mage";;
        break;
 

//=======================
//        main.cpp
//=======================

// main function for the RPG style game

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

#include ";swordsman.h";


int main()
{
    string tempName;
    bool success=0;        //flag for storing whether operation is successful
    cout <<";Please input player';s name: ";;
    cin >>tempName;        // get player';s name from keyboard input
    player *human;        // use pointer of base class, convenience for polymorphism
    int tempJob;        // temp choice for job selection
    do
    {
        cout <<";Please choose a job: 1 Swordsman, 2 Archer, 3 Mage";<<endl;
        cin>>tempJob;
        system(";cls";);        // clear the screen
        switch(tempJob)
        {
        case 1:
            human=new swordsmanƑ,tempName);    // create the character with user inputted name and job
            success=1;        // operation succeed
            break;
        default:
            break;                // In this case, success=0, character creation failed
        }
    }while(success!=1);        // so the loop will ask user to re-create a character

    int tempCom;            // temp command inputted by user
    int nOpp=0;                // the Nth opponent
    for(int i=1;nOpp<5;i+=2)    // i is opponent';s level
    {
        nOpp++;
        system(";cls";);
        cout<<";STAGE"; <<nOpp<<endl;
        cout<<";Your opponent, a Level ";<<i<<"; Swordsman.";<<endl;
        system(";pause";);
        swordsman enemy(i, ";Warrior";);    // Initialise an opponent, level i, name ";Junior";
        human->reFill();                // get HP/MP refill before start fight
        
        while(!human->death() && !enemy.death())    // no died
        {
            success=0;
            while (success!=1)
            {
                showinfo(*human,enemy);                // show fighter';s information
                cout<<";Please give command: ";<<endl;
                cout<<";1 Attack; 2 Special Attack; 3 Use Heal; 4 Use Magic Water; 0 Exit Game";<<endl;
                cin>>tempCom;
                switch(tempCom)
                {
                case 0:
                    cout<<";Are you sure to exit? Y/N";<<endl;
                    char temp;
                    cin>>temp;
                    if(temp==';Y';||temp==';y';)
                        return 0;
                    else
                        break;
                case 1:
                    success=human->attack(enemy);
                    human->isLevelUp();
                    enemy.isDead();
                    break;
                case 2:
                    success=human->specialatt(enemy);
                    human->isLevelUp();
                    enemy.isDead();
                    break;
                case 3:
                    success=human->useHeal();
                    break;
                case 4:
                    success=human->useMW();
                    break;
                default:
                    break;
                }
            }
            if(!enemy.death())        // If AI still alive
                enemy.AI(*human);
            else                            // AI died
            {
                cout<<";YOU WIN";<<endl;
                human->transfer(enemy);        // player got all AI';s items
            }
            if (human->death())
            {
                system(";cls";);
                cout<<endl<<setw࿒)<<";GAME OVER";<<endl;
                /ǜ_???????????        // player is dead, program is getting to its end, what should we do here?
                delete human;
 

运行截图：