справочник на STL

#include <iostream>
#include <conio.h> 
#include <string>
#include <stdio.h>
#include <windows.h>
#include <fstream> 
#include <vector>
 
#include <algorithm>
#include <functional>
 
 
using namespace std;
 
//#define NUM_ROWS 14
 
class Person{
 
public:
        Person(){}    
        ~Person(){}   
        
        
        string GetFamiliya(){ return persFamiliya;}
        string GetName(){ return persName;}
        string GetData(){ return persData;}
        string GetTelefon(){ return persTelefon;}
 
        
        void SetFamiliya(string fam){ persFamiliya=fam;}
        void SetName(string name){ persName=name;}
        void SetData(string data){ persData=data;}
        void SetTelefon(string tel){ persTelefon=tel;}
 
        
        void Print();
 
        
        
private:
        string persFamiliya;
        string persName;
        string persData;
        string persTelefon;
        
};
 
 
vector <Person> pers;
 
 
class Rus {
public:
    Rus(const char* text): data(new char [strlen( text)+1]) {CharToOemA( text, data);}
    ~Rus() {delete [] data;};
    operator const char* () const {return data;}
private:
    char* data;
};
 
 
 
void Person::Print(){
 
HANDLE H=GetStdHandle(STD_OUTPUT_HANDLE);
SetConsoleTextAttribute ( H, BACKGROUND_RED | BACKGROUND_GREEN | BACKGROUND_BLUE| BACKGROUND_INTENSITY );
 
//  cout<<"----------------------------------------------------------------"<<endl;
//cout<<Rus("|    Фамилия          | Имя         |Дата рождения|  Tелефон    | ")<<std::endl;
//  cout<<"----------------------------------------------------------------"<<endl;
//  cout<<"|                     |             |             |             | "<<endl;
    printf("| %-20.20s| %-12.12s| %-12.12s| %-12.12s|\n",persFamiliya.c_str(),persName.c_str(),persData.c_str(),persTelefon.c_str());
    }
 
 
 
void PrintMenu(){
HANDLE H=GetStdHandle(STD_OUTPUT_HANDLE);
SetConsoleTextAttribute ( H, BACKGROUND_RED | BACKGROUND_GREEN | BACKGROUND_BLUE| BACKGROUND_INTENSITY );
 
 
        cout<<endl;
               std::cout <<Rus("Выбирите действие")<<std::endl;
              std::cout <<Rus("1 - Вывести книгу")<<std::endl;
               std::cout <<Rus("2 - Сортировка")<<std::endl;
               std::cout <<Rus("3 - Поиск")<<std::endl;
               std::cout <<Rus("4 - Добавить")<<std::endl;
               std::cout <<Rus("5 - Удалить")<<std::endl;
               std::cout <<Rus("6 - Сохраненить в файл")<<std::endl;
               std::cout <<Rus("7 - Загрузить из файла")<<std::endl;
               std::cout <<Rus("8 - Выход")<<std::endl;
 
               std::cout <<"-------------------------------------------------" << std::endl;
}
 
 
void PrintAll(){system("cls");
HANDLE H=GetStdHandle(STD_OUTPUT_HANDLE);
SetConsoleTextAttribute ( H, BACKGROUND_RED | BACKGROUND_GREEN | BACKGROUND_BLUE| BACKGROUND_INTENSITY );
 
        //cout<<Rus("***---------  Записная книжка  --------------***\n");
    system("cls");
    cout<<Rus("                    ТЕЛЕФОННАЯ КНИГА")<<std::endl;
    cout<<"----------------------------------------------------------------"<<endl;
cout<<Rus("|    Фамилия          | Имя         |Дата рождения|  Tелефон    | ")<<std::endl;
    cout<<"----------------------------------------------------------------"<<endl;
    cout<<"|                     |             |             |             | "<<endl;
 
 
             for(int n=0; n<pers.size(); n++){
            //cout<<Rus("\n- Запись # ")<<n+1<<" -\n";
                pers[n].Print();
        //}
 
 
//
//// количество сторк на экране
//      if (++n == NUM_ROWS) 
//      {
//          n = 0;
//          //cout << "Press any key to continue..." << flush;
//                  cout<<Rus("Нажмите любую клавишу.....") << flush;
//          // Ожидаем нажатия любой клавиши
//          _getch();
//          cout << endl;
//      }
    }
 
    cout<<"-----------------------------------------------------------------\n";
}
 
 
int GetNumber(int imin, int imax){
        int number=imin-1;
        while(true){
        cin >> number;
        if((number>=imin) && (number <=imax))
        break;
        else{
        cout <<Rus( "Повторите ввод" )<< endl;
        cin.clear();
        while(cin.get()!='\n'){}
                }
        }
        return number;
}
 
 
 
void SortPerson() {system("cls");
HANDLE H=GetStdHandle(STD_OUTPUT_HANDLE);
SetConsoleTextAttribute ( H, BACKGROUND_RED | BACKGROUND_GREEN | BACKGROUND_BLUE| BACKGROUND_INTENSITY );
 
        cout<<Rus("***----------  сортировка  ---------------***\n");
        cout<<Rus("Введите параметр\n");
        cout<<Rus(" 1 - Фамилия\n");
        cout<<Rus(" 2 - Имя\n");
            cout<<Rus(" 3 - Телефон\n");
            cout<<Rus(" 4 - Выход\n");
            int vybor=GetNumber(1,4);
        
                switch(vybor){
                case 1:{
    cout<<Rus("                    ТЕЛЕФОННАЯ КНИГА")<<std::endl;
    cout<<"----------------------------------------------------------------"<<endl;
cout<<Rus("|    Фамилия          | Имя         |Дата рождения|  Tелефон    | ")<<std::endl;
    cout<<"----------------------------------------------------------------"<<endl;
    cout<<"|                     |             |             |             | "<<endl;
 
                        int n, i, k, dl;
                        for(n=0; n<=pers.size()-1; n++) {
                                dl=pers[n].GetFamiliya().size();
                                for (i=n+1; i<pers.size(); i++)
                                        for (k=dl; k>=0; k--)
                                                if (pers[i].GetFamiliya()[k]<pers[n].GetFamiliya()[k]) {
                                                        Person buf=pers[n];
                                                        pers[n]=pers[i];
                                                        pers[i]=buf;
                                                }                       
                        //cout<<Rus("\n- Запись N ")<<n+1<<" -\n";
 
                        pers[n].Print();
                        }
                           }
                        break;          
                case 2:{
    cout<<Rus("                    ТЕЛЕФОННАЯ КНИГА")<<std::endl;
    cout<<"----------------------------------------------------------------"<<endl;
cout<<Rus("|    Фамилия          | Имя         |Дата рождения|  Tелефон    | ")<<std::endl;
    cout<<"----------------------------------------------------------------"<<endl;
    cout<<"|                     |             |             |             | "<<endl;
 
                        int n, i, k, dl;
                        for(n=0; n<=pers.size()-1; n++) {
                                dl=pers[n].GetName().size();
                                for (i=n+1; i<pers.size(); i++)
                                        for (k=dl; k>=0; k--)
                                                if (pers[i].GetName()[k]<pers[n].GetName()[k]) {
                                                        Person buf=pers[n];
                                                        pers[n]=pers[i];
                                                        pers[i]=buf;
                                                }
                        //cout<<Rus("\n- Запись N ")<<n+1<<" -\n";
 
                        pers[n].Print();
                        }
                           }
                        break;
        
                case 3:{
    cout<<Rus("                    ТЕЛЕФОННАЯ КНИГА")<<std::endl;
    cout<<"----------------------------------------------------------------"<<endl;
cout<<Rus("|    Фамилия          | Имя         |Дата рождения|  Tелефон    | ")<<std::endl;
    cout<<"----------------------------------------------------------------"<<endl;
    cout<<"|                     |             |             |             | "<<endl;
 
                        int n, i, k, dl;
                        for(n=0; n<=pers.size()-1; n++) {
                                dl=pers[n].GetTelefon().size();
                                for (i=n+1; i<pers.size(); i++)
                                        for (k=dl; k>=0; k--)
                                                if (pers[i].GetTelefon()[k]>pers[n].GetTelefon()[k]) {
                                                        Person buf=pers[n];
                                                        pers[n]=pers[i];
                                                        pers[i]=buf;
                                                }
                        //cout<<Rus("\n- Запись N ")<<n+1<<" -\n";
 
                        pers[n].Print();
                        }
                           }
                        break;
                case 4:{
                        break;
                           }
                }
        cout<<"----------------------------------------------------------------"<<endl;
}
 
 
 
 
void FindPerson(){system("cls");
HANDLE H=GetStdHandle(STD_OUTPUT_HANDLE);
SetConsoleTextAttribute ( H, BACKGROUND_RED | BACKGROUND_GREEN | BACKGROUND_BLUE| BACKGROUND_INTENSITY );
 
     cout<<Rus("---------------------  поиск записи  -------------------------\n");
        cout<<Rus("Выбирите критерий поиска\n");
        cout<<Rus(" 1 - Фамилия\n");
            cout<<Rus(" 2 - Имя\n");
            cout<<Rus(" 3 - Дата рождения\n");
            cout<<Rus(" 4 - Телефон\n");
            cout<<Rus(" 5 - Выход\n");
        int vybor=GetNumber(1,5);
                switch(vybor){
                case 1:{
                        bool find=false;
                        string sbuf;
                        cout<<Rus("Введите фамилию: ");
                        cin>>sbuf;
                        int n=0;
    cout<<Rus("                    ТЕЛЕФОННАЯ КНИГА")<<std::endl;
    cout<<"----------------------------------------------------------------"<<endl;
cout<<Rus("|    Фамилия          | Имя         |Дата рождения|  Tелефон    | ")<<std::endl;
    cout<<"----------------------------------------------------------------"<<endl;
    cout<<"|                     |             |             |             | "<<endl;
 
                        while(n<pers.size()){
                                if(sbuf==pers[n].GetFamiliya()) {
 
                                        pers[n].Print();
                                        find=true;
                                        break;}
                                else
                                        n++;
                        }
                        if (find==false) cout<<Rus("Нет такой записи\n");
        cout<<"----------------------------------------------------------------"<<endl;
                        break;
                           }
                case 2:{
                        bool find=false;
                        string sbuf;
                        cout<<Rus("Введите имя: ");
                        cin>>sbuf;
                        int n=0;
    cout<<Rus("                    ТЕЛЕФОННАЯ КНИГА")<<std::endl;
    cout<<"----------------------------------------------------------------"<<endl;
cout<<Rus("|    Фамилия          | Имя         |Дата рождения|  Tелефон    | ")<<std::endl;
    cout<<"----------------------------------------------------------------"<<endl;
    cout<<"|                     |             |             |             | "<<endl;
 
                        while(n<pers.size()){
                                if(sbuf==pers[n].GetName()) {
                                        pers[n].Print();
                                        find=true;
                                        break;}
                                else
                                        n++;
                        }
                        if (find==false) cout<<Rus("Нет такой записи\n");
     cout<<"---------------------------------------------------------------"<<endl;
                        break;
                           }
                
                case 3:{
                        bool find=false;
                        string sbuf;
                        cout<<Rus("Введите дату рождения: ");
                        cin>>sbuf;
                        int n=0;
    cout<<Rus("                    ТЕЛЕФОННАЯ КНИГА")<<std::endl;
    cout<<"----------------------------------------------------------------"<<endl;
cout<<Rus("|    Фамилия          | Имя         |Дата рождения|  Tелефон    | ")<<std::endl;
    cout<<"----------------------------------------------------------------"<<endl;
    cout<<"|                     |             |             |             | "<<endl;
 
                        while(n<pers.size()){
                                if(sbuf==pers[n].GetData()) {
 
                                        pers[n].Print();
                                        find=true;
                                        break;}
                                else
                                        n++;
                        }
                        if (find==false) cout<<Rus("Нет такой записи\n");
        cout<<"----------------------------------------------------------------"<<endl;
                        break;
                                }
                case 4:{
                        bool find=false;
                        string sbuf;
                        cout<<Rus("Введите телефон: ");
                        cin>>sbuf;
                        int n=0;
    cout<<Rus("                    ТЕЛЕФОННАЯ КНИГА")<<std::endl;
    cout<<"----------------------------------------------------------------"<<endl;
cout<<Rus("|    Фамилия          | Имя         |Дата рождения|  Tелефон    | ")<<std::endl;
    cout<<"----------------------------------------------------------------"<<endl;
    cout<<"|                     |             |             |             | "<<endl;
 
                        while(n<pers.size()){
                                if(sbuf==pers[n].GetTelefon()) {
 
                                        pers[n].Print();
                                        find=true;
                                        break;}
                                else
                                        n++;
                        }
                        if (find==false) cout<<Rus("Нет такой записи");
        cout<<"-----------------------------------------------------------------"<<endl;
                        break;
                                }
                case 5:{
                        break;
                           }
                }
 
}
 
 
void AddPerson(){system("cls");
HANDLE H=GetStdHandle(STD_OUTPUT_HANDLE);
SetConsoleTextAttribute ( H, BACKGROUND_RED | BACKGROUND_GREEN | BACKGROUND_BLUE| BACKGROUND_INTENSITY );
 
        string sbuf;
        Person bufPers;
        cout<<endl;
 
                cout<<Rus("----------------  Добавление записи ----------------\n");
                cout<<Rus("Фамилия: ");
        cin>>sbuf;
        bufPers.SetFamiliya(sbuf);
 
        cout<<endl
                <<Rus("Имя: ");
        cin>>sbuf;
        bufPers.SetName(sbuf);
 
        cout<<endl
                <<Rus("Дата рождения: ");
        cin>>sbuf;
        bufPers.SetData(sbuf);
 
        cout<<endl
                <<Rus("Телефон:");
        cin>>sbuf;
        bufPers.SetTelefon(sbuf);
 
        pers.push_back(bufPers);
        cout<<"----------------------------------------------------------------"<<endl;
}
 
 
void DeletePerson(){system("cls");
        string sbuf;
HANDLE H=GetStdHandle(STD_OUTPUT_HANDLE);
SetConsoleTextAttribute ( H, BACKGROUND_RED | BACKGROUND_GREEN | BACKGROUND_BLUE| BACKGROUND_INTENSITY );
 
        cout<<Rus("----------------  Удаление записи ---------------\n");
        cout<<Rus("Введите фамилию: ");
        cin>>sbuf;
 
        int n=0;
        bool find=false;
        while(n<pers.size()){
                if(sbuf==pers[n].GetFamiliya()){
                        pers[n].Print();
                        find=true;
                        pers.erase(pers.begin()+n);
                        cout<<endl;
                }
                else            
                        n++;
        }
        if (find==false) cout<<Rus("Нет такой записи\n");    
        cout<<"----------------------------------------------------------------"<<endl;
 
}
 
 
 
 
void SaveToFile()
{
    ofstream fout("D:\\fileX1.bin", ios_base::out | ios_base::app | ios_base::binary);  
    if(fout.is_open() )
    {
    int size = pers.size(); 
    fout.write((char*)&size, sizeof(int));
    for(int i=0; i<size; i++)
    fout.write((char*)&pers[i], sizeof(Person));
    fout.close();
    }
 
}
 
void LoadFromFile()
{
    ifstream fin("D:\\fileX1.bin");
    if( fin.is_open() )
    {
        int size;
        fin.read((char*)&size, sizeof(int));
        for(int i=0; i<size; i++)
        {
            Person tmp;
            fin.read((char*)&tmp, sizeof(Person));
            pers.push_back(tmp);
        }
        fin.close();        
    }
 
 
 
ну и мэйн, конечно
 
main.cpp
 
#include <iostream>
#include <string>
#include <vector>
#include <fstream> 
#include <windows.h> 
#include <algorithm>
#include <functional>
 
using namespace std;
 
void PrintMenu();        
void PrintAll();         
void SortPerson();       
void FindPerson();       
void AddPerson();        
void DeletePerson();     
int GetNumber(int imin, int imax);
std::string & change(std::string & str);
void SaveToFile();
void LoadFromFile();
 
 
int main(){
 
        
        bool exit=false;
        while(true){
                PrintMenu();
HANDLE H=GetStdHandle(STD_OUTPUT_HANDLE);
SetConsoleTextAttribute ( H, BACKGROUND_RED | BACKGROUND_GREEN | BACKGROUND_BLUE| BACKGROUND_INTENSITY );
 
                switch(GetNumber(1,8)){
                case 1: PrintAll(); break;
                case 2: SortPerson(); break;
                case 3: FindPerson(); break;
                case 4: AddPerson(); break;
                case 5: DeletePerson(); break;
                case 6: SaveToFile(); break;
                case 7: LoadFromFile();break;
                case 8: exit=true; break;
                }
                if(exit)
                        break;
        }
        return 0;
 
 
        
}

//Human.h
 
#ifndef HUMAN_H
#define HUMAN_H
 
#include "Weapon.h"
#include "Things.h"
#include <cstdio>
#include <cstdlib>
 
enum TypeHuman {hHuman, hTank, hDoctor, hShturm, hUvorot };
 
class Human
{
protected:
  char *name;
  int life, Respect, Level,   Money,   Expirience;
  // Жизнь, Уважение, Уровень, Деньги,  Опыт
 
  int currentThing; //вещь на игорке
  int current;      //оружие в руках игрока
 
  Weapon **W;   //массив для хранения оружия
  Things **Th;  //массив для хранения вещей
 
  TypeHuman Type;
public:
  Human(char*n);
  virtual~Human();
  //ф-я которая изменяет жизнь
  int Changelife(int l);
  int ChangeExpiriens();
  virtual void Defence(Human*h);
  virtual void Shoot(Human*h);// в кого стрелять
  void SetWeapon(int  c);//выбор оружия
  void SetThings(int  t);//выбор вещей
  void Print();
  void SaveToFile(FILE* file);
  void LoadFromFile(FILE* file);
  TypeHuman GetType();
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
class Tank:public Human
{
public:
  Tank(char*n);
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
class Doctor:public Human
{
public:
  Doctor(char*n);
  virtual void Heel(Human*h);
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
class Shturm:public Human
{
public:
  Shturm(char*n);
  void Shoot(Human*h);
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
class Uvorot:public Human
{
public:
  Uvorot(char*n);
};
 
#endif HUMAN_H

//Human.cpp
 
//Human.cpp
 
#include "human.h"
 
Human::Human(char *n)
{
    name=new char[strlen(n)+1];
    strcpy(name,n);
    current=0;
    life=50;
    currentThing=0;
    Respect=0,  Level=1,   Money=100,   Expirience=0;
    Type = hHuman;  // Тип hHuman
        
    W=new Weapon*[3];
        
    W[0]=new Knife("BigKnife");
    W[1]=new Pulemet("Pulemet");
    W[2]=new Gung("AKM");
        
 
    Th=new Things*[2];
        
    Th[0]=new Bronegelet("Bronegelet");
    Th[1]=new Helmet("Helmet");
}
 
Human::~Human()
{
    delete  [] name;
    delete W[0];
    delete W[1];
    delete W[2];
 
    delete Th[0];
    delete Th[1];
}
 
int Human::Changelife(int l)
{
    return life+=l;
}
 
int Human::ChangeExpiriens()
{
    return Expirience++;
}
 
void Human::Defence(Human*h)
{
    h->Changelife(Th[currentThing]->Defence());
}
 
void Human::Shoot(Human*h)
{
    int i=rand()%100;
    if ( (h->Type == hUvorot) ? i<40 : i<20)
    {
      cout<<"Promazal!!!:))\n";
    }
    else
    {
      h->Changelife(-W[current]->Shoot());
    }
}
 
void Human::SetWeapon(int  c)
{
    current=c;
}
 
void Human::SetThings(int  t)
{
    currentThing=t;
}
 
void Human::Print()
{
    cout<<"name="<<name<<"\n"<<"life"<<life<<"\n";
    cout<<"Level="<<Level<<"\n";
    cout<<"Money="<<Money<<"\n";
    cout<<"Expirience="<<Expirience<<"\n";
    W[current]->Print();
    Th[currentThing]->Print();
}
 
void Human::SaveToFile(FILE* file)
{
    int size=strlen(name)+1;
    fwrite(&life, sizeof(int), 1, file);
    fwrite(&current, sizeof(int), 1, file);
    fwrite(&size, sizeof(int), 1, file);
    fwrite(name, sizeof(char) , size, file);
}
 
void Human::LoadFromFile(FILE* file)
{
    int size;
    fread(&life, sizeof(int), 1, file);
    fread(&current, sizeof(int), 1, file);
    fread(&size, sizeof(int), 1, file);
    fread(name, sizeof(char) , size, file);
    fclose(file);
}
 
TypeHuman Human::GetType()
{
   return Type;
}
 
/////////////////////////////////////////////////
 
Tank::Tank(char *n):Human(n)
{
    Type = hTank;
    life=100;
}
 
/////////////////////////////////////////////////
 
Doctor::Doctor(char *n):Human(n)  
{
    Type = hDoctor;
}
 
void Doctor::Heel(Human*h )
{
    h->Changelife(10);
}
 
///////////////////////////////////////////////////
 
Shturm::Shturm(char *n):Human(n)
{
    Type = hShturm;
}
 
void Shturm::Shoot(Human*h )
{
    int i=rand()%100;
    if( (h->GetType() == hUvorot) ? i<40 : i<20 )
    {
      cout<<"Promazal!!!:))\n";
    }
    else
    {
      h->Changelife(-W[current]->Shoot()+10);
    }
}
 
////////////////////////////////////////////////////
 
Uvorot::Uvorot(char *n):Human(n)
{
    Type=hUvorot;
}

#include<windows.h>
#include<iostream>
#include <cstring>
#include <io.h>
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#include <time.h>
 
 
using namespace std;
 
class Weapon
{
protected:
    int damage,count;//урон и количество патронов
    char* name;
    public:
        
        Weapon(char*n){name=new char [strlen(n)+1];strcpy(name,n);}
        
        ////описываем поведение оружия
        virtual int Shoot()=0;
        void Print()
        {
            cout<<name<<"\n"<<count<<"\n";
            
        }
        virtual~Weapon(){delete[]name;}
};
class Knife:public Weapon
{
        
public:
    
    ////описываем поведение оружия
        int Shoot() {cout<<"Udar of knife\n"; return damage;}
        Knife(char*n):Weapon(n){damage=10;count=1;}
        
};
 
class Gung:public Weapon
{
 
public:
    int Shoot() {cout<<"Shoot of gung !!\n"; return damage;--count;}
    Gung(char*n):Weapon(n){damage=20;count=2;}
    
    
};
class Pulemet:public Weapon
{
public:
 
    int Shoot() {cout<<"Ochered of Pulemet !!\n"; return damage;count-=10;}
    Pulemet(char*n):Weapon(n){damage=30;count=20;}
    
};
 
 
class Things
{
protected:
    int defence;//защита
    char* nameThing;
    public:
        
        Things(char*nt){nameThing=new char [strlen(nt)+1];strcpy(nameThing,nt);}
        
        ////описываем поведение вещи
        virtual int Defence()=0;
        void Print()
        {
            cout<<nameThing<<"\n"<<defence<<"\n";
            
        }
 
        virtual~Things()
        {
            delete[]nameThing;
        }
 
};
 
class Bronegelet:public Things
{
 
public:
    int Defence() {cout<<"Put on Bronegelet !!\n"; return defence;}
    Bronegelet(char*n):Things(n){defence=10;}
    
    
};
class Helmet:public Things
{
public:
 
   int Defence() {cout<<"Put on Helmet !!\n"; return defence;}
    Helmet(char*n):Things(n){defence=5;}
    
};
class Human
{
protected:
char *name;
int life, Respect, Level,   Money,  Status_step, Expirience, XP_LEVEL;             
// Жизнь, Уважение, Уровень, Деньги, Статус(шаг), Опыт, Опыт для наращивания уровня
   
int currentThing;//вещь на игорке
int current;///оружие в руках игрока
 
Weapon**W;///массив для хранения оружия 
Things**Th;///массив для хранения вещей
 
public:
    Human(char*n)
    {name=new char[strlen(n)+1];  
    strcpy(name,n);
    current=0;
    life=50;
    currentThing=0;
    Respect=0,  Level=1,   Money=0,  Status_step=0, Expirience=0, XP_LEVEL=0;
    
    
    W=new Weapon*[3];
    
    W[0]=new Knife("BigKnife");
    W[1]=new Pulemet("Pulemet");
    W[2]=new Gung("AKM");
    
 
    Th=new Things*[2];
    
    Th[0]=new Bronegelet("Bronegelet");
    Th[1]=new Helmet("Helmet");
    }
 
    virtual~Human()
    {
    delete  [] name;
    delete W[0];
    delete W[1];
    delete W[2];
 
    delete Th[0];
    delete Th[1];
    }
 
    //ф-я которая изменяет жизнь
    int Changelife(int l) {return life+=l;}
    
    virtual void Defence(Human*h)
    {
    h->Changelife(Th[currentThing]->Defence());
    }
 
 
 
    virtual void Shoot(Human*h )// в кого стрелять
    {
        int i=rand()%100;
        if (i<20){cout<<"Promazal!!!:))\n";}
        else
        {
            h->Changelife(-W[current]->Shoot());
        }
    }
 
    void SetWeapon(int  c)//выбор оружия 
    {
     current=c;
    }
    void SetThings(int  t)//выбор вещей 
    {
     currentThing=t;
    }
 
    void Print()
    {
        cout<<"name="<<name<<"\n"<<"life"<<life<<"\n";
        cout<<"Respect="<<Respect<<"\n"<<"Level="<<Level<<"\n";
        cout<<"Money="<<Money<<"\n"<<"Status_step="<<Status_step<<"\n";
        cout<<"Expirience="<<Expirience<<"\n"<<"XP_LEVEL="<<XP_LEVEL<<"\n";
        W[current]->Print();
        Th[currentThing]->Print();
    }
 
 
 
void SaveToFile(FILE* file)
{
    int size=strlen(name)+1;
    fwrite(&life, sizeof(int), 1, file);
    fwrite(&current, sizeof(int), 1, file);
    fwrite(&size, sizeof(int), 1, file);
    fwrite(name, sizeof(char) , size, file);
}
 
void LoadFromFile(FILE* file)
{
int size;
    fread(&life, sizeof(int), 1, file);
    fread(&current, sizeof(int), 1, file);
    fread(&size, sizeof(int), 1, file);
    fread(name, sizeof(char) , size, file);
    fclose(file);
 
 
}
    
 
};
 
 
 
class Tank:public Human
{
    public:
        Tank(char*n):Human(n)
        {
            life=100;
        }
    
};
 
class Doctor:public Human
{
    public: 
        Doctor(char*n):Human(n){} 
        
        
    virtual void Heel(Human*h )
    {
        h->Changelife(10);
      
    }
 
};
 
class Shturm:public Human
{
    public:
        Shturm(char*n):Human(n){}   
 
    void Shoot(Human*h )
    {
        int i=rand()%100;
        if (i<20){cout<<"Promazal!!!:))\n";}
        else
        {
            h->Changelife(-W[current]->Shoot()+10);
        }
    }
};
 
 
 
 
 
class Game
{      
    Human** players;
public:
 
    Game ()
    {
         players= new Human*[3];
       for (int i=0;i<3;++i)
       {
           cout<<"Who are you :\n";
           cout<<"Doctor(1)?,Tanc(2)?,Shturm(3)?\n";
            
             int c; char name[20];
             c=_getch(); c=c-'1'; cout<<endl<<"Enter PlayerS name\n"; cin >>name;
            switch(c)
            {
                case 0:
                players[i]=new Doctor(name);
                break;
                case 1:
                players[i]=new Tank(name) ;
                break;
                default:
                players[i]=new Shturm(name);
                break;
            }
       }
    }
 
    ~Game()
    {
    for (int i=0;i<3;++i)
       delete players[i];
    delete  [] players;
    }
void Print()
{
    system("cls");
 
    for (int i=0;i<3;++i)
    {
        players[i]->Print();
        cout<<"\n\n";
    }
}
 
void Save()
{
FILE* file = fopen("ShooterPlayer.txt", "w+");
    if (file==NULL)
    {
    cout <<"Ne udalos otktyt file\n";
    exit (0);
    }
 
    for (int i=0;i<3;++i)
    {
        players[i]->SaveToFile(file);
    }
 
fclose(file);
}
 
void Load()
{
 
FILE* file = fopen("ShooterPlayer.txt", "w+");
    if (file==NULL)
    {
    cout <<"Ne udalos otktyt file\n";
    exit (0);
    }
 
    for (int i=0;i<3;i++)
    {
    players[i]->LoadFromFile(file);
    }
 
fclose(file);
 
 
}
 
 
void ChangeWeapon(int curr)
{
        cout<<"Choose Weapon:2\n ";
        cout<<"if Knife press 1\n ";
        cout<<"if Pulemet press 2\n ";
        cout<<"if Gung press 3\n ";
        int c; c=_getch();
        c=c-'1';
        players[curr]->SetWeapon(c);
 
}
 
void Shoot(int curr)
{
cout <<"Choose enemy:\n"; 
            cout<<"if Doctor press 1\n";
            cout<<"if Tank press 2\n ";
            cout<<"if Shturm press 3\n ";
 
int c;
c=_getch(); c-='1';
players[curr]->Shoot(players[c]);
}
 
bool isOK()
{
    int k=0;
    for (int i=0;i<3;++i)
    {
        if (players[i]->Changelife(0)>0)
            ++k;
    }
 
   return k>1;
}
 
 
 
void Play()
{
    while (isOK())
    {
        for (int i=0;i<3;++i)
        {
            if(players[i]->Changelife(0)>0)
            {
            Print();
            ChangeWeapon(i);
            Shoot(i);
            Sleep(1000);
            }
            else {cout<<players[i]<<"was dead\n";}
        }
    }
 
}
 
 
};
 
void main()
{
        Game obj;
 
    HANDLE H=GetStdHandle(STD_OUTPUT_HANDLE);
    enum keys {ESC=27, LEFT=75, RIGHT=77, UP=72, DOWN=80, SH=254};
    int m=0,x=0,key=0,podmenu=0,menu=1;
    while(true)
    {
        if (menu == 1)
        {
            system("CLS");
            for(int i=0; i<3; i++)
            {
                m=i;
                
                    if(i==x)
                    {
                        SetConsoleTextAttribute(H, FOREGROUND_RED | FOREGROUND_INTENSITY);
                        cout<<"->";
                        SetConsoleTextAttribute(H, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
                    }
                    else
                    {cout<<" ";}
            
                switch(m)
                {
                case 0: cout<<" Play game";
                    break;
                case 1: cout<<" save / load";
                    break;
                case 2: cout<<" Exit";
                }
                cout<<"\n";
            }
            key = getch();
            if(key == ESC)
            {
                exit(0);
            }
            else if(key == 224)
            {
                key = getch();  
                switch(key)
                {
                case UP:    x>0 ? x-- : x=2; break;
                case DOWN:  x<2 ? x++ : x=0; break;
                }
            }
            else if(key == 13)
            {
                switch (x)
                {
                case 0: obj.Play();obj.Print();
                    break;
                case 1: system("CLS");int ans; cout<<"to save press 1\n";
                            cout<<"to load press 2\n"; 
                    cin>>ans;
                    if (ans==1){obj.Save();}
                    else if (ans==2){obj.Load();}
                    else cout<<"error!\n";
                    break;
                case 2: exit(0);
                    break;
                }
            }
        }
    }
}