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

С++ для начинающих

Войти
Регистрация
Восстановить пароль
 
 
Рейтинг: Рейтинг темы: голосов - 13, средняя оценка - 4.62
footbaler
1 / 1 / 0
Регистрация: 18.12.2010
Сообщений: 50
#1

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

19.07.2011, 19:53. Просмотров 1670. Ответов 31
Метки нет (Все метки)

Доброго времени суток!
В чем собственно моя проблема. Есть задание курсовой роботы (миниатюры), есть исходник программы написанный мною (прилагаю). Но программу надо написать двумя способами, используя структурированный подход и объектно-ориентированный. Со структурированным я вроде справился, хотя если есть тут проблемы или вопросы просьба ткнуть носом. Как мне переделать программу во второй способ, кто что подскажет?
Заранее спасибо.
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");
}
0
Миниатюры
Структурированный в объектно-ориентированный  
Similar
Эксперт
41792 / 34177 / 6122
Регистрация: 12.04.2006
Сообщений: 57,940
19.07.2011, 19:53
Здравствуйте! Я подобрал для вас темы с ответами на вопрос Структурированный в объектно-ориентированный (C++):

объектно-ориентированный анализ,объектно-ориентированное проектирование - C++
Прошу помочь построить диаграмму прециндентов и диаграмму классов,мне необходимо только начало диаграммы или хотя-бы какой-нибудь пример с...

Объектно-ориентированный C++ и другие языки - C++
Один мой знакомый посоветовал мне, для того чтобы лучше разобраться с объектно-ориентированной и библиотечно-шаблонной кухней C++ сперва...

Объектно-ориентированный анализ и проектирование с примерами приложений - C++
Стоит ли её читать, а то пролистал в середине кодов никаких нет один текст + немного картинок как из газеты? Добавлено через 41 минуту...

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

Задача на ориентированный граф - C++
Ребята, спасайте! обычно я прихожу сюда с недоделанным кодом/кодом в котором что-то неправильно работает, но тут времени совсем не...

Определить структурированный тип, набор функций (в виде меню) для работы с массивом структур - C++
Здравствуйте. Помогите пожалуйста решить задачу по структурам. на С++. Вот текст задачи: Определить структурированный тип, набор...

Надоела реклама? Зарегистрируйтесь и она исчезнет полностью.
Сыроежка
Заблокирован
24.08.2011, 21:39 #16
Цитата Сообщение от footbaler Посмотреть сообщение
Ну возможно и так. Суть мое курсовой - написать программу 2-мя способами, используя структурированный подход, и объектно-ориентированный. Потом сделать выводы, что ООП - это круто и привести аргументы по этому поводу.
Правильно было бы сформулировать задачу так: написать программу, используя процедурный подход и объектно-ориентированный.
0
footbaler
1 / 1 / 0
Регистрация: 18.12.2010
Сообщений: 50
24.08.2011, 21:51  [ТС] #17
Сыроежка, видимо, мои количество знаний и грамотность в программировании, не позволили мне выразиться яснее.
0
ValeryLaptev
Эксперт С++
1041 / 820 / 48
Регистрация: 30.04.2011
Сообщений: 1,659
24.08.2011, 22:52 #18
Цитата Сообщение от footbaler Посмотреть сообщение
Ну возможно и так. Суть мое курсовой - написать программу 2-мя способами, используя структурированный подход, и объектно-ориентированный. Потом сделать выводы, что ООП - это круто и привести аргументы по этому поводу.
Ну, в столь простой работе преимущества ООП превращаются в недостатки...
0
Mr.X
Эксперт С++
3049 / 1694 / 265
Регистрация: 03.05.2010
Сообщений: 3,867
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);
}
1
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.
0
Mr.X
Эксперт С++
3049 / 1694 / 265
Регистрация: 03.05.2010
Сообщений: 3,867
25.08.2011, 06:17 #21
Цитата Сообщение от footbaler Посмотреть сообщение
на строчку
C++
1
std::back_inserter(res_I_for_I_ind)
, говорит - is not a member of 'std' и identifier not found.
Надо еще включить
C++
1
#include <iterator>
У меня, правда, на MSVS 2008 и так работает.

Добавлено через 5 минут
Цитата Сообщение от footbaler Посмотреть сообщение
То есть, это ошибка в курсовой
Ну, если вы делаете точно по методичке, то да.
1
footbaler
1 / 1 / 0
Регистрация: 18.12.2010
Сообщений: 50
25.08.2011, 21:59  [ТС] #22
Mr.X, спасибо за помощь, буду разбираться.

Добавлено через 14 минут
только что посмотрел, нашел у себя в программе ошибку, в выражении, при расчете J3. Там в одном месте, вместо r2 у меня стояла r3. Теперь моя программа считает так же как ваша! Еще раз спасибо!
0
footbaler
1 / 1 / 0
Регистрация: 18.12.2010
Сообщений: 50
29.08.2011, 01:41  [ТС] #23
Возник очередной вопрос...
Вот код первого варианта (используя структурированный подход):
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
#include "stdafx.h"
#include <iomanip>
#include <iostream>
 
double J2(int E1, int E2, float r1, float r2, float r3)
{
    return (E1/(r1+((r2*r3)/(r2+r3))))*(r3/(r2+r3))-(E2/(r2+(r1*r3/(r1+r3))));
}
 
double J3(int E1, int E2, float r1, float r2, float r3)
{
    return (E1/(r1+((r2*r3)/(r2+r3))))*(r2/(r2+r3))+(E2/(r2+(r1*r3/(r1+r3))))*(r1/(r1+r3));
}
 
double J1(int E1, int E2, float r1, float r2, float r3)
{
    return J2(E1, E2, r1, r2, r3)+J3(E1, E2, r1, r2, r3);
}
 
int main()
{
    int v, E1, E2;
    float r1 = 30.6, r2 = 3.25, r3 = 20.57;
    setlocale(LC_ALL, "Russian");
    for(;;)
    {
        std::cout << "\n1. Таблица зависимости J1 от E1 i E2\n"
                     "2. Таблица зависимости J2 от E1 i E2\n"
                     "3. Таблица зависимости J3 от E1 i E2\n"
                     "-> ";
 
        if( !(std::cin >> v) || (v < 1) || (v > 3) ) return 0;
 
        std::system("cls");
        std::cout << "\n|---------------------------------------|\n"
                     "|   Таблица зависимости J" << v << " от 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(8);
                switch(v)
                {
                case 1: std::cout << std::setprecision(3) << J1(E1, E2, r1, r2, r3) << '|'; break;
                case 2: std::cout << std::setprecision(3) << J2(E1, E2, r1, r2, r3) << '|'; break;
                case 3: std::cout << std::setprecision(3) << J3(E1, E2, r1, r2, r3) << '|'; break;
                }
            }
 
            std::cout << "\n|---|--------|--------|--------|--------|\n";
        }
    }
}
Вот код второго варианта (используя объектно-ориентированный подход):
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
#include "stdafx.h"
#include <iostream>
#include <iomanip>
 
class power_box {
    float r1;
    float r2;
    float r3;
    int E1;
    int E2;
public:
    double J2(int E1, int E2, float r1, float r2, float r3)
    {
        return (E1/(r1+((r2*r3)/(r2+r3))))*(r3/(r2+r3))-(E2/(r2+(r1*r3/(r1+r3))));
    };
    double J3(int E1, int E2, float r1, float r2, float r3)
    {
        return (E1/(r1+((r2*r3)/(r2+r3))))*(r2/(r2+r3))+(E2/(r2+(r1*r3/(r1+r3))))*(r1/(r1+r3));
    };
    double J1(int E1, int E2, float r1, float r2, float r3)
    {
        return J2(E1, E2, r1, r2, r3)+J3(E1, E2, r1, r2, r3);
    };
} tok;
 
int main()
{
    int v, E1, E2;
    float r1 = 30.6, r2 = 3.25, r3 = 20.57;
    setlocale(LC_ALL, "Russian");
    for(;;)
    {
        std::cout << "\n1. Таблица зависимости J1 от E1 i E2\n"
                     "2. Таблица зависимости J2 от E1 i E2\n"
                     "3. Таблица зависимости J3 от E1 i E2\n"
                     "-> ";
 
        if( !(std::cin >> v) || (v < 1) || (v > 3) ) return 0;
 
        std::system("cls");
        std::cout << "\n|---------------------------------------|\n"
                     "|   Таблица зависимости J" << v << " от 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(8);
                switch(v)
                {
                case 1: std::cout << std::setprecision(3) << tok.J1(E1, E2, r1, r2, r3) << '|'; break;
                case 2: std::cout << std::setprecision(3) << tok.J2(E1, E2, r1, r2, r3) << '|'; break;
                case 3: std::cout << std::setprecision(3) << tok.J3(E1, E2, r1, r2, r3) << '|'; break;
                }
            }
 
            std::cout << "\n|---|--------|--------|--------|--------|\n";
        }
    }
}
Тут я просто добавил класс, и в него занес функции, все остальное осталось прежним. Так надо было сделать, это считается объектно-ориентированный подход, или я не правильно мыслю? Ну и может я где, чего, неправильно объявил, написал, говорите не стесняйтесь!:-)
Спасибо.
0
footbaler
1 / 1 / 0
Регистрация: 18.12.2010
Сообщений: 50
31.08.2011, 23:17  [ТС] #24
Кто-нибудь, что-нибудь подскажет?
0
Jupiter
Каратель
Эксперт С++
6554 / 3975 / 226
Регистрация: 26.03.2010
Сообщений: 9,273
Записей в блоге: 1
Завершенные тесты: 2
31.08.2011, 23:28 #25
Цитата Сообщение от footbaler Посмотреть сообщение
Тут я просто добавил класс, и в него занес функции, все остальное осталось прежним. Так надо было сделать, это считается объектно-ориентированный подход, или я не правильно мыслю? Ну и может я где, чего, неправильно объявил, написал, говорите не стесняйтесь!:-)
Спасибо.
конструкторов нет, как вы проиницилизируете поля класса? и где само использование класса?
1
footbaler
1 / 1 / 0
Регистрация: 18.12.2010
Сообщений: 50
01.10.2011, 13:06  [ТС] #26
Доброго времени суток!
После не большой паузы, я вновь занимаюсь данным вопросом.
Вот, что у меня получилось сейчас. Уважаемые эксперты, указывайте, пожалуйста, на мои ошибки. Интересует, конкретно, правильность объектно-ориентированного подхода.
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
#include <iostream>
#include <iomanip>
#include <windows>
 
class power_box {
     float r1, r2, r3;
     int E1, E2;
public:
     power_box(int i, int j);
     double J1();
     double J2();
     double J3();
};
 
power_box::power_box(int i, int j)
{
 r1 = 30.6;
 r2 = 3.25;
 r3 = 20.57;
 E1 = i;
 E2 = j;
}
 
double power_box::J2()
{
    return (E1/(r1+((r2*r3)/(r2+r3))))*(r3/(r2+r3))-(E2/(r2+(r1*r3/(r1+r3))));
}
 
double power_box::J3()
{
    return (E1/(r1+((r2*r3)/(r2+r3))))*(r2/(r2+r3))+(E2/(r2+(r1*r3/(r1+r3))))*(r1/(r1+r3));
}
 
double power_box::J1()
{
    return J2() + J3();
}
 
int main()
{
    for(;;)
    {
        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"
                  "-> ";
        int v;
        if( !(cin >> v) || (v < 1) || (v > 3) ) return 0;
        system("cls");
        cout << "\n------------------ E2 --------------\n"
                " E1     15     20      25      30   \n"
                "------------------------------------\n";
        cout.setf(ios::fixed);
        for(int i = 10; i <= 100; i+= 10)
        {
            cout << setw(3) << i;
            for(int j = 15; j <= 30; j+= 5)
            {
                power_box power(i, j);
                cout.width(8);
                switch(v)
                {
                    case 1: cout << setprecision(3) << power.J1(); break;
                    case 2: cout << setprecision(3) << power.J2(); break;
                    case 3: cout << setprecision(3) << power.J3(); break;
                }
            }
            cout << "\n------------------------------------\n";
        }
    }
}
0
Deviaphan
Делаю внезапно и красиво
Эксперт C++
1287 / 1221 / 50
Регистрация: 22.03.2011
Сообщений: 3,744
01.10.2011, 13:25 #27
Т.к. J1-2-3 не меняют состояние объекта, их нужно сделать константными (дописать const в конце).

Добавлено через 3 минуты
Но конкретно этот код от ООП ничего не выигрывает.
1
footbaler
1 / 1 / 0
Регистрация: 18.12.2010
Сообщений: 50
01.10.2011, 13:31  [ТС] #28
Исправлено.
Цитата Сообщение от Deviaphan Посмотреть сообщение
Но конкретно этот код от ООП ничего не выигрывает.
Поясните пожалуйста.
0
Deviaphan
Делаю внезапно и красиво
Эксперт C++
1287 / 1221 / 50
Регистрация: 22.03.2011
Сообщений: 3,744
01.10.2011, 13:37 #29
Такой код по сути равнозначен.
C++
1
2
3
4
5
6
7
8
     const float r1=30.6, r2=3.25, r3=20.57;
 
struct power_box {
     int E1, E2;
};
     double J1( const power_box * );
     double J2( const power_box * );
     double J3( const power_box * );
На самом деле, тебе даже не нужна структура, можно сразу Е1 и Е2 в функции передавать.

Ну и по начальному коду. Раз r1-2-3 константы, их можно сделать статическими константами и они не будут занимать место в объекте power_box.
0
footbaler
1 / 1 / 0
Регистрация: 18.12.2010
Сообщений: 50
01.10.2011, 14:10  [ТС] #30
Я немного запутался, поэтому поясню, что изначально мне нужно было, почему я создал данную тему.
Я делаю курсовую работу. Задание курсовой: написать программу двумя способами, использую структурированный и объектно-ориентированный подход. С первым способом проблем не возникло,
вот код

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
#include <iostream>
#include <iomanip>
#include <windows>
 
double J2(int E1, int E2, float r1, float r2, float r3)
{
    return (E1/(r1+((r2*r3)/(r2+r3))))*(r3/(r2+r3))-(E2/(r2+(r1*r3/(r1+r3))));
}
 
double J3(int E1, int E2, float r1, float r2, float r3)
{
    return (E1/(r1+((r2*r3)/(r2+r3))))*(r2/(r2+r3))+(E2/(r2+(r1*r3/(r1+r3))))*(r1/(r1+r3));
}
 
double J1(int E1, int E2, float r1, float r2, float r3)
{
    return J2(E1, E2, r1, r2, r3)+J3(E1, E2, r1, r2, r3);
}
 
int main()
{
    for(;;)
    {
        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"
                  "-> ";
        int v;
        if( !(cin >> v) || (v < 1) || (v > 3) ) return 0;
        system("cls");
        cout << "\n------------------ E2 --------------\n"
                " E1     15     20      25      30   \n"
                "------------------------------------\n";
        cout.setf(ios::fixed);
        float r1 = 30.6, r2 = 3.25, r3 = 20.57;
        for(int E1 = 10; E1 <= 100; E1+= 10)
        {
            cout << setw(3) << E1;
            for(int E2 = 15; E2 <= 30; E2+= 5)
            {
                cout.width(8);
                switch(v)
                {
                    case 1: cout << setprecision(3) << J1(E1, E2, r1, r2, r3); break;
                    case 2: cout << setprecision(3) << J2(E1, E2, r1, r2, r3); break;
                    case 3: cout << setprecision(3) << J3(E1, E2, r1, r2, r3); break;
                }
            }
            cout << "\n------------------------------------\n";
        }
    }
}
, а с ООП возникли проблемы.
Выберете, пожалуйста: 1) то, что я делаю можно назвать ООП; 2) я двигаюсь в правильном направлении, но у меня есть ошибки; 3) нужно вообще все делать по другому.
Спасибо.
0
MoreAnswers
Эксперт
37091 / 29110 / 5898
Регистрация: 17.06.2006
Сообщений: 43,301
01.10.2011, 14:10
Привет! Вот еще темы с ответами:

Ориентированный граф и матрица инцидентности - C++
Вот у меня есть такое прекрасное задание: Базовый класс: Элемент ориентированного графа. Производные классы: дуга и вершина...

Из матрицы смежности сделать ориентированный граф - C++
Какаю библиотеку использовать что би нарисовать граф?Возможно есть готов код ,буду очень благодарный за любую помощь.У меня идей ноль)

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

Реализовать программу, вычисляющую для точек в плоскости произвольно ориентированный прямоугольник - C++
Задание: Реализовать программу, вычисляющую для заданного набора точек в плоскости произвольно ориентированный прямоугольник, содержащий...


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

Или воспользуйтесь поиском по форуму:
Yandex
Объявления
01.10.2011, 14:10
Ответ Создать тему
Опции темы

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