Форум программистов, компьютерный форум, киберфорум
Наши страницы
С++ для начинающих
Войти
Регистрация
Восстановить пароль
 
Zohan1234567
0 / 0 / 0
Регистрация: 09.07.2016
Сообщений: 25
#1

Абстрактные классы. Виртуальные функции. Задача

16.11.2016, 06:31. Просмотров 457. Ответов 3
Метки нет (Все метки)

ПОМОГИТЕ ПОЖАЛУЙСТА РЕШИТЬ ЗАДАЧУ:
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
#include<stdio.h>
#include<conio.h>
#include<locale.h>
#include<time.h>
#include<stdlib.h>
#include<string>
#include<windows.h>
#include <math.h>
 
//"Программно промоделировать стрельбу по мишени группой человек.  
//Каждый человек имеет свое имя, возраст (в годах) и стаж обучения стрель-
//бе (в годах).  
//Люди  делятся  на  новичков,  опытных  и  ветеранов  (потомки  класса  чело-
//век).  Для  каждого  человека  определите  полиморфный  метод  «Стрелять» 
//без  параметров,  возвращающий  целочисленное значение  (попал  – 1,  не 
//попал  –  0).  Попадание  определяется  случайным  образом,  причем  для 
//новичка вероятность попасть равна 0,01*стаж обучения; для опытного  = 
//0,05*стаж обучения стрельбе; для ветерана = 0,7 – 0,01*возраст. 
//Люди  стреляют  по  очереди,  начиная  с  первого  пока  кто-то  не  попадет  в 
//мишень.  Стрельба  прекращается  после  того,  как  кто-то  попал  или  все 
//выстрелили по одному разу. После каждого выстрела нужно выводить на 
//экран всю информацию о стреляющем и результат стрельбы. 
//В главной программе создайте массив из 7 людей в таком порядке: нови-
//чок, новичок, опытный, ветеран, опытный, новичок и произведите стрель-
//бу с выводом ее результатов. 
 
 
//========================================//
//=================КЛАСС==================//
class Chel
{
    protected:
        char *name;
        int   let;
        int experience;
        
    public:
//-------------Конструкторы--------------//     
        Chel(char *name, int let, int experience)  //с параметрами
         {  
           this->name=new char[strlen(name)+1];
           strcpy(this->name,name);
           this->let=let;
           this->experience=experience;
         } 
         
        Chel()   // без параметров
         {
           this->name=new char(0);
           this->let=0;
           this->experience=0;
         }
//-------------Сэттеры-------------------//         
        void set_name(char *name)                 
         {
           delete(this->name);  
           this->name=new char[strlen(name)+1];
           strcpy(this->name,name);
         }         
        void set_let(int let)
         {
           this->let=let;
         } 
         void set_experience(int experience)
         {
           this->experience=experience;
         } 
         
//-------------Геттеры-------------------//       
        char *get_name()                        
         {
           return(this->name);  
         } 
        int get_let()  
         {
           return(this->let);   
         }
        int get_experience()  
         {
           return(this->experience);    
         }
//-----------Инфо_метод-------------------//    
        virtual void Info()=0;
        virtual void Show(Chel *Ch)=0; 
//-----------Деструктор-------------------//         
        virtual ~Chel()
         {
            delete(this->name);
         }           
};
 
//==========НАСЛЕДУЕМЫЙ КЛАСС=============//
class newbie: public Chel
{
    protected:
    public:
//-------------Конструкторы---------------//        
        newbie(char *name, int let,int experience ):Chel(name,let,experience) //с параметрами
         {  
         } 
        newbie():Chel() // без параметров
         {
         }
//-----------метод_стрелять-------------------//    
        void fire()
         {
            int i, a;
            a = 0,01*experience;
            if (a>=1)
            printf("Я новичек %s, мне %d, я попал\n", this->name, this->let);
            else if (a==0)
            printf("Я новичек %s, мне %d, я не попал\n", this->name, this->let);
         }
//        void Show(Chel *Ch)
//         {
//          int i;
//          printf("Оппаа, здарова, %s\n", Ch[i].get_name());
//         }
//-----------Деструктор-------------------//         
        ~newbie()
         {
         }           
};
 
//==========НАСЛЕДУЕМЫЙ КЛАСС=============//
class experienced: public Chel
{
    protected:
    public:
//-------------Конструкторы---------------//        
        experienced(char *name, int let,int experience): Chel(name, let, experience)       //с параметрами
         {  
         } 
        experienced(): Chel()                                  // без параметров
         {
         }
//-----------Инфо_метод-------------------//    
        void fire()
         {
            int i, a;
            a = 0,05*experience;
            if (a>=1)
            printf("Я опытный %s, мне %d, я попал\n", this->name, this->let);
            else if (a==0)
            printf("Я опытный %s, мне %d, я не попал\n", this->name, this->let);
         }
//        void Show(Chel *Ch)
//         {
//          int i;
//          printf("Привет, %s\n", Ch[i].get_name());
//         }
//-----------Деструктор-------------------//         
        ~experienced()
         {
         }           
};
 
//==========НАСЛЕДУЕМЫЙ КЛАСС=============//
class veteran: public Chel
{
    protected:
    public:
//-------------Конструкторы---------------//        
        veteran(char *name, int let, int experience): Chel(name, let, experience) //с параметрами
         {  
         } 
        veteran(): Chel()   // без параметров
         {
         }
//-----------Инфо_метод-------------------//    
        void fire()
         {
            int i, a;
            a = 0,05*experience;
            if (a>=1)
            printf("Я опытный %s, мне %d, я попал\n", this->name, this->let);
            else if (a==0)
            printf("Я опытный %s, мне %d, я не попал\n", this->name, this->let);
         }
       void Show(Chel *Ch)
         {
            int i;
            if (this->let-Ch[i].get_let()<-5)
            {
                printf("Приветствую Вас, %s\n", Ch[i].get_name());
            }
            else 
            {
                printf("Здраствуй, %s\n", Ch[i].get_name());
            }
         } 
//-----------Деструктор-------------------//         
        ~veteran()
         {
         }           
};
 
main()
{
//  SetConsoleCP(1251);
//  SetConsoleOutputCP(1251);
//  SetLocale (0," ");
    setlocale(LC_ALL,"Rus");
    srand(time(0));
    
    int n=1;
    
    newbie *Gp1=new newbie("Новичек",22);
    newbie *Gp3=new newbie("Новичек",26);
    experienced *Op1=new experienced("Опытный",24);
    veteran *Bn1=new veteran("Ветеран",20);
    experienced *Op2=new experienced("Опытный",32);
    newbie *Gp2=new newbie("Новичек",26);
    veteran *Bn2=new veteran("Ветеран",30);
    
        
    Chel **N2=new Chel*[7];
    N2[0]=Gp1;
    N2[1]=Gp3;
    N2[2]=Op1;
    N2[3]=Bn1;
    N2[4]=Op2;
    N2[5]=Gp2;
    N2[6]=Bn2;
    
    for(int i=0;i<7;i++)
    {
        N2[i]->Info();
    }
    printf("\n");
    
    for(int i=0;i<7;i++)
     {
        for(int j=n;j<7;j++)
        {
          printf("%s: ",N2[i]->get_name()); 
          N2[i]->Show(N2[j]);
          printf("%s: ",N2[j]->get_name());
          N2[j]->Show(N2[i]);
        }
        n++;
        printf("\n");
    }
    
    return(0);  
}
0
Надоела реклама? Зарегистрируйтесь и она исчезнет полностью.
Similar
Эксперт
41792 / 34177 / 6122
Регистрация: 12.04.2006
Сообщений: 57,940
16.11.2016, 06:31
Ответы с готовыми решениями:

Абстрактные классы, виртуальные функции
Собственно сабж. нужна достаточно простая(не важно что выполняющая) программа с...

Абстрактные классы. Виртуальные функции
Помогите, пожалуйста. Класс : место - область - город - мегаполис 1....

Виртуальные функции и абстрактные классы
Есть два класса: Человек и производный от него Совершеннолетний. 1) Как...

Виртуальные функции. Абстрактные классы.
Есть у меня абстрактный класс class DataManager { protected: ...

Абстрактные классы и чистые виртуальные функции
У Р. Лафоре написано: И вот, есть такой пример из его книги: #include...

3
MrGluck
Модератор
Эксперт CЭксперт С++
8078 / 4931 / 1431
Регистрация: 29.11.2010
Сообщений: 13,366
16.11.2016, 09:43 #2
Много текста. Конкретизируйте задачу и участок кода, который некорректно работает. Повысите шансы на ответ.
0
Mathist
56 / 52 / 33
Регистрация: 18.04.2014
Сообщений: 120
Завершенные тесты: 2
16.11.2016, 13:44 #3
Zohan1234567,
Кликните здесь для просмотра всего текста
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
#include <clocale>
#include <ctime>
#include <string.h>
#include <iostream>
 
//"Программно промоделировать стрельбу по мишени группой человек.
//Каждый человек имеет свое имя, возраст (в годах) и стаж обучения стрель-
//бе (в годах).
//Люди  делятся  на  новичков,  опытных  и  ветеранов  (потомки  класса  чело-
//век).  Для  каждого  человека  определите  полиморфный  метод  «Стрелять»
//без  параметров,  возвращающий  целочисленное значение  (попал  – 1,  не
//попал  –  0).  Попадание  определяется  случайным  образом,  причем  для
//новичка вероятность попасть равна 0,01*стаж обучения; для опытного  =
//0,05*стаж обучения стрельбе; для ветерана = 0,7 – 0,01*возраст.
//Люди  стреляют  по  очереди,  начиная  с  первого  пока  кто-то  не  попадет  в
//мишень.  Стрельба  прекращается  после  того,  как  кто-то  попал  или  все
//выстрелили по одному разу. После каждого выстрела нужно выводить на
//экран всю информацию о стреляющем и результат стрельбы.
//В главной программе создайте массив из 7 людей в таком порядке: нови-
//чок, новичок, опытный, ветеран, опытный, новичок и произведите стрель-
//бу с выводом ее результатов.
 
//========================================//
//=================КЛАСС==================//
using namespace std;
 
class Chel {
protected:
    char *name;
    int let;
    int experience;
 
public:
    //-------------Конструкторы--------------//
    Chel(const char *name, int let, int experience)  //с параметрами
            {
        this->name = new char[strlen(name) + 1];
        strcpy(this->name, name);
        this->let = let;
        this->experience = experience;
    }
 
    Chel()   // без параметров
    {
        this->name = new char[1];
        this->name[0] = 0;
        this->let = 0;
        this->experience = 0;
    }
    //-------------Сэттеры-------------------//
    void set_name(char *name) {
        delete[] this->name;
        this->name = new char[strlen(name) + 1];
        strcpy(this->name, name);
    }
    void set_let(int let) {
        this->let = let;
    }
    void set_experience(int experience) {
        this->experience = experience;
    }
 
    //-------------Геттеры-------------------//
    char *get_name() {
        return (this->name);
    }
    int get_let() {
        return (this->let);
    }
    int get_experience() {
        return (this->experience);
    }
    //-----------Инфо_метод-------------------//
    void Info() {
        cout << "Я " << name << ". Мой возраст - " << let;
        cout << ". Опыт - " << experience << "." << endl;
    }
    virtual unsigned Fire() = 0;
 
    char ShowFire() {
        Info();
 
        if (Fire()) {
            cout << "Я попал" << endl;
            return 1;
        } else {
            cout << "Я не попал" << endl;
            return 0;
        }
    }
    //-----------Деструктор-------------------//
    virtual ~Chel() {
        delete[] this->name;
    }
};
 
//==========НАСЛЕДУЕМЫЙ КЛАСС=============//
class newbie: public Chel {
protected:
public:
    //-------------Конструкторы---------------//
    newbie(const char *name, int let, int experience) :
            Chel(name, let, experience) //с параметрами
    {
    }
    newbie() :
            Chel() // без параметров
    {
    }
    //-----------метод_стрелять-------------------//
    unsigned Fire() override {
        return 0.01 * experience > (rand() % 100) / 100.0;
    }
    //-----------Деструктор-------------------//
    ~newbie() {
    }
};
 
//==========НАСЛЕДУЕМЫЙ КЛАСС=============//
class experienced: public Chel {
protected:
public:
    //-------------Конструкторы---------------//
    experienced(const char *name, int let, int experience) :
            Chel(name, let, experience)       //с параметрами
    {
    }
    experienced() :
            Chel()                                  // без параметров
    {
    }
    //-----------Инфо_метод-------------------//
    unsigned Fire() override {
        return 0.05 * experience > (rand() % 100) / 100.0;
    }
    //-----------Деструктор-------------------//
    ~experienced() {
    }
};
 
//==========НАСЛЕДУЕМЫЙ КЛАСС=============//
class veteran: public Chel {
protected:
public:
    //-------------Конструкторы---------------//
    veteran(const char *name, int let, int experience) :
            Chel(name, let, experience) //с параметрами
    {
    }
    veteran() :
            Chel()   // без параметров
    {
    }
    //-----------Инфо_метод-------------------//
    unsigned Fire() override {
        return 0.7 - 0.01 * let > (rand() % 100) / 100.0;
    }
 
    //-----------Деструктор-------------------//
    ~veteran() {
    }
};
 
int main() {
    //  SetConsoleCP(1251);
    //  SetConsoleOutputCP(1251);
    //  SetLocale (0," ");
    setlocale(LC_ALL, "Rus");
    srand(time(0));
 
    const int N = 7;
    Chel **arr = new Chel*[N];
    arr[0] = new newbie("Новичек", 22, 1);
    arr[1] = new newbie("Новичек", 26, 2);
    arr[2] = new experienced("Опытный", 24, 5);
    arr[3] = new veteran("Ветеран", 50, 30);
    arr[4] = new experienced("Опытный", 32, 10);
    arr[5] = new newbie("Новичек", 26, 3);
    arr[6] = new veteran("Ветеран", 30, 12);
 
    for (int i = 0; i < N; ++i) {
        arr[i]->Info();
    }
    cout << endl;
 
    for (int j = 0; !arr[j++]->ShowFire(); j = j == N ? 0 : j) {
    }
 
    for (int i = 0; i < N; i++) {
        delete arr[i];
    }
    delete arr;
    return (0);
}
0
Mr.X
Эксперт С++
3178 / 1705 / 435
Регистрация: 03.05.2010
Сообщений: 3,867
16.11.2016, 23:40 #4
Zohan1234567, очень много ненужных и бессмысленных комментариев, которые засоряют программу и мешают чтению.
Мой вариант:
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
///////////////////////////////////////////////////////////////////////////////
//1.
///////////////////////////////////////////////////////////////////////////////
//"Программно промоделировать стрельбу по мишени группой человек.
//Каждый человек имеет свое имя, возраст (в годах) и стаж обучения стрель-
//бе (в годах).
//Люди  делятся  на  новичков,  опытных  и  ветеранов  (потомки  класса  чело-
//век).  Для  каждого  человека  определите  полиморфный  метод  «Стрелять»
//без  параметров,  возвращающий  целочисленное значение  (попал  – 1,  не
//попал  –  0).  Попадание  определяется  случайным  образом,  причем  для
//новичка вероятность попасть равна 0,01*стаж обучения; для опытного  =
//0,05*стаж обучения стрельбе; для ветерана = 0,7 – 0,01*возраст.
//Люди  стреляют  по  очереди,  начиная  с  первого  пока  кто-то  не  попадет  в
//мишень.  Стрельба  прекращается  после  того,  как  кто-то  попал  или  все
//выстрелили по одному разу. После каждого выстрела нужно выводить на
//экран всю информацию о стреляющем и результат стрельбы.
//В главной программе создайте массив из 7 людей в таком порядке: нови-
//чок, новичок, опытный, ветеран, опытный, новичок и произведите стрель-
//бу с выводом ее результатов.
///////////////////////////////////////////////////////////////////////////////
#include <ctime>
#include <iostream>
#include <random>
#include <string>
#include <vector>
///////////////////////////////////////////////////////////////////////////////
typedef std::string     T_str;
///////////////////////////////////////////////////////////////////////////////
class   T_person
{
    //-------------------------------------------------------------------------
    T_str   name_;
    int     age_;
    //-------------------------------------------------------------------------
public:
    //-------------------------------------------------------------------------
    T_person
        (
            T_str   const   &   name,
            int                 age
        )
        :
        name_   ( name  ),
        age_    ( age   )
    {}
    //-------------------------------------------------------------------------
    virtual
    void    print_data()                                                    const
    {
        std::cout   <<  "name\t\t: "    <<  name_   <<  std::endl
                    <<  "age\t\t: "     <<  age_    <<  std::endl;
    }
    //-------------------------------------------------------------------------
    int     get_age()                                                       const
    {
        return  age_;
    }
    //-------------------------------------------------------------------------
};
///////////////////////////////////////////////////////////////////////////////
class   T_shooter   :   public  T_person
{
    //-------------------------------------------------------------------------
    int     shooting_training_experience_;
    //-------------------------------------------------------------------------
public:
    //-------------------------------------------------------------------------
    T_shooter
        (
            T_str   const   &   name,
            int                 age,
            int                 shooting_training_experience
        )
        :
        T_person                        (
                                            name,
                                            age
                                        ),
 
        shooting_training_experience_   ( shooting_training_experience )
    {}
    //-------------------------------------------------------------------------
    virtual
    ~T_shooter()
    {}
    //-------------------------------------------------------------------------
    int     get_shooting_training_experience()                              const
    {
        return  shooting_training_experience_;
    }
    //-------------------------------------------------------------------------
    bool    successfully_shot()                                             const
    {
        return  generate_success_with_probability   (
                                                        hit_probability()
                                                    );
    }
    //-------------------------------------------------------------------------
    virtual
    void    print_data()                                        const   override
    {
        T_person::print_data();
 
        std::cout
            <<  "experience\t: "    <<  shooting_training_experience_   <<  std::endl
            <<  "p = "              <<  hit_probability()               <<  std::endl;
    }
    //-------------------------------------------------------------------------
private:
    //-------------------------------------------------------------------------
    virtual
    double  hit_probability()   const   =   0;
    //-------------------------------------------------------------------------
    bool    generate_success_with_probability( double   probability )       const
    {
        static  std::mt19937                    gen     (
                                                            unsigned(time(0))
                                                        );
 
        std::discrete_distribution<>            distr   (
                                                            {
                                                                1 - probability,
                                                                probability
                                                            }
                                                        );
 
        return  distr( gen );
    }
    //-------------------------------------------------------------------------
};
///////////////////////////////////////////////////////////////////////////////
class   T_novice_shooter    :   public  T_shooter
{
    //-------------------------------------------------------------------------
public:
    //-------------------------------------------------------------------------
    using   T_shooter::T_shooter;
    //-------------------------------------------------------------------------
    virtual
    void    print_data()                                        const   override
    {
        std::cout   <<  "novice_shooter"    <<  std::endl;
        T_shooter::print_data();
    }
    //-------------------------------------------------------------------------
    virtual
    double  hit_probability()                                   const   override
    {
        return      0.01
                *   get_shooting_training_experience();
    }
    //-------------------------------------------------------------------------
};
///////////////////////////////////////////////////////////////////////////////
typedef std::vector     < T_shooter*    >   T_shooter_ptrs;
///////////////////////////////////////////////////////////////////////////////
class   T_expert_shooter    :   public  T_shooter
{
    //-------------------------------------------------------------------------
public:
    //-------------------------------------------------------------------------
    using   T_shooter::T_shooter;
    //-------------------------------------------------------------------------
    virtual
    double  hit_probability()                                   const   override
    {
        return      0.05
                *   get_shooting_training_experience();
    }
    //-------------------------------------------------------------------------
    virtual
    void    print_data()                                        const   override
    {
        std::cout   <<  "expert_shooter"
                    <<  std::endl;
 
        T_shooter::print_data();
    }
    //-------------------------------------------------------------------------
};
///////////////////////////////////////////////////////////////////////////////
class   T_veteran_shooter   :   public  T_shooter
{
    //-------------------------------------------------------------------------
public:
    //-------------------------------------------------------------------------
    using   T_shooter::T_shooter;
    //-------------------------------------------------------------------------
    virtual
    double  hit_probability()                                   const   override
    {
        return      0.7
 
                -       0.01
                    *   get_age();
    }
    //-------------------------------------------------------------------------
    virtual
    void    print_data()                                        const   override
    {
        std::cout   <<  "veteran_shooter"
                    <<  std::endl;
 
        T_shooter::print_data();
    }
    //-------------------------------------------------------------------------
};
///////////////////////////////////////////////////////////////////////////////
int     main()
{
    T_shooter_ptrs  shooter_ptrs;
 
    //1
    shooter_ptrs.push_back  (
                                new     T_novice_shooter    (
                                                                "Trump",
                                                                30,
                                                                2
                                                            )
                            );
    //2
    shooter_ptrs.push_back  (
                                new     T_novice_shooter    (
                                                                "Reagan",
                                                                20,
                                                                1
                                                            )
                            );
    //3
    shooter_ptrs.push_back  (
                                new     T_expert_shooter    (
                                                                "Obama",
                                                                40,
                                                                5
                                                            )
                            );
    //4
    shooter_ptrs.push_back  (
                                new     T_veteran_shooter    (
                                                                "Kennedy",
                                                                60,
                                                                20
                                                            )
                            );
    //5
    shooter_ptrs.push_back  (
                                new     T_expert_shooter    (
                                                                "Clinton",
                                                                45,
                                                                7
                                                            )
                            );
    //6
    shooter_ptrs.push_back  (
                                new     T_novice_shooter    (
                                                                "Johnson",
                                                                33,
                                                                3
                                                            )
                            );
    //7
    shooter_ptrs.push_back  (
                                new     T_novice_shooter    (
                                                                "Truman",
                                                                22,
                                                                4
                                                            )
                            );
 
    for(;;)
    {
        std::cout   <<  std::endl
                    <<  std::endl;
 
        int     shots_count{};
 
        for( auto   shooter_ptr     :   shooter_ptrs )
        {
            std::cout   <<  "# "
                        <<  ++shots_count
                        <<  ":"
                        <<  std::endl;
 
            shooter_ptr->print_data();
 
            auto
            res     =   shooter_ptr->successfully_shot();
 
            std::cout   <<  "result\t\t: "  <<  res     <<  std::endl
                        <<  std::endl;
 
            if( res )
            {
                break;
            }
        }//for
 
        system("pause");
    }//for
}
1
MoreAnswers
Эксперт
37091 / 29110 / 5898
Регистрация: 17.06.2006
Сообщений: 43,301
16.11.2016, 23:40

Наследование: Чистые Виртуальные функции и Абстрактные классы
Добрый вечер помогите пожалуйста вывести на экран то что мы вводим с клавиатуры...

Виртуальные абстрактные базовые классы
Привет всем!:-) Вчера столкнулся со следующей проблемой: компилятор ругается на...

Виртуальные функции и классы
Всем привет. Подскажите, пожалуйста, часть задания: Есть класс свет, в нем...


Искать еще темы с ответами

Или воспользуйтесь поиском по форуму:
4
Ответ Создать тему
Опции темы

КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2018, vBulletin Solutions, Inc.
Рейтинг@Mail.ru