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

Структурированный в объектно-ориентированный - C++

Восстановить пароль Регистрация
 
 
Рейтинг: Рейтинг темы: голосов - 13, средняя оценка - 4.62
footbaler
1 / 1 / 0
Регистрация: 18.12.2010
Сообщений: 50
19.07.2011, 19:53     Структурированный в объектно-ориентированный #1
Доброго времени суток!
В чем собственно моя проблема. Есть задание курсовой роботы (миниатюры), есть исходник программы написанный мною (прилагаю). Но программу надо написать двумя способами, используя структурированный подход и объектно-ориентированный. Со структурированным я вроде справился, хотя если есть тут проблемы или вопросы просьба ткнуть носом. Как мне переделать программу во второй способ, кто что подскажет?
Заранее спасибо.
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
#include <iostream> 
using namespace std;
 
int E1, E2;
float r1=30.6, r2=3.25, r3=20.57;
 
float J2()
{
 return (E1/(r1+((r2*r3)/(r2+r3))))*(r3/(r2+r3))-(E2/(r2+(r1*r3/(r1+r3))));
}
 
float J3()
{
 return (E1/(r1+((r2*r3)/(r2+r3))))*(r3/(r2+r3))+(E2/(r2+(r1*r3/(r1+r3))))*(r1/(r1+r3));
}
 
float J1()
{
 return J2()+J3();
}
 
void main()
{
 cout<<"  Tablica zavicimosti J1,J2,J3 ot E1,E2  \n";
 cout<<"|----|----|-----------------------------|\n";
 cout<<"| E1 | E2 |     J2       J3       J1    \n";
 for(E1=10, E2=15; E1<=100, E2<=60; E1+=10, E2+=5)
 {
  cout<<"|----|----|-----------------------------|\n";
  cout<<"| "<<E1<<" | "<<E2<<" | "<<J2()<<"  "<<J3()<<"  "<<J1()<<"\n";
 }
 cout<<"|----|----|-----------------------------|\n";
 system("pause");
}
Миниатюры
Структурированный в объектно-ориентированный  
Similar
Эксперт
41792 / 34177 / 6122
Регистрация: 12.04.2006
Сообщений: 57,940
19.07.2011, 19:53     Структурированный в объектно-ориентированный
Посмотрите здесь:

объектно-ориентированный анализ,объектно-ориентированное проектирование C++
Определить структурированный тип, набор функций (в виде меню) для работы с массивом структур C++
Объектно-ориентированный C++ и другие языки C++
Объектно-ориентированный анализ и проектирование с примерами приложений C++
Дан ориентированный граф, нужно на выходе получить матрицу кратчайших путей C++
После регистрации реклама в сообщениях будет скрыта и будут доступны все возможности форума.
ValeryLaptev
Эксперт C++
1005 / 784 / 46
Регистрация: 30.04.2011
Сообщений: 1,595
19.07.2011, 20:16     Структурированный в объектно-ориентированный #2
footbaler, судя по тексту - нет ничего проще.
Возьми и помести свои функции (кроме main()) в класс.
footbaler
1 / 1 / 0
Регистрация: 18.12.2010
Сообщений: 50
19.07.2011, 20:18  [ТС]     Структурированный в объектно-ориентированный #3
Спасибо, я в принципе так и думал сделать, но решил подстраховаться.
ValeryLaptev
Эксперт C++
1005 / 784 / 46
Регистрация: 30.04.2011
Сообщений: 1,595
19.07.2011, 20:20     Структурированный в объектно-ориентированный #4
footbaler, не забудь объявить E1 и E2 полями класса.
кстати, константы r1, r2, r3 - либо тоже полями-переменными, либо полями-константами.
В последнем случае нужен конструктор со списком инициализации.
А если переменные, то просто конструктор с параметрами.
Jupiter
Каратель
Эксперт C++
6543 / 3963 / 226
Регистрация: 26.03.2010
Сообщений: 9,273
Записей в блоге: 1
Завершенные тесты: 2
19.07.2011, 21:36     Структурированный в объектно-ориентированный #5
Цитата Сообщение от footbaler Посмотреть сообщение
ткнуть носом
Цитата Сообщение от footbaler Посмотреть сообщение
void main()
Правильно писать
C++
1
int main()
, если у вас так работает, то это не значит что это сработает у других.
Ну и между оператоми принято ставить пробелы, анеписатьслитно, курсовая все таки, может кто-то и посмотрит кроме вас
footbaler
1 / 1 / 0
Регистрация: 18.12.2010
Сообщений: 50
19.07.2011, 22:13  [ТС]     Структурированный в объектно-ориентированный #6
Спасибо, все учел и у себя исправил!
footbaler
1 / 1 / 0
Регистрация: 18.12.2010
Сообщений: 50
22.08.2011, 22:18  [ТС]     Структурированный в объектно-ориентированный #7
Здравствуйте. Появилось еще несколько вопросов. Код в шапке оказался неверным, я его переделал, верный код ниже.
Собственно вопросы:
1) В коде я использовал printf, для того что бы в таблицах данные отображались на одном расстоянии. Но использовать его в C++ не правильно, как я понимаю. Как сделать правильно с помощью cout (или др.), получив тот же результат?
2)Повторюсь, если что еще неправильно в коде, просьба ткнуть носом.
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
#include <numeric>
#include <stdio.h>
#include <iostream>
using namespace std;
 
int E1, E2;
float r1=30.6, r2=3.25, r3=20.57;
 
float J2()
{
 return (E1/(r1+((r2*r3)/(r2+r3))))*(r3/(r2+r3))-(E2/(r2+(r1*r3/(r1+r3))));
}
 
float J3()
{
 return (E1/(r1+((r2*r3)/(r2+r3))))*(r3/(r2+r3))+(E2/(r2+(r1*r3/(r1+r3))))*(r1/(r1+r3));
}
 
float J1()
{
 return J2()+J3();
}
 
int main()
{
 int v;
 for(;;)
 {
  cout << "\n" <<
  "1. Tablica zavisimosti J1 ot E1 i E2" << "\n" <<
  "2. Tablica zavisimosti J2 ot E1 i E2" << "\n" <<
  "3. Tablica zavisimosti J3 ot E1 i E2" << "\n\n" <<
  "Dlya vivoda tablici vvedite 1-3, dlya vixoda - 4-...: ";
  cin >> v;
  if(v>=4)
  return 0;
  else
  system("cls");
  cout << "|---------------------------------------------------|\n";
  cout << "|       Tablica zavisimosti J" << v << " ot E1 i E2           |\n";
  cout << "|---|-----------------------------------------------|\n";
  cout << "|---|---------------------- E2 ---------------------|\n";
  cout << "| E1|      15   |      20   |     25    |     30    |\n";
  cout << "|---|-----------|-----------|-----------|-----------|\n";
  for(E1=10; E1<=100; E1+=10)
  {
   printf ( "|%3d|", E1);
   for(E2=15; E2<=30; E2+=5)
   {
    switch (v)
    {
     case 1: printf (" %10lf|", J1()); break;
     case 2: printf (" %10lf|", J2()); break;
     case 3: printf (" %10lf|", J3()); break;
    }
   }
   cout << "\n|---|-----------|-----------|-----------|-----------|\n";
  }
 }
}
Заранее спасибо.
Jupiter
Каратель
Эксперт C++
6543 / 3963 / 226
Регистрация: 26.03.2010
Сообщений: 9,273
Записей в блоге: 1
Завершенные тесты: 2
22.08.2011, 22:36     Структурированный в объектно-ориентированный #8
Флаги форматирования и манипуляторы
rangerx
1908 / 1517 / 139
Регистрация: 31.05.2009
Сообщений: 2,876
23.08.2011, 00:16     Структурированный в объектно-ориентированный #9
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
#include <cstdlib>
#include <iostream>
#include <iomanip>
 
int E1, E2;
const float r1 = 30.6, r2 = 3.25, r3 = 20.57;
 
float J2()
{
    return (E1/(r1+((r2*r3)/(r2+r3))))*(r3/(r2+r3))-(E2/(r2+(r1*r3/(r1+r3))));
}
 
float J3()
{
    return (E1/(r1+((r2*r3)/(r2+r3))))*(r3/(r2+r3))+(E2/(r2+(r1*r3/(r1+r3))))*(r1/(r1+r3));
}
 
float J1()
{
    return J2()+J3();
}
 
int main()
{
    int v;
 
    for(;;)
    {
        std::cout << "\n1. Tablica zavisimosti J1 ot E1 i E2\n"
                     "2. Tablica zavisimosti J2 ot E1 i E2\n"
                     "3. Tablica zavisimosti J3 ot E1 i E2\n"
                     "-> ";
                     //"\nDlya vivoda tablici vvedite 1-3, dlya vixoda - 4-...: ";
 
        if( !(std::cin >> v) || (v < 1) || (v > 3) ) return 0;
 
        std::system("cls");
        std::cout << "|---------------------------------------------------|\n"
                     "|       Tablica zavisimosti J" << v << " ot E1 i E2           |\n"
                     "|---|-----------------------------------------------|\n"
                     "|---|---------------------- E2 ---------------------|\n"
                     "| E1|      15   |      20   |     25    |     30    |\n"
                     "|---|-----------|-----------|-----------|-----------|\n";
 
 
 
        std::cout.setf(std::ios::fixed);
        for(E1 = 10; E1 <= 100; E1+= 10)
        {
            std::cout << '|' << std::setw(3) << E1 << '|';
 
            for(E2 = 15; E2 <= 30; E2+= 5)
            {
                std::cout.width(11);
                switch(v)
                {
                    case 1: std::cout << J1() << '|'; break;
                    case 2: std::cout << J2() << '|'; break;
                    case 3: std::cout << J3() << '|'; break;
                }
            }
 
            std::cout << "\n|---|-----------|-----------|-----------|-----------|\n";
        }
    }
}
ValeryS
Модератор
6377 / 4843 / 442
Регистрация: 14.02.2011
Сообщений: 16,048
23.08.2011, 01:16     Структурированный в объектно-ориентированный #10
Цитата Сообщение от footbaler Посмотреть сообщение
Со структурированным я вроде справился, хотя если есть тут проблемы или вопросы просьба ткнуть носом.
Цитата Сообщение от footbaler Посмотреть сообщение
int E1, E2;
float r1=30.6, r2=3.25, r3=20.57;
глобальные переменные не есть гуд.
посему переменные нужно описывать в main и передавать функциям
а для ООП (если не просто скинуть лабу)
создать класс источников питания (источник напряжения,источник тока)
где будет напряжение эдс, внутреннее сопротивление, на будущее паразитная емкость
класс сопротивлений
где будет активное сопротивление , на будущее реактивное
все это породить от одного абстрактного класса радио_элементы
потом туда можно будет запихивать все элементы которые знаешь
footbaler
1 / 1 / 0
Регистрация: 18.12.2010
Сообщений: 50
23.08.2011, 02:17  [ТС]     Структурированный в объектно-ориентированный #11
ValeryS, Спасибо за подсказки. Переменные объявил в main, и функциям передал. Я бы и сразу так сделал, но мне хотелось минимализма... что поделать, я только учусь. На счет ООП... мне бы пока по заданию сделать, на будущее будем писать позже :-)

Цитата Сообщение от Maxwe11 Посмотреть сообщение
Флаги форматирования и манипуляторы
Спасибо за ссылку. Я банально не знал как в поиске найти, не знал какой запрос писать :-)

rangerx, Спасибо и вам, все проще в коде стало.
Mr.X
Эксперт С++
 Аватар для Mr.X
2802 / 1578 / 247
Регистрация: 03.05.2010
Сообщений: 3,666
24.08.2011, 08:17     Структурированный в объектно-ориентированный #12
Что-то ваша программа как-то непонятно считает.
При E1 = 10 В и E2 = 15 В она дает следующие значения токов:
J1 = 0.129 А
J2 = -0.706 А
J3 = 0.835 А.
Если принять для всех токов положительное направление снизу вверх, то по закону Ома для участка цепи, содержащей ЭДС, для ветви с r1 имеем:
J1 = (U + E1) / r1,
откуда
J1*r1 = U + E1
U = J1*r1 – E1 = 0.129 * 30.6 – 10 = -6.05 В

При таком U между узлами схемы остальные токи должны быть равны:
J2 = U / r2 = -6.05 / 3.25 = -1.86 A (у вас -0.706 А)
J3 = (U + E2) / r3 = (-6.05 + 15) / 20.57 = 0.435 A (у вас 0.835 А).
footbaler
1 / 1 / 0
Регистрация: 18.12.2010
Сообщений: 50
24.08.2011, 19:04  [ТС]     Структурированный в объектно-ориентированный #13
Mr.X, ну в условии написаны выражения J2, J3 и J1, по ним программа и считает, причем J1 = J2 + J3. т.е. прежде чем найти J1, находит значения J2 и J3. И вот из этого
Цитата Сообщение от Mr.X Посмотреть сообщение
При E1 = 10 В и E2 = 15 В она дает следующие значения токов:
J1 = 0.129 А
J2 = -0.706 А
J3 = 0.835 А.
получаем, что J1 = J2 + J3 = -0.706 А + 0.835 А = 0.129А.
Сыроежка
Заблокирован
24.08.2011, 20:47     Структурированный в объектно-ориентированный #14
Структурированный подход не есть противопоставление объектно-ориентированному. Так что сама постановка вопроса некорректная! Объектно=ориентированные программирование включает в себя структурированное программирование.
footbaler
1 / 1 / 0
Регистрация: 18.12.2010
Сообщений: 50
24.08.2011, 21:13  [ТС]     Структурированный в объектно-ориентированный #15
Ну возможно и так. Суть мое курсовой - написать программу 2-мя способами, используя структурированный подход, и объектно-ориентированный. Потом сделать выводы, что ООП - это круто и привести аргументы по этому поводу.
Сыроежка
Заблокирован
24.08.2011, 21:39     Структурированный в объектно-ориентированный #16
Цитата Сообщение от footbaler Посмотреть сообщение
Ну возможно и так. Суть мое курсовой - написать программу 2-мя способами, используя структурированный подход, и объектно-ориентированный. Потом сделать выводы, что ООП - это круто и привести аргументы по этому поводу.
Правильно было бы сформулировать задачу так: написать программу, используя процедурный подход и объектно-ориентированный.
footbaler
1 / 1 / 0
Регистрация: 18.12.2010
Сообщений: 50
24.08.2011, 21:51  [ТС]     Структурированный в объектно-ориентированный #17
Сыроежка, видимо, мои количество знаний и грамотность в программировании, не позволили мне выразиться яснее.
ValeryLaptev
Эксперт C++
1005 / 784 / 46
Регистрация: 30.04.2011
Сообщений: 1,595
24.08.2011, 22:52     Структурированный в объектно-ориентированный #18
Цитата Сообщение от footbaler Посмотреть сообщение
Ну возможно и так. Суть мое курсовой - написать программу 2-мя способами, используя структурированный подход, и объектно-ориентированный. Потом сделать выводы, что ООП - это круто и привести аргументы по этому поводу.
Ну, в столь простой работе преимущества ООП превращаются в недостатки...
Mr.X
Эксперт С++
 Аватар для Mr.X
2802 / 1578 / 247
Регистрация: 03.05.2010
Сообщений: 3,666
24.08.2011, 23:21     Структурированный в объектно-ориентированный #19
Цитата Сообщение от footbaler Посмотреть сообщение
Mr.X, ну в условии написаны выражения J2, J3 и J1, по ним программа и считает, причем J1 = J2 + J3. т.е. прежде чем найти J1, находит значения J2 и J3. И вот из этого
При E1 = 10 В и E2 = 15 В она дает следующие значения токов:
J1 = 0.129 А
J2 = -0.706 А
J3 = 0.835 А.
получаем, что J1 = J2 + J3 = -0.706 А + 0.835 А = 0.129А.
Ну дак это же противоречит законам природы, в частности закону Ома.
Да и вообще для курсовой такой сугубо частный случай - это узковато.
Моя программа рассчитывает токи для паралллельного соединения любого количества ветвей,
содержащих ЭДС и сопротивления. Далее она позволяет произвольно выбрать любое подмножество
ветвей схемы, назначить для каждой выбранной ветви начальное и конечное значения ЭДС,
а также шаг, и протабулировать значения токов для всех сочетаний пошаговых сдвигов ЭДС
в каждой ветви. Разумеется, при большом количестве токов и ЭДС таблица не поместится
в консоли, но в файл любую такую таблицу вывести возможно.
Вот программа:
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
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
/////////////////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <iomanip>
#include <iostream>
#include <numeric>
#include <set>
#include <sstream>
#include <string>
#include <vector>
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::vector<double>       T_el_values;
typedef T_el_values               T_row;
typedef std::vector<T_el_values>  T_matr;
typedef std::string               T_str;
typedef std::vector<int>          T_indexes;
/////////////////////////////////////////////////////////////////////////////////////////
struct  T_E_for_table
{
    int     ind_;
    double  val_begin_;
    double  val_end_;
    double  val_step_;    
    double  val_cur_;    
};
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::vector<T_E_for_table>  T_E_for_table_vect;
/////////////////////////////////////////////////////////////////////////////////////////
class  T_parallel_circuits
{
    T_el_values  R_values_;
    T_el_values  E_values_;
    //-----------------------------------------------------------------------------------    
public:
    //-----------------------------------------------------------------------------------
    int  get_dim() const
    {
        return  R_values_.size();
    }
    //-----------------------------------------------------------------------------------
    void  add_parallel_R_E
        (
            double  R,
            double  E
        )
    {
        R_values_.push_back(R);
        E_values_.push_back(E);
    }
    //-----------------------------------------------------------------------------------
    T_el_values  get_I_values()
    {       
        T_matr  res_I_partial_for_I_ind_E_ind( get_dim(), T_el_values( get_dim() ) );
 
        for(int E_ind = 0; E_ind < get_dim(); ++E_ind)
        {
            if(E_values_[E_ind] == 0)  continue;
 
            //Вычисляем частичный ток в элементе с индексом E_ind от находящегося в нем ЭДС
            //E_values_[E_ind] (направление тока совпадает с направлением E_values_[E_ind]):
            res_I_partial_for_I_ind_E_ind[E_ind][E_ind] 
                = E_values_[E_ind] / get_R_total_for_E_ind(E_ind);
 
            //Вычисляем напряжение между узлами A и B для E_values_[E_ind]:
            double  res_U_for_E_ind
                = res_I_partial_for_I_ind_E_ind[E_ind][E_ind] * R_values_[E_ind]
                  - E_values_[E_ind];
 
            //Вычисляем остальные частичные токи, порожденные ЭДС E_values_[E_ind]:
            for(int  I_ind = 0; I_ind < get_dim(); ++I_ind)
            {
                if(I_ind == E_ind) continue;
                res_I_partial_for_I_ind_E_ind[I_ind][E_ind] 
                    = res_U_for_E_ind / R_values_[I_ind];
            }
        }
        //Утверждение. Частичные токи для каждой ветви от каждой ЭДС вычислены.
        //Вычисляем полные токи для всех ветвей цепи.       
        struct  T_accumulate_I_partial
        {
            T_el_values::value_type  operator() (T_matr::value_type  I_partial_row)
            {
                return
                std::accumulate
                    (
                        I_partial_row.begin(),
                        I_partial_row.end(),
                        T_el_values::value_type()
                    );
            }
        };
        
        T_el_values  res_I_for_I_ind;
        std::transform
            (
                res_I_partial_for_I_ind_E_ind.begin(),
                res_I_partial_for_I_ind_E_ind.end(),
                std::back_inserter(res_I_for_I_ind),
                T_accumulate_I_partial()
            );
 
        return  res_I_for_I_ind;
    }
    //-----------------------------------------------------------------------------------
    T_el_values  get_new_I_values_for_new_E_values
        (
            const T_E_for_table_vect&  E_for_table_vect
        )
    {
        for(T_E_for_table_vect::const_iterator  E_for_table_it = E_for_table_vect.begin();
            E_for_table_it != E_for_table_vect.end(); ++E_for_table_it)
        {
            E_values_[E_for_table_it->ind_] = E_for_table_it->val_cur_;
        }
        return  get_I_values();
    }
    //-----------------------------------------------------------------------------------
private:
    //-----------------------------------------------------------------------------------
    static void  add_R_parallel(double&  R1, double  R2)
    {
        if(   R1 == 0
           || R2 == 0 )
        {
            R1 = 0;
        }
        else
        {
            double  G1 = 1 / R1 + 1 / R2;
            R1 = 1 / G1;
        }        
    }
    //-----------------------------------------------------------------------------------
    double  get_R_total_for_E_ind(int  E_ind) const
    {        
        double  R_parallel_res = 0;
        for(size_t  i = 0; i < R_values_.size(); ++i)
        {
            if(i == E_ind) continue;
            if(R_parallel_res == 0)
            {
                R_parallel_res = R_values_[i];
            }
            else
            {
                add_R_parallel(R_parallel_res, R_values_[i]);
            }            
        }
        return  R_values_[E_ind] + R_parallel_res;
    }
    //-----------------------------------------------------------------------------------
};
/////////////////////////////////////////////////////////////////////////////////////////
void  print_line
    (
        char  symb,
        int   len
    )
{
    for(int  i = 0; i < len; ++i)
    {
        std::cout << symb;
    }
    std::cout << std::endl;
}
/////////////////////////////////////////////////////////////////////////////////////////
void  print_line(int  len)
{
    print_line('-', len);
}
/////////////////////////////////////////////////////////////////////////////////////////
void  print_bold_line(int  len)
{
    print_line('=', len);
}
/////////////////////////////////////////////////////////////////////////////////////////
void  print_I_values_table
    (
        T_parallel_circuits&  parallel_circuits,
        T_E_for_table_vect    E_for_table_vect
    )
{
    const int  TABLE_W  = 79;
    const int  word_w   = TABLE_W / ( E_for_table_vect.size() + parallel_circuits.get_dim() );
    print_bold_line(TABLE_W);
 
    std::cout << '\t'
              << "Таблица зависимости токов от значений ЭДС ";
    for(size_t  i = 0; i < E_for_table_vect.size(); ++i)
    {        
        std::cout << "E"
                  << E_for_table_vect[i].ind_ + 1
                  << (i == E_for_table_vect.size() - 1 ? "" : ", ");
    }
    std::cout << std::endl;
    print_bold_line(TABLE_W);
 
    for(size_t  i = 0; i < E_for_table_vect.size(); ++i)
    {
        std::ostringstream  sout;
        sout << "E"
             << (E_for_table_vect[i].ind_ + 1);
 
        std::cout << std::setw(word_w)
                  << sout.str();
    }
 
    for(int  j = 0; j < parallel_circuits.get_dim(); ++j)
    {
        std::ostringstream  sout;
        sout << "J"
             << j + 1;
 
        std::cout << std::setw(word_w)
                  << sout.str();
    }
    std::cout << std::endl;
    print_bold_line(TABLE_W);
 
    for(;;)
    {
        T_E_for_table_vect::reverse_iterator  E_rev_for_inc_it = E_for_table_vect.rbegin();
        //Пробегаемся по вектору E_for_table_vect и выводим в строку таблицы 
        //текущие значения ЭДС.
        for(T_E_for_table_vect::const_iterator  E_it = E_for_table_vect.begin();
            E_it != E_for_table_vect.end(); ++E_it)
        {
            std::cout << std::fixed
                      << std::setprecision(3)
                      << std::setw(word_w)
                      << E_it->val_cur_;
        }
 
        T_el_values  I_values 
            = parallel_circuits.get_new_I_values_for_new_E_values(E_for_table_vect);
 
        //Выводим в строку таблицы значения токов.
        for(T_el_values::const_iterator  I_val_it = I_values.begin();
            I_val_it != I_values.end(); ++I_val_it)
        {
             std::cout << std::setw(word_w)
                      << *I_val_it;       
        }
        std::cout << std::endl;
 
        for(;;)
        {
            E_rev_for_inc_it->val_cur_ += E_rev_for_inc_it->val_step_;
            //Если значение ЭДС инкрементируемого индекса не вышло за конечное, то:
            if(E_rev_for_inc_it->val_cur_ - E_rev_for_inc_it->val_end_ 
               <= E_rev_for_inc_it->val_step_ / 3)
            {
                break;
            }
            
            print_line(TABLE_W);
            //Передвигаемся на один индекс влево.
            ++E_rev_for_inc_it;
            //Если вышли за пределы вектора, то выйти из функции:
            if(E_rev_for_inc_it == E_for_table_vect.rend())  return;
 
            //Возвращаем значение ЭДС инкрементируемого индекса и следующих в векторе
            //в начальное.
            for(T_E_for_table_vect::reverse_iterator  E_it = E_for_table_vect.rbegin();
                E_it != E_rev_for_inc_it; ++E_it)
            {
                E_it->val_cur_ = E_it->val_begin_;
            }           
        }//for       
    }//for
}
/////////////////////////////////////////////////////////////////////////////////////////
void  input_R_E_data(T_parallel_circuits&  parallel_circuits)
{
    const int  COMPONENTS_TOTAL_MIN  = 2;
    int        components_total      = 0;
    do
    {
        std::cout << "Введите количество ветвей электрической цепи, соединенных параллельно"
                  << std::endl
                  << "в узлах A и B (>= "
                  << COMPONENTS_TOTAL_MIN
                  << "): ";
        
        std::cin >> components_total;    
    }while(components_total < COMPONENTS_TOTAL_MIN);
 
    std::cout << std::endl
              << "Для "
              << components_total
              << " ветвей цепи введите их сопротивления и ЭДС" 
              << std::endl
              << "(положительным направлением для ЭДС и токов считаем направление "
              << std::endl
              << "от узла A к узлу B):"
              << std::endl;
    
    for(int  i = 0; i < components_total; ++i)
    {
        std::cout << std::endl
                  << '\t'
                  << "ветвь #"
                  << i + 1
                  << ":"
                  << std::endl
                  << '\t'
                  << '\t'
                  << 'R'
                  << i + 1
                  << " = ";
 
        double  R = 0;
        std::cin >> R;
 
        std::cout << '\t'
                  << '\t'
                  << 'E'
                  << i + 1
                  << " = ";
 
        double  E = 0;
        std::cin >> E;
 
        parallel_circuits.add_parallel_R_E(R, E);
    }
}
/////////////////////////////////////////////////////////////////////////////////////////
void  input_E_data_for_table
    (
        const T_parallel_circuits&  parallel_circuits,
        T_E_for_table_vect&         E_for_table_vect
    )
{
    int  dim = parallel_circuits.get_dim();  
 
    int  E_tab_indexes_total = 0;
    do
    {
        std::cout << "Введите количество изменяемых ЭДС в таблице токов: ";
        std::cin >> E_tab_indexes_total;
    }while(    E_tab_indexes_total < 1
            || E_tab_indexes_total > dim);  
 
    typedef std::set<int>  T_E_indexes;
    T_E_indexes  E_indexes;
    std::cout << std::endl
              << "Для построения таблицы токов введите данные для каждого"
              << std::endl<<"из "
              << E_tab_indexes_total              
              << " табулируемых значений ЭДС:"
              << std::endl;
 
    for(int  i = 0; ; ++i)
    {
        T_E_for_table  E_for_table;
        std::cout << std::endl;
 
        do
        {
            std::cout << '\t'
                      << "номер ветви (начиная с 1):"
                      << '\t';
 
            int  E_i_ind_1 = 0;
            std::cin >> E_i_ind_1;
            E_for_table.ind_ = E_i_ind_1 - 1;        
        }while(    E_for_table.ind_ < 0
                || E_for_table.ind_ >= dim
                || E_indexes.count(E_for_table.ind_) );
 
        E_indexes.insert(E_for_table.ind_);
 
        std::cout << '\t'
                  << "начальное значение ЭДС:"
                  << '\t'
                  << '\t';
        
        std::cin >> E_for_table.val_begin_;
        E_for_table.val_cur_ = E_for_table.val_begin_;
        
        do
        {
            std::cout << '\t'
                      << "конечное значение ЭДС:"
                      << '\t'
                      << '\t';
            
            std::cin >> E_for_table.val_end_;
        }while(E_for_table.val_end_ < E_for_table.val_begin_);        
 
        do
        {
            std::cout << '\t'
                      << "шаг табуляции ЭДС:"
                      << '\t'
                      << '\t';
            
            std::cin >> E_for_table.val_step_;        
        }while(E_for_table.val_step_ <= 0);
 
        E_for_table_vect.push_back(E_for_table);
 
        if(E_indexes.size() == E_tab_indexes_total)
        {
            break;
        }
    }//for
}
/////////////////////////////////////////////////////////////////////////////////////////
int main()
{
    std::locale::global(std::locale(""));
 
    T_parallel_circuits  parallel_circuits;
    input_R_E_data(parallel_circuits);
 
    T_el_values  res_I_values = parallel_circuits.get_I_values();
    std::cout << std::endl
              << "Значения токов в " 
              << res_I_values.size()
              <<" ветвях заданной цепи (в направлении от узла A к узлу B):"
              << std::endl;
 
    for(size_t  i = 0; i < res_I_values.size(); ++i)
    {
        std::cout << '\t'
                  << "J"
                  << i + 1
                  << " = "
                  << std::fixed
                  << std::setprecision(3) 
                  << res_I_values[i]
                  << std::endl;
    }    
 
    std::cout << std::endl
              << std::endl
              << std::endl
              << std::endl;
 
    T_E_for_table_vect  E_for_table_vect;
    input_E_data_for_table
        (
            parallel_circuits,
            E_for_table_vect
        );
 
    std::cout << std::endl
              << std::endl
              << std::endl
              << std::endl;
 
    print_I_values_table(parallel_circuits, E_for_table_vect);
}
MoreAnswers
Эксперт
37091 / 29110 / 5898
Регистрация: 17.06.2006
Сообщений: 43,301
25.08.2011, 01:24     Структурированный в объектно-ориентированный
Еще ссылки по теме:

Задача на ориентированный граф C++
Ориентированный граф. Получить из списка рёбер матрицу смежности C++
C++ Объектно-ориентированный аналог телефонного справочника: поиск по нескольким параметрам одновременно

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

Или воспользуйтесь поиском по форуму:
footbaler
1 / 1 / 0
Регистрация: 18.12.2010
Сообщений: 50
25.08.2011, 01:24  [ТС]     Структурированный в объектно-ориентированный #20
Цитата Сообщение от ValeryLaptev Посмотреть сообщение
Ну, в столь простой работе преимущества ООП превращаются в недостатки...
Можно подробнее?
Цитата Сообщение от Mr.X Посмотреть сообщение
Ну дак это же противоречит законам природы, в частности закону Ома.
Да и вообще для курсовой такой сугубо частный случай - это узковато.
То есть, это ошибка в курсовой или я не так что то делаю? И что вы мне предлагаете сделать?
И да, спасибо за исходник вашей программы. Правда ругается здесь:
C++
1
2
3
4
5
6
7
8
 T_el_values  res_I_for_I_ind;
        std::transform
            (
                res_I_partial_for_I_ind_E_ind.begin(),
                res_I_partial_for_I_ind_E_ind.end(),
                std::back_inserter(res_I_for_I_ind),
                T_accumulate_I_partial()
            );
на строчку
C++
1
std::back_inserter(res_I_for_I_ind)
, говорит - is not a member of 'std' и identifier not found.
Yandex
Объявления
25.08.2011, 01:24     Структурированный в объектно-ориентированный
Ответ Создать тему
Опции темы

Текущее время: 09:29. Часовой пояс GMT +3.
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2016, vBulletin Solutions, Inc.
Рейтинг@Mail.ru