Форум программистов, компьютерный форум CyberForum.ru

Ввод строки типа {a,b,c,d,f,{a,b,c,f},g,h,j}, исправить код - C++

Войти
Регистрация
Восстановить пароль
Другие темы раздела
C++ Нужно написать программу со строками http://www.cyberforum.ru/cpp-beginners/thread666360.html
Пожалуйста помогите написать программу, которая будет подсчитывать количество заглавных букв в строке, введенной с клавиатуры. e. выполнить пункты a и b на оценку 4 балла. f. реализовать меню пользователя, состоящее как минимум из 4-х пунктов: a. ввод данных; b. обработка данных; c. вывод результата на экран; d. выход. g. Для корректной работы меню организовать промежуточное хранение...
C++ Сумма ряда до точность E Четвёртый член ряда равен 0.001411 (можете проверить запустив программу) Вопрос: почему не срабатывает строчка (последняя) if(E<b) printf("Sum ryada do tochnosty %f ravna: %f\n", E, w); Когда 0.0001<0.001411? #include <iostream> #include <stdio.h> #include <math.h> using namespace std; int function(); http://www.cyberforum.ru/cpp-beginners/thread666344.html
Обьясните, пожалуйста, строчки C++
CRect rect; GetWindowRect(&rect); rect.OffsetRect(20,20); if (pic_wnd) delete pic_wnd; pic_wnd = new CPicWnd; pic_wnd->some = this; pic_wnd->CreateEx(NULL, "", "", WS_VISIBLE|WS_OVERLAPPEDWINDOW, rect, this, 0);
Реализовать класс Account, представляющий собой банковский счет C++
Б15.12 Реализовать класс Account , представляющий собой банковский счет. В классе должны быть реализованы 4 поля: фамилия владельца, номер счета, процент начисления и сумма в рублях. Необходимо выполнять следующие операции: сменить владельца счета, снять некоторую сумму со счета, положить деньги на счет, начислить проценты, перевести сумму в доллары, перевести сумму в евро, ...
C++ Компилятор и исполняющая среда CUDA http://www.cyberforum.ru/cpp-beginners/thread666324.html
Помогите разобраться... что не так?? Подскажите.. Должно получиться как на первом скрине
C++ Для заданного числа найти не превышающие его дружественные Написать программу, которая для заданного натурального числа N находит, не превышающие это число дружественные. подробнее

Показать сообщение отдельно
Mr.X
Эксперт С++
3042 / 1687 / 265
Регистрация: 03.05.2010
Сообщений: 3,867
13.10.2012, 08:26     Ввод строки типа {a,b,c,d,f,{a,b,c,f},g,h,j}, исправить код
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
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
/////////////////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <cctype>
#include <functional>
#include <iostream>
#include <set>
#include <string>
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::string         T_str;
typedef T_str::size_type    T_pos;
/////////////////////////////////////////////////////////////////////////////////////////
class  T_elem;
/////////////////////////////////////////////////////////////////////////////////////////
typedef T_elem*             T_elem_p;
/////////////////////////////////////////////////////////////////////////////////////////
struct T_elem_p_compare
{
    bool  operator() 
        (
            const T_elem_p&     L_elem_p,
            const T_elem_p&     R_elem_p
        );
};
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::set<T_elem_p, T_elem_p_compare>  T_stand_elem_p_set;
/////////////////////////////////////////////////////////////////////////////////////////
class  T_my_elem_p_set
{
    //-----------------------------------------------------------------------------------
    static const char   BEGIN_SYMB  =   '{';
    static const char   END_SYMB    =   '}';
    static const char   COMMA_SYMB  =   ',';
    //-----------------------------------------------------------------------------------
    T_stand_elem_p_set    stand_elem_p_set_;
    //-----------------------------------------------------------------------------------
public:
    //-----------------------------------------------------------------------------------
    T_my_elem_p_set
        ( 
            const T_str&    s,
            T_pos&          pos
        )
    {
        bool    bool_res    =   successfully_read_begin_symb(s, pos);
 
        if( bool_res )
        {
            while   (
                            successfully_add_elem           (s, pos)
                        &&  successfully_read_comma_symb    (s, pos)
                    );
 
            bool_res    =   successfully_read_end_symb(s, pos);
        }
        if( !bool_res )
        {
            throw   (
                        std::invalid_argument("Bad string.")
                    );
        }
    }
    //-----------------------------------------------------------------------------------
    void  print()                                       const;
    //-----------------------------------------------------------------------------------
    const T_stand_elem_p_set&  get_stand_elem_p_set()   const
    {
        return  stand_elem_p_set_;
    }    
    //-----------------------------------------------------------------------------------
private:
    //-----------------------------------------------------------------------------------
    static bool  successfully_read_begin_symb
        ( 
            const T_str&    s,
            T_pos&          pos
        )
    {
        return  successfully_read_symb
                    (
                        BEGIN_SYMB,
                        s,
                        pos
                    );
    }
    //-----------------------------------------------------------------------------------
    bool  successfully_add_elem
        ( 
            const T_str&    s,
            T_pos&          pos
        );
    //-----------------------------------------------------------------------------------
    static bool  successfully_read_comma_symb
        ( 
            const T_str&    s,
            T_pos&          pos
        )
    {
        return  successfully_read_symb
                    (
                        COMMA_SYMB,
                        s,
                        pos
                    );    
    }
    //-----------------------------------------------------------------------------------
    static bool  successfully_read_end_symb
        ( 
            const T_str&    s,
            T_pos&          pos
        )
    {
        return  successfully_read_symb
                    (
                        END_SYMB,
                        s,
                        pos
                    );    
    }
    //-----------------------------------------------------------------------------------
    static bool  successfully_read_symb
        (
            char            symb,
            const T_str&    s,
            T_pos&          pos
        )
    {
        bool    bool_res    =       pos_is_correct(s, pos)
                                &&  s[pos]  ==  symb;
 
        if( bool_res )
        {
            ++pos;
        }
 
        return  bool_res;
    }
    //-----------------------------------------------------------------------------------
    static bool  pos_is_correct 
        (
            const T_str&    s,
            T_pos&          pos
        ) 
    {
        return  pos < s.size();
    }
    //-----------------------------------------------------------------------------------
};
/////////////////////////////////////////////////////////////////////////////////////////
class  T_elem
{
    friend struct       T_elem_compare;
    //-----------------------------------------------------------------------------------
    bool                is_symb_;
    char                symb_;
    T_my_elem_p_set*    set_p_;
    //-----------------------------------------------------------------------------------
public:
    //-----------------------------------------------------------------------------------
    T_elem
        ( 
            const T_str&    s,
            T_pos&          pos,
            bool            is_symb
        )
        :
        is_symb_( is_symb )
    {
        if( is_symb_ )
        {
            symb_   =   s[pos];
            set_p_  =   0;
            ++pos;
        }
        else
        {
            symb_   =   0;
            set_p_  =   new T_my_elem_p_set(s, pos);
        }
    }
    //-----------------------------------------------------------------------------------
    void  print()           const
    {
        if( is_symb_ )
        {
            std::cout   <<  symb_
                        <<  ' ';
        }
        else
        {
            set_p_->print();
        }
    }
    //-----------------------------------------------------------------------------------
};
/////////////////////////////////////////////////////////////////////////////////////////
struct  T_elem_compare
{
    bool  operator() 
        (
            const T_elem&  L,
            const T_elem&  R
        )
    {
        //Если один множество, а другой символ.
        if  ( 
                    L.is_symb_
                !=  R.is_symb_
            )
        {
            return  L.is_symb_;
        }
 
        //Если оба символы.
        if( L.is_symb_ )
        {
            return  L.symb_   <   R.symb_;
        }
        
        //Если оба множества.
        return  std::lexicographical_compare
                    (
                        L.set_p_->get_stand_elem_p_set().begin  (),
                        L.set_p_->get_stand_elem_p_set().end    (),
                        R.set_p_->get_stand_elem_p_set().begin  (),
                        R.set_p_->get_stand_elem_p_set().end    (),
                        T_elem_p_compare                        ()
                    );
    }
};
/////////////////////////////////////////////////////////////////////////////////////////
bool  T_elem_p_compare::operator()
    (
        const T_elem_p&     L_elem_p,
        const T_elem_p&     R_elem_p
    )
{
    T_elem_compare  elem_compare;
    return  elem_compare
                (
                    *L_elem_p,
                    *R_elem_p
                );
}
/////////////////////////////////////////////////////////////////////////////////////////
//Реализация функций класса T_my_elem_p_set, содержащих тип T_elem.
void  T_my_elem_p_set::print()  const
{
    std::cout   <<  BEGIN_SYMB;
 
    std::for_each
        (
            stand_elem_p_set_.begin     (),
            stand_elem_p_set_.end       (),
            std::mem_fun                ( &T_elem::print )
        );
 
    std::cout   <<  END_SYMB; 
}
//---------------------------------------------------------------------------------------
bool  T_my_elem_p_set::successfully_add_elem
    ( 
        const T_str&    s,
        T_pos&          pos
    )
{
    bool    elem_is_symb    =   isalpha( s[pos] ) != 0;
    bool    elem_is_set     =   s[pos]  == BEGIN_SYMB;
 
    bool    bool_res    =       pos_is_correct  ( s, pos )
                            &&  (   
                                        elem_is_symb
                                    ||  elem_is_set
                                );
 
    if( bool_res )
    {
        stand_elem_p_set_.insert
            (
                new     T_elem
                            (
                                s, 
                                pos,
                                elem_is_symb
                            )
            );
    }
 
    return  bool_res;
}
/////////////////////////////////////////////////////////////////////////////////////////
int main()
{
    std::locale::global(std::locale(""));
 
    for(;;)
    {
        std::cout   <<  std::endl
                    <<  std::endl
                    <<  std::endl
                    <<  "Введите строку:"
                    <<  std::endl;
 
        T_str   s;
        T_pos   pos     =   0;
        getline(std::cin, s);
 
        try
        {
            T_my_elem_p_set     set
                                    ( 
                                        s,
                                        pos
                                    );
 
            if  (
                    pos != s.size() 
                )
            {
                throw
                    (
                        std::invalid_argument( "Bad string." )
                    );
            }
 
            std::cout   <<  "Создано множество:"
                        <<  std::endl;
 
            set.print();
        }
        catch(std::invalid_argument&  e)
        {
            std::cout   <<  e.what()
                        <<  std::endl;
        }
    }
}
 
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2017, vBulletin Solutions, Inc.
Рейтинг@Mail.ru