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

@Zohan1234567 · Регистрация: 09.07.2016

Студворк — интернет-сервис помощи студентам

ПОМОГИТЕ ПОЖАЛУЙСТА РЕШИТЬ ЗАДАЧУ:

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);  
}

MrGluck · 16.11.2016, 09:43

Много текста. Конкретизируйте задачу и участок кода, который некорректно работает. Повысите шансы на ответ.

@Mathist · 16.11.2016, 13:44

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);
}

@Mr.X · 16.11.2016, 23:40

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
}

Новые блоги и статьи Все статьи Все блоги /
Создание Single Page Application на фреймах krapotkin 16.11.2025 Статья исключительно для начинающих. Подходы оригинальностью не блещут. В век Веб все очень привыкли к дизайну Single-Page-Application . Быстренько разберем подход "на фреймах". Мы делаем одну. . .	Создание Single Page Application на фреймах krapotkin 16.11.2025 Статья исключительно для начинающих. Подходы оригинальностью не блещут. В век Веб все очень привыкли к дизайну Single-Page-Application . Быстренько разберем подход "на фреймах". Мы делаем одну. . .	Фото: Daniel Greenwood kumehtar 13.11.2025	Расскажи мне о Мире, бродяга kumehtar 12.11.2025 — Расскажи мне о Мире, бродяга, Ты же видел моря и метели. Как сменялись короны и стяги, Как эпохи стрелою летели. - Этот мир — это крылья и горы, Снег и пламя, любовь и тревоги, И бескрайние. . .	PowerShell Snippets iNNOKENTIY21 11.11.2025 Модуль PowerShell 5. 1+ : Snippets. psm1 У меня модуль расположен в пользовательской папке модулей, по умолчанию: \Documents\WindowsPowerShell\Modules\Snippets\ А в самом низу файла-профиля. . .
PowerShell и онлайн сервисы. Валюта (floatrates.com руб.) iNNOKENTIY21 11.11.2025 PowerShell функция floatrates-rub Примеры вызова: # Указанная валюта 'EUR' floatrates-rub -Code 'EUR' # Список имеющихся кодов валют floatrates-rub -Available function floatrates-rub {	PowerShell и онлайн сервисы. Погода (RP5.ru) iNNOKENTIY21 11.11.2025 PowerShell функция Get-WeatherRP5rss для получения погоды с сервиса RP5 Примеры вызова Get-WeatherRP5rss с указанием id 5484 — Москва (восток, Измайлово) и переносом строки:. . .	PowerShell и онлайн сервисы. Погода (wttr) iNNOKENTIY21 11.11.2025 PowerShell Функция для получения погоды с сервиса wttr Примеры вызова: Погода в городе Омск с прогнозом на день, можно изменить прогноз на более дней, для этого надо поменять запрос:. . .	PowerShell и онлайн сервисы. Валюта (ЦБР) iNNOKENTIY21 11.11.2025 # Получение курса валют function cbr (] $Valutes = @('USD', 'EUR', 'CNY')) { $url = 'https:/ / www. cbr-xml-daily. ru/ daily_json. js' $data = Invoke-RestMethod -Uri $url $esc = 27 . . .	И решил я переделать этот ноут в машину для распределенных вычислений Programma_Boinc 09.11.2025 И решил я переделать этот ноут в машину для распределенных вычислений Всем привет. А вот мой компьютер, переделанный из ноутбука. Был у меня ноут асус 2011 года. Со временем корпус превратился. . .

MrGluck Форумчанин 8216 / 5047 / 1437 Регистрация: 29.11.2010 Сообщений: 13,453
	16.11.2016, 09:43
	Много текста. Конкретизируйте задачу и участок кода, который некорректно работает. Повысите шансы на ответ. 0

Опции темы