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

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

int main()

#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";
  }
 }
}

#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";
        }
    }
}

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

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

std::back_inserter(res_I_for_I_ind)