2014 dxdy logo

Научный форум dxdy

Математика, Физика, Computer Science, Machine Learning, LaTeX, Механика и Техника, Химия,
Биология и Медицина, Экономика и Финансовая Математика, Гуманитарные науки




Начать новую тему Ответить на тему
 
 Класс полином.
Сообщение14.11.2009, 16:51 


14/11/09
7
приветствую.
реализован класс полинома, в нем необходимо реализовать перегрузку операторов.
остановился на бинарном *= , и не разбирусь никак.
в чем собственно трабл.
хотелось бы услышать ответа/cовета.
глаз приелся никак не соображу...
код: [ скачать ] [ спрятать ]
Используется синтаксис C++
  1. #include <iostream>
  2. #include <iomanip>
  3. #include <cmath>
  4. #include <conio.h>
  5. #include <windows.h>
  6. #include "ConvOem.h"
  7. using namespace std;
  8.  
  9. CConvOem szbuf(100);
  10. class Vector;
  11. class Polynom
  12. {
  13. private:
  14.         size_t m_Dim;   //размер
  15.         double * m_Pol;
  16. public:
  17.         Polynom();                                                              // к-ор по умолчанию             
  18.         Polynom(const size_t);                                  // к-ор с 1 аргументом
  19.         Polynom(const size_t,const double* );   //конструктор с 2 аргументами
  20.         Polynom(const Polynom&);                                // Конструктор копирования
  21.         ~Polynom();                                                             // Деструктор
  22.         size_t GetDim() const {return m_Dim;}   // Получение степени
  23.         //void SetDim(int y){ m_Dim = y; }              // Изменение Степени.
  24.         double GetKof(const size_t i); //Получение i-ого коэффициента.
  25.         void SetKof(const size_t i,const double x ); // Изменение i-ого коэффициента.
  26.         void Show() const;
  27.         friend Vector Vec2Poly(const Polynom &);
  28.         friend Polynom Poly2Vec(const Vector &);
  29.  
  30.         Polynom operator+() {return *this;} //перегрузка унарного оператора "+"
  31.         Polynom operator-(); //перегрузка унарного оператора "-"
  32.  
  33.         operator double* ();
  34.  
  35.         Polynom & operator=(Polynom &no);
  36.         Polynom & operator=(double no);
  37.         Polynom & operator+=(Polynom &no);
  38.         Polynom & operator+=(double no);
  39.         Polynom & operator-=(Polynom &no);
  40.         Polynom & operator-=(double no);
  41.         Polynom & operator*=(Polynom &no);
  42.         Polynom & operator*=(double no);
  43.         Polynom & operator/=(double no);
  44.         Polynom & operator^=(double no);
  45.        
  46. };
  47.  
  48. class Vector
  49. {  
  50. private:
  51.         size_t m_Dim;                                           // Размер вектора.
  52.         double *m_pVec;                                         //адрес массива с координатами вектора
  53. public:
  54.         Vector(size_t,double*);                         //конструктор с 1-им параметром
  55.         Vector(size_t);                                         //конструктор с 2-мя параметром
  56.         Vector();
  57.         Vector(const Vector&);                          //конструктор копирования
  58.         ~Vector();                                                      // Деструктор.
  59.         double GetKof(const size_t i); // Получение i-ой координаты.
  60.         void SetKof(const size_t i, const double x);    // Изменение i-ой координаты.
  61.         size_t GetDim() const {return m_Dim;}   // Получение размера вектора.
  62.         void Show() const;      // Вывод вектора.
  63.  
  64.         friend Vector Vec2Poly(const Polynom &);
  65.         friend Polynom Poly2Vec(const Vector &);
  66. };
  67.  
  68. double Vector::GetKof(const size_t i)
  69. {
  70.         if (i > m_Dim)
  71.         {
  72.                 cout<<szbuf.toOem("Неправильное значение")<<endl;;
  73.                 exit(-1);
  74.         }
  75.         return m_pVec[i-1];
  76. }
  77. void Vector::SetKof(const size_t i,const double x )
  78. {
  79.         if (i > m_Dim)
  80.         {
  81.                 cout<<szbuf.toOem("Неправильное значение ")<<endl;
  82.                 exit(-1);
  83.         }
  84.         m_pVec[i-1]=x;
  85. }
  86.  
  87. void Vector::Show() const
  88. {
  89.         cout << '(';
  90.         size_t i;
  91.         for (i = 0; i < m_Dim; ++i)
  92.         {
  93.                 cout << m_pVec[i];
  94.                 if (i < m_Dim - 1) cout << ", ";
  95.         }
  96.         cout << ')' << endl;
  97. }
  98.  
  99. Vector::Vector(const size_t Dim,double* pVec):m_Dim(Dim) // к-ор с 2мя арг
  100. {
  101.         m_pVec=new double[Dim];
  102.         if (!m_pVec)
  103.         {
  104.                 cout <<szbuf.toOemA( "Ошибка! Неверный размер вектора." )<< endl;
  105.                 exit(-3);
  106.         }
  107.         for(int i=0;i<m_Dim;i++)
  108.                 m_pVec[i]=pVec[i];
  109. }
  110. Vector::Vector(size_t Dim):m_Dim(Dim) // к-ор с 1им арг
  111. {
  112.         m_pVec= new double[m_Dim];
  113.         if (!m_pVec)
  114.         {
  115.                 cout <<szbuf.toOemA( "Ошибка! Неверный размер вектора." )<< endl;
  116.                 exit(-1);
  117.         }
  118.         for(int i=0;i<m_Dim;i++)
  119.                 m_pVec[i]=0.0;
  120. }
  121.  
  122. Vector::Vector():m_Dim(1) // к-ор без арг
  123. {
  124.         m_pVec=new double [m_Dim];
  125.         if(!m_pVec) {
  126.                 cout<<"Error"<<endl;
  127.                 exit (-1);
  128.         }      
  129. }
  130.  
  131. Vector::Vector(const Vector& cv):m_Dim(cv.m_Dim) //конструктор копирования
  132. {
  133.         if (!(m_pVec=new double[m_Dim]))
  134.         {
  135.                 cout<<szbuf.toOemA("Нет памяти") <<endl;
  136.                 exit(-1);
  137.         }
  138.         //копирование координат
  139.         size_t i;
  140.         for(i=0;i<m_Dim;++i)
  141.                 m_pVec[i]=cv.m_pVec[i];
  142.         cout<<szbuf.toOemA("копия создана Vec") <<endl;
  143. }
  144. Vector::~Vector()
  145. {
  146.         cout << szbuf.toOemA("Вектор успешно удалён ...") << endl;
  147.         delete[] m_pVec;
  148.  
  149. }
  150. Polynom Poly2Vec(const Vector& cv)
  151. {
  152.         Polynom c(cv.m_Dim-1);
  153.         for(int i=0; i < cv.m_Dim; ++i)
  154.                 c.m_Pol[i]=cv.m_pVec[i];
  155.         return c;
  156. }
  157. Vector Vec2Poly(const Polynom& cc)
  158. {
  159.         //создадим объект класса вектор
  160.         Vector v(cc.m_Dim);
  161.         for(int i=0; i<cc.m_Dim; ++i)
  162.                 v.m_pVec[i]=cc.m_Pol[i];
  163.         return v;
  164. }
  165. double Polynom::GetKof(const size_t i)
  166. {
  167.         if (i > m_Dim)
  168.         {
  169.                 cout<<szbuf.toOem("Неправильное значение")<<endl;;
  170.                 exit(-1);
  171.         }
  172.         return m_Pol[i-1];
  173. }
  174. void Polynom::SetKof(const size_t i,const double x )
  175. {
  176.         if (i > m_Dim)
  177.         {
  178.                 cout<<szbuf.toOem("Неправильное значение ")<<endl;
  179.                 exit(-1);
  180.         }
  181.         m_Pol[i]=x;
  182. }
  183. //Конструктор без аргументов
  184. Polynom::Polynom(): m_Dim(0)
  185. {      
  186.         m_Dim=m_Dim+1;
  187.         m_Pol=new double[m_Dim];    // Выделение памяти для Polynoma
  188.         if(!m_Pol)
  189.         {
  190.                 cout<<szbuf.toOem("Ошибка")<<endl;
  191.                 exit (-1);
  192.         }      
  193.         m_Pol[0]=0;
  194. }
  195. // Определение конструктора с 1 арг
  196. Polynom::Polynom(const size_t Dim): m_Dim(Dim)
  197. {
  198.         {
  199.                 m_Dim=Dim+1;
  200.                 if(!m_Dim)
  201.                 {
  202.                         cout<<szbuf.toOem("Ошибка")<<endl;
  203.                         exit (-3);
  204.                 }
  205.                 if(!(m_Pol= new double[m_Dim+1]))
  206.                 {
  207.                         cout<<szbuf.toOem("Ошибка")<<endl;
  208.                         exit (-1);
  209.                 }
  210.                 size_t i;
  211.                 for(i=0; i <= m_Dim ; ++i)
  212.                 {
  213.                         m_Pol[i]=i;
  214.                 }
  215.  
  216.         }
  217. }
  218. Polynom::Polynom(const size_t Dim,const double *mas):m_Dim(Dim)
  219. {
  220.         m_Dim=Dim+1;
  221.         if(!m_Dim)
  222.         {
  223.                 cout<<szbuf.toOem("Неверный размер")<<endl;
  224.                 exit(-3);
  225.         }
  226.         if(!(m_Pol= new double[m_Dim+1]))
  227.         {
  228.                 cout<<szbuf.toOem("Нет памяти")<<endl;
  229.                 exit(-1);
  230.         }
  231.         size_t i;
  232.         if(mas)
  233.         {
  234.                 for(i=0; i <= m_Dim ; ++i)
  235.                 {
  236.                         m_Pol[i]=mas[i];
  237.                 }
  238.         }
  239.  
  240. }
  241. //Конструктор копирования
  242. Polynom::Polynom(const Polynom& Pol):m_Dim(Pol.m_Dim)
  243. {      
  244.         if (!(m_Pol=new double[m_Dim+1]))
  245.         {
  246.                 cout<<szbuf.toOem("Нет памяти") <<endl;
  247.                 exit(-1);
  248.         }
  249.         for (int i=0; i < m_Dim; i++)
  250.                 m_Pol[i]=Pol.m_Pol[i];
  251.         cout<<szbuf.toOem("копия Pol создана") <<endl;
  252. }
  253.  
  254. Polynom::~Polynom()
  255. {      
  256.         cout << szbuf.toOem("Полином успешно удалён ...") << endl;
  257.         delete[] m_Pol;
  258. }
  259.  
  260. void Polynom::Show()const
  261. {      
  262.         size_t i;
  263.         for(i=0;i<m_Dim-1;++i)
  264.         {
  265.                 cout << m_Pol[i] << "*x^" << m_Dim-i-1;
  266.                 if(m_Pol[i+1]>=0)
  267.                         cout << "+";
  268.         }
  269.         cout << m_Pol[m_Dim-1] << endl;
  270. }
  271. /*
  272. void Polynom::Show()const
  273. {
  274. cout << m_Pol[0];
  275. for (int i=1; i<m_Dim; ++i)
  276. {
  277. if(i!=0)
  278. {
  279. if (m_Pol[i] < 0)
  280. cout << m_Pol[i]<<"*x^"<<i;
  281. else cout << "+" << m_Pol[i] << "*x^" << i;
  282. }
  283. }
  284. cout << endl;
  285. }
  286. */
  287.  
  288. //////////////////    OPERATORI   /////////////////////////
  289. ///////////////////////////////////////////////////////////
  290. ///////////////////////////////////////////////////////////
  291.  
  292.  
  293. ////////////////  Перегрузки 1
  294. ////////////////
  295. Polynom::operator double *()
  296. {
  297.         return m_Pol;
  298. }
  299. ////перегрузка унарного оператора "-"
  300. Polynom Polynom::operator-()
  301. {      
  302.         size_t i;
  303.         for (i=0; i<m_Dim; ++i)
  304.                 m_Pol[i] = -m_Pol[i];
  305.         return *this;
  306. }
  307.  
  308. ////////////////  Перегрузки 2
  309. ////////////////
  310.  
  311. // Оператор присваивания
  312. Polynom & Polynom::operator=(Polynom & no)
  313. {
  314.         if ( this != &no)
  315.         {
  316.                 delete[] m_Pol;
  317.                 if (!(m_Pol=new double[m_Dim=no.m_Dim]))
  318.                 {
  319.                         cout<<szbuf.toOem("Ошибка! Недостаточно памяти!")<<endl;;
  320.                         exit(-1);
  321.                 }
  322.                 size_t i;
  323.                 for (i=0; i < m_Dim; ++i)
  324.                         m_Pol[i]=no.m_Pol[i];
  325.         }
  326.         return *this;
  327.  
  328. }
  329. // Оператор присваивания, когда правая часть число
  330. Polynom & Polynom::operator=(double no)
  331. {
  332.         size_t i;
  333.         for (i=0; i <= m_Dim; ++i)
  334.                 m_Pol[i]=no;
  335.         return *this;
  336. }
  337. // Оператор присваивания cо сложением    
  338. Polynom & Polynom::operator+=(Polynom & no)
  339. {
  340.         if (&no != this)
  341.         {
  342.                 size_t i,k,j;
  343.  
  344.                 if (m_Dim > no.m_Dim)
  345.                 {
  346.                         i = m_Dim;
  347.                         k=no.m_Dim;
  348.                 }
  349.                 else
  350.                 {
  351.                         i = no.m_Dim;
  352.                         k = m_Dim;
  353.                 }
  354.                
  355.                 //Polynom new_Pol(i);
  356.                 double* new_Pol = new double[i];
  357.  
  358.                 for(j=0; j<k; ++j)
  359.                         new_Pol[j] = m_Pol[j]+no.m_Pol[j];
  360.  
  361.                 for(j=k; j<i; ++j)
  362.                         if (m_Dim > no.m_Dim)
  363.  
  364.                                 new_Pol[j] = m_Pol[j];
  365.                         else
  366.                                 new_Pol[j] = no.m_Pol[j];
  367.  
  368.                 m_Pol = new_Pol;
  369.                 m_Dim = i;
  370.         }
  371.         return *this;
  372. }
  373. // Оператор присваивания cо сложением, когда правая часть число.
  374. Polynom & Polynom::operator+=(double no)
  375. {
  376.         size_t i;
  377.         for (i=0; i < m_Dim; ++i)
  378.                 m_Pol[i]+=no;
  379.         return *this;
  380. }
  381. // Оператор присваивания c вычитанием
  382. Polynom & Polynom::operator-=(Polynom & no)
  383. {
  384.         if (&no != this)
  385.         {
  386.                 size_t i,k,j;
  387.  
  388.                 if (m_Dim > no.m_Dim)
  389.                 {
  390.                         i = m_Dim;
  391.                         k=no.m_Dim;
  392.                 }
  393.                 else
  394.                 {
  395.                         i = no.m_Dim;
  396.                         k = m_Dim;
  397.                 }
  398.  
  399.                 double* new_Pol = new double[i];
  400.  
  401.                 for(j=0; j<k; ++j)
  402.                         new_Pol[j] = m_Pol[j]-no.m_Pol[j];
  403.  
  404.                 for(j=k; j<i; ++j)
  405.                         if (m_Dim > no.m_Dim)
  406.                                 new_Pol[j] = -m_Pol[j];
  407.                         else
  408.                                 new_Pol[j] = -no.m_Pol[j];
  409.  
  410.                 m_Pol = new_Pol;
  411.                 m_Dim = i;
  412.         }
  413.         return *this;
  414. }
  415. // Оператор присваивания c вычитанием, когда правая часть число.
  416. Polynom & Polynom::operator-=(double no)
  417. {
  418.         size_t i;
  419.         for (i=0; i < m_Dim; ++i)
  420.                 m_Pol[i]-=no;
  421.         return *this;
  422. }
  423. //оператор присваивания с умножением
  424. Polynom & Polynom::operator*=(Polynom & no)
  425. {
  426.     if (&no != this)
  427.     {
  428.         size_t i,k,j,m_B,m_M;
  429.  
  430.         if (m_Dim > no.m_Dim)
  431.         {
  432.             m_B = m_Dim;
  433.             m_M = no.m_Dim;
  434.         }
  435.         else
  436.         {
  437.             m_B = no.m_Dim;
  438.             m_M = m_Dim;
  439.         }
  440.                
  441.                  Polynom new_Pol(m_B+m_M-1),
  442.                                          sum(new_Pol);
  443.  
  444.                 for(k=0;k <= m_B+m_M-1; ++k)
  445.                
  446.                                 new_Pol[k]=0;
  447.                
  448.                 *this = new_Pol;
  449.        
  450.         for(i=0; i < m_M;++i)
  451.         {
  452.                         k=i;
  453.             for(j=0;j < m_B;++j)
  454.             {
  455.                 new_Pol[k] = m_Pol[j] * no.m_Pol[i];
  456.              k++;
  457.             }
  458.            sum+=new_Pol;
  459.                 }
  460.                 *this = sum;
  461.         }
  462.         return *this;
  463. }
  464. //для случая,когда правый операнд число
  465. Polynom & Polynom::operator*=(double no)
  466. {
  467.         size_t i;
  468.         for(i=0; i<m_Dim; ++i)
  469.                 m_Pol[i] *= no;
  470.         return *this;
  471. }
  472. //оператор возвидения в степень для случая,когда правый операнд число/
  473. Polynom & Polynom::operator^=(double no)
  474. {
  475.         size_t i;
  476.         for(i=0; i<m_Dim; ++i)
  477.                 m_Pol[i] = pow(m_Pol[i],no);
  478.         return *this;
  479. }
  480.  
  481. //Бинарный оператор присваивания с делением
  482. //для случая,когда правый операнд число
  483. Polynom & Polynom::operator/=(double no)
  484. {
  485.         size_t i;
  486.         for(i=0; i<m_Dim; ++i)
  487.                 m_Pol[i] /= no;
  488.         return *this;
  489. }
  490.  
  491. ///////////////////////////////////
  492. /////////Перегрузки 3///////////
  493.  
  494. void main()
  495. {      
  496.  
  497.         Polynom p1;
  498.         Polynom p2(4);
  499.         double mass[4]={4,5,6,7};
  500.         Polynom p3(3,mass);
  501.         p1.Show();
  502.         p2.Show();
  503.         p3.Show();
  504.         Polynom p4(p3);
  505.         p4.Show();
  506.         p4.SetKof(3,20);
  507.         p4.Show();
  508.         double per;                                
  509.         per = p4.GetKof(3);
  510.         cout << per << endl;
  511.  
  512.  
  513.  
  514.         double mass2[5]={-4,5,6,-0.77,0};
  515.         Vector va3(5,mass2);
  516.         va3.Show();
  517.         Polynom toVec = Poly2Vec(va3); 
  518.         Vector toPol = Vec2Poly(toVec);
  519.         toVec.Show();
  520.         toPol.Show();
  521.  
  522.         cout<<endl;
  523.  
  524.         cout <<szbuf.toOem("Использование оператора +:");
  525.         +p1;
  526.         p1.Show();
  527.         cout <<szbuf.toOem("Использование оператора -:");
  528.         -p1;
  529.         p1.Show();
  530.  
  531.         cout<<endl;
  532.  
  533.         cout <<szbuf.toOem("Использование бинарного оператора =:");
  534.         p1=p4;
  535.         p1.Show();
  536.  
  537.         cout << szbuf.toOem("Использование бинарного оператора = когда правый операнд число(2):");
  538.         double x=2;
  539.         p1=x;
  540.         p1.Show();
  541.  
  542.         cout <<szbuf.toOem("Использование бинарного оператора +=:");
  543.         double mass3[]={1,1,1,0,2,10};
  544.         Polynom p6(5,mass3);
  545.         double mass4[]={4,3,100,100,30};
  546.         Polynom p7(4,mass4);
  547.         p6+=p7;
  548.         p6.Show();
  549.  
  550.         cout << szbuf.toOem("Использование бинарного оператора += когда правый операнд число:");
  551.         double y=3;
  552.         p1+=y;
  553.         p1.Show();
  554.  
  555.         cout <<szbuf.toOem("Использование бинарного оператора -=:");
  556.         double mass6[]={1,1,1,0,2,10};
  557.         Polynom p10(5,mass6);
  558.         double mass7[]={4,3,100,100,30};
  559.         Polynom p11(4,mass7);
  560.         p11-=p10;
  561.         p11.Show();
  562.  
  563.         cout << szbuf.toOem("Использование бинарного оператора -= когда правый операнд число:");
  564.         double z=4;
  565.         p1-=z;
  566.         p1.Show();
  567.  
  568.         ///////////////////
  569.  
  570.         cout <<szbuf.toOem("Использование бинарного оператора =*:");
  571.         double mass8[]={3,1,5};  // 3 + x + 5x^2
  572.         Polynom p12(2,mass8);
  573.         double mass9[]={1,3}; // 1 + 3x
  574.         Polynom p13(1,mass9);
  575.  
  576.         p13*=p12;
  577.         p13.Show();
  578.  
  579.         getch();
  580. }
  581.  

 Профиль  
                  
 
 Re: Класс полином.
Сообщение14.11.2009, 17:00 
Заслуженный участник
Аватара пользователя


01/08/06
3116
Уфа
inlaf писал(а):
Используется синтаксис C++
  1.         for(i=0; i < m_M;++i)
  2.         {
  3.                   k=i;
  4.             for(j=0;j < m_B;++j)
  5.             {
  6.                 new_Pol[k] = m_Pol[j] * no.m_Pol[i];
  7.              k++;
  8.             }
  9.            sum+=new_Pol;
  10.       }
Вроде, перед началом цикла по j надо бы обнулить многочлен new_Pol.

 Профиль  
                  
 
 Re: Класс полином.
Сообщение14.11.2009, 17:33 


23/12/08
245
Украина

(Оффтоп)

Оф топ:
одного меня раздражает двойной скролинг?(по коду и по странице)

 Профиль  
                  
 
 Re: Класс полином.
Сообщение14.11.2009, 17:56 
Заслуженный участник


04/05/09
4586
1. Неплохо бы форматирование поправить, а то нелегко разобраться, где цикл кончается.
2. К аргументам типа Polinom& у всех операторов надо добавить const.
3. Непонятно, какой смысл у вас имеют операторы прибавления и вычитания числа. По идее, они должны изменять только константный член полинома, а у вас - все члены. Та же фигня с оператором присваивания числа.
4. Оператор возведения в степень почему-то возводит в степень все коэффициенты. Какой в этом смысл? Да и вообще, аргумент здесь должен быть целым.
5. В нескольких операторах выделяете новую память, а старую не освобождаете.
6. А почему в операторе *= нельзя умножить полином на себя?

-- Сб ноя 14, 2009 09:57:35 --

(Оффтоп)

Nerazumovskiy в сообщении #261970 писал(а):
Оф топ:
одного меня раздражает двойной скролинг?(по коду и по странице)
Нажмите кнопку [развернуть].

 Профиль  
                  
 
 Re: Класс полином.
Сообщение14.11.2009, 17:57 
Заслуженный участник
Аватара пользователя


01/08/06
3116
Уфа
Nerazumovskiy писал(а):

(Оффтоп)

одного меня раздражает двойной скролинг?(по коду и по странице)

(Оффтоп)

Обратите внимание на кнопку "РАЗВЕРНУТЬ" в коде.

 Профиль  
                  
 
 Re: Класс полином.
Сообщение14.11.2009, 18:01 
Заслуженный участник


04/05/09
4586
А ещё разберитесь со смыслом поля m_Dim. Он может быть равен размеру массива m_Pol, а может быть на единицу меньше. Решите, как должно быть, и приведите в порядок.

 Профиль  
                  
 
 Re: Класс полином.
Сообщение14.11.2009, 20:54 


14/11/09
7
3. проработаю. просто конкретных указананий в заданий не было.
4.переделал. там вроде можно перемножить полином сам на себя.
5. в каких именно?
6. нам даны два разных полинома, возможно разных размеров.

на счет поля m_Dim, посмотрел. вроде все как и должно быть.
прога крашиться на операторе *= .
помоему беда с размером все же..

код: [ скачать ] [ спрятать ]
Используется синтаксис C++
#include <iostream>
#include <iomanip>
#include <cmath>
#include <conio.h>
#include <windows.h>
#include "ConvOem.h"
using namespace std;

CConvOem szbuf(100);
class Vector;
class Polynom
{
private:
        size_t m_Dim;   //размер
        double * m_Pol;
public:
        Polynom();                                                              // к-ор по умолчанию             
        Polynom(const size_t);                                  // к-ор с 1 аргументом
        Polynom(const size_t,const double* );   //конструктор с 2 аргументами
        Polynom(const Polynom&);                                // Конструктор копирования
        ~Polynom();                                                             // Деструктор
        size_t GetDim() const {return m_Dim;}   // Получение степени
        //void SetDim(int y){ m_Dim = y; }              // Изменение Степени.
        double GetKof(const size_t i); //Получение i-ого коэффициента.
        void SetKof(const size_t i,const double x ); // Изменение i-ого коэффициента.
        void Show() const;
        friend Vector Vec2Poly(const Polynom &);
        friend Polynom Poly2Vec(const Vector &);

        Polynom operator+() {return *this;} //перегрузка унарного оператора "+"
        Polynom operator-(); //перегрузка унарного оператора "-"

        operator double* ();

        Polynom & operator=(const Polynom& no);
        Polynom & operator=(double no);
        Polynom & operator+=(const Polynom& no);
        Polynom & operator+=(double no);
        Polynom & operator-=(const Polynom& no);
        Polynom & operator-=(double no);
        Polynom & operator*=(const Polynom& no);
        Polynom & operator*=(double no);
        Polynom & operator/=(double no);
        Polynom & operator^=(double no);

};

class Vector
{  
private:
        size_t m_Dim;                                           // Размер вектора.
        double *m_pVec;                                         //адрес массива с координатами вектора
public:
        Vector(size_t,double*);                         //конструктор с 1-им параметром
        Vector(size_t);                                         //конструктор с 2-мя параметром
        Vector();
        Vector(const Vector&);                          //конструктор копирования
        ~Vector();                                                      // Деструктор.
        double GetKof(const size_t i); // Получение i-ой координаты.
        void SetKof(const size_t i, const double x);    // Изменение i-ой координаты.
        size_t GetDim() const {return m_Dim;}   // Получение размера вектора.
        void Show() const;      // Вывод вектора.

        friend Vector Vec2Poly(const Polynom &);
        friend Polynom Poly2Vec(const Vector &);
};

double Vector::GetKof(const size_t i)
{
        if (i > m_Dim)
        {
                cout<<szbuf.toOem("Неправильное значение")<<endl;;
                exit(-1);
        }
        return m_pVec[i-1];
}
void Vector::SetKof(const size_t i,const double x )
{
        if (i > m_Dim)
        {
                cout<<szbuf.toOem("Неправильное значение ")<<endl;
                exit(-1);
        }
        m_pVec[i-1]=x;
}

void Vector::Show() const
{
        cout << '(';
        size_t i;
        for (i = 0; i < m_Dim; ++i)
        {
                cout << m_pVec[i];
                if (i < m_Dim - 1) cout << ", ";
        }
        cout << ')' << endl;
}

Vector::Vector(const size_t Dim,double* pVec):m_Dim(Dim) // к-ор с 2мя арг
{
        m_pVec=new double[Dim];
        if (!m_pVec)
        {
                cout <<szbuf.toOemA( "Ошибка! Неверный размер вектора." )<< endl;
                exit(-3);
        }
        for(int i=0;i<m_Dim;i++)
                m_pVec[i]=pVec[i];
}
Vector::Vector(size_t Dim):m_Dim(Dim) // к-ор с 1им арг
{
        m_pVec= new double[m_Dim];
        if (!m_pVec)
        {
                cout <<szbuf.toOemA( "Ошибка! Неверный размер вектора." )<< endl;
                exit(-1);
        }
        for(int i=0;i<m_Dim;i++)
                m_pVec[i]=0.0;
}

Vector::Vector():m_Dim(1) // к-ор без арг
{
        m_pVec=new double [m_Dim];
        if(!m_pVec) {
                cout<<"Error"<<endl;
                exit (-1);
        }      
}

Vector::Vector(const Vector& cv):m_Dim(cv.m_Dim) //конструктор копирования
{
        if (!(m_pVec=new double[m_Dim]))
        {
                cout<<szbuf.toOemA("Нет памяти") <<endl;
                exit(-1);
        }
        //копирование координат
        size_t i;
        for(i=0;i<m_Dim;++i)
                m_pVec[i]=cv.m_pVec[i];
        cout<<szbuf.toOemA("копия создана Vec") <<endl;
}
Vector::~Vector()
{
        cout << szbuf.toOemA("Вектор успешно удалён ...") << endl;
        delete[] m_pVec;

}
Polynom Poly2Vec(const Vector& cv)
{
        Polynom c(cv.m_Dim-1);
        for(int i=0; i < cv.m_Dim; ++i)
                c.m_Pol[i]=cv.m_pVec[i];
        return c;
}
Vector Vec2Poly(const Polynom& cc)
{
        //создадим объект класса вектор
        Vector v(cc.m_Dim);
        for(int i=0; i<cc.m_Dim; ++i)
                v.m_pVec[i]=cc.m_Pol[i];
        return v;
}
double Polynom::GetKof(const size_t i)
{
        if (i > m_Dim)
        {
                cout<<szbuf.toOem("Неправильное значение")<<endl;;
                exit(-1);
        }
        return m_Pol[i-1];
}
void Polynom::SetKof(const size_t i,const double x )
{
        if (i > m_Dim)
        {
                cout<<szbuf.toOem("Неправильное значение ")<<endl;
                exit(-1);
        }
        m_Pol[i]=x;
}
//Конструктор без аргументов
Polynom::Polynom(): m_Dim(0)
{      
        m_Dim=m_Dim+1;
        m_Pol=new double[m_Dim];    // Выделение памяти для Polynoma
        if(!m_Pol)
        {
                cout<<szbuf.toOem("Ошибка")<<endl;
                exit (-1);
        }      
        m_Pol[0]=0;
}
// Определение конструктора с 1 арг
Polynom::Polynom(const size_t Dim): m_Dim(Dim)
{
        {
                m_Dim=Dim+1;
                if(!m_Dim)
                {
                        cout<<szbuf.toOem("Ошибка")<<endl;
                        exit (-3);
                }
                if(!(m_Pol= new double[m_Dim+1]))
                {
                        cout<<szbuf.toOem("Ошибка")<<endl;
                        exit (-1);
                }
                size_t i;
                for(i=0; i <= m_Dim ; ++i)
                {
                        m_Pol[i]=i;
                }

        }
}
Polynom::Polynom(const size_t Dim,const double *mas):m_Dim(Dim)
{
        m_Dim=Dim+1;
        if(!m_Dim)
        {
                cout<<szbuf.toOem("Неверный размер")<<endl;
                exit(-3);
        }
        if(!(m_Pol= new double[m_Dim+1]))
        {
                cout<<szbuf.toOem("Нет памяти")<<endl;
                exit(-1);
        }
        size_t i;
        if(mas)
        {
                for(i=0; i <= m_Dim ; ++i)
                {
                        m_Pol[i]=mas[i];
                }
        }

}
//Конструктор копирования
Polynom::Polynom(const Polynom& Pol):m_Dim(Pol.m_Dim)
{      
        if (!(m_Pol=new double[m_Dim+1]))
        {
                cout<<szbuf.toOem("Нет памяти") <<endl;
                exit(-1);
        }
        for (int i=0; i < m_Dim; i++)
                m_Pol[i]=Pol.m_Pol[i];
        cout<<szbuf.toOem("копия Pol создана") <<endl;
}

Polynom::~Polynom()
{      
        cout << szbuf.toOem("Полином успешно удалён ...") << endl;
        delete[] m_Pol;
}

void Polynom::Show()const
{      
        size_t i;
        for(i=0;i<m_Dim-1;++i)
        {
                cout << m_Pol[i] << "*x^" << m_Dim-i-1;
                if(m_Pol[i+1]>=0)
                        cout << "+";
        }
        cout << m_Pol[m_Dim-1] << endl;
}
/*
void Polynom::Show()const
{
cout << m_Pol[0];
for (int i=1; i<m_Dim; ++i)
{
if(i!=0)
{
if (m_Pol[i] < 0)
cout << m_Pol[i]<<"*x^"<<i;
else cout << "+" << m_Pol[i] << "*x^" << i;
}
}
cout << endl;
}
*/


//////////////////    OPERATORI   /////////////////////////
///////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////


////////////////  Перегрузки 1
////////////////
Polynom::operator double *()
{
        return m_Pol;
}
////перегрузка унарного оператора "-"
Polynom Polynom::operator-()
{      
        size_t i;
        for (i=0; i<=m_Dim; ++i)
                m_Pol[i] = -m_Pol[i];
        return *this;
}

////////////////  Перегрузки 2
////////////////

// Оператор присваивания
Polynom & Polynom::operator=(const Polynom& no)
{
        if ( this != &no)
        {
                delete[] m_Pol;
                if (!(m_Pol=new double[m_Dim=no.m_Dim]))
                {
                        cout<<szbuf.toOem("Ошибка! Недостаточно памяти!")<<endl;;
                        exit(-1);
                }
                size_t i;
                for (i=0; i <= m_Dim; ++i)
                        m_Pol[i]=no.m_Pol[i];
        }
        return *this;

}
// Оператор присваивания, когда правая часть число
Polynom & Polynom::operator=(const double no)
{
        size_t i;
        for (i=0; i <= m_Dim; ++i)
                m_Pol[i]=no;
        return *this;
}
// Оператор присваивания cо сложением    
Polynom & Polynom::operator+=(const Polynom& no)
{
        if (&no != this)
        {
                size_t i,k,j;

                if (m_Dim > no.m_Dim)
                {
                        i = m_Dim;
                        k=no.m_Dim;
                }
                else
                {
                        i = no.m_Dim;
                        k = m_Dim;
                }

                double* new_Pol = new double[i];

                for(j=0; j<=k; ++j)
                        new_Pol[j] = m_Pol[j]+no.m_Pol[j];

                for(j=k; j<=i; ++j)
                        if (m_Dim > no.m_Dim)

                                new_Pol[j] = m_Pol[j];
                        else
                                new_Pol[j] = no.m_Pol[j];

                m_Pol = new_Pol;
                m_Dim = i;
        }
        return *this;
}
// Оператор присваивания cо сложением, когда правая часть число.
Polynom & Polynom::operator+=(const double no)
{
        size_t i;
        for (i=0; i <= m_Dim; ++i)
                m_Pol[i]+=no;
        return *this;
}
// Оператор присваивания c вычитанием
Polynom & Polynom::operator-=(const Polynom& no)
{
        if (&no != this)
        {
                size_t i,k,j;

                if (m_Dim > no.m_Dim)
                {
                        i = m_Dim;
                        k=no.m_Dim;
                }
                else
                {
                        i = no.m_Dim;
                        k = m_Dim;
                }

                double* new_Pol = new double[i];

                for(j=0; j<=k; ++j)
                        new_Pol[j] = m_Pol[j]-no.m_Pol[j];

                for(j=k; j<=i; ++j)
                        if (m_Dim > no.m_Dim)
                                new_Pol[j] = -m_Pol[j];
                        else
                                new_Pol[j] = -no.m_Pol[j];

                m_Pol = new_Pol;
                m_Dim = i;
        }
        return *this;
}
// Оператор присваивания c вычитанием, когда правая часть число.
Polynom & Polynom::operator-=(const double no)
{
        size_t i;
        for (i=0; i <= m_Dim; ++i)
                m_Pol[i]-=no;
        return *this;
}
//оператор присваивания с умножением
Polynom & Polynom::operator*=(const Polynom& no)
{
        if (&no != this)
        {
                size_t i,k,j,b,m;

                if (m_Dim > no.m_Dim)
                {
                        b = m_Dim;
                        m = no.m_Dim;
                }
                else
                {
                        b = no.m_Dim;
                        m = m_Dim;
                }


                Polynom new_Pol(b+m),
                        sum(new_Pol);

                for (i=0; i<=b+m; ++i)
                        sum[i]=0;

                for(i=0;i<=m;++i)
                {
                        for(k=0;k<=b+m;++k)
                                new_Pol[k]=0;

                        k=i;
                        for(j=0;j<=b;++j)
                        {
                                new_Pol[k] =  
                                        no.m_Pol[i]*m_Pol[j];
                                k++;
                        }
                        sum+=new_Pol;
                }
                *this=sum;
        }

        return *this;
}
//для случая,когда правый операнд число
Polynom & Polynom::operator*=(const double no)
{
        size_t i;
        for(i=0; i<=m_Dim; ++i)
                m_Pol[i] *= no;
        return *this;
}
//оператор возвидения в степень для случая,когда правый операнд число/
Polynom & Polynom::operator^=(const double no)
{
        size_t i;

        Polynom temp = *this;
        for (i=0;i<=m_Dim;++i)
        {
                temp*=*this;
                *this = temp;
        }
        return *this;
}

//Бинарный оператор присваивания с делением
//для случая,когда правый операнд число
Polynom & Polynom::operator/=(const double no)
{
        size_t i;
        for(i=0; i<=m_Dim; ++i)
                m_Pol[i] /= no;
        return *this;
}

////////////////////////////////
/////////Перегрузки 3///////////

void main()
{      

        Polynom p1;
        Polynom p2(4);
        double mass[4]={4,5,6,7};
        Polynom p3(3,mass);
        p1.Show();
        p2.Show();
        p3.Show();
        Polynom p4(p3);
        p4.Show();
        p4.SetKof(3,20);
        p4.Show();
        double per;                                
        per = p4.GetKof(3);
        cout << per << endl;



        double mass2[5]={-4,5,6,-0.77,0};
        Vector va3(5,mass2);
        va3.Show();
        Polynom toVec = Poly2Vec(va3); 
        Vector toPol = Vec2Poly(toVec);
        toVec.Show();
        toPol.Show();

        cout<<endl;

        cout <<szbuf.toOem("Использование оператора +:");
        +p1;
        p1.Show();
        cout <<szbuf.toOem("Использование оператора -:");
        -p1;
        p1.Show();

        cout<<endl;

        cout <<szbuf.toOem("Использование бинарного оператора =:");
        p1=p4;
        p1.Show();

        cout << szbuf.toOem("Использование бинарного оператора = когда правый операнд число(2):");
        double x=2;
        p1=x;
        p1.Show();

        cout <<szbuf.toOem("Использование бинарного оператора +=:");
        double mass3[]={1,1,1,0,2,10};
        Polynom p6(5,mass3);
        double mass4[]={4,3,100,100,30};
        Polynom p7(4,mass4);
        p6+=p7;
        p6.Show();

        cout << szbuf.toOem("Использование бинарного оператора += когда правый операнд число:");
        double y=3;
        p1+=y;
        p1.Show();

        cout <<szbuf.toOem("Использование бинарного оператора -=:");
        double mass6[]={1,1,1,0,2,10};
        Polynom p10(5,mass6);
        double mass7[]={4,3,100,100,30};
        Polynom p11(4,mass7);
        p11-=p10;
        p11.Show();

        cout << szbuf.toOem("Использование бинарного оператора -= когда правый операнд число:");
        double z=4;
        p1-=z;
        p1.Show();
        ///////////////////

        cout <<szbuf.toOem("Использование бинарного оператора =*:");
        double mass8[]={1,1,1}; // 1+ x + x^2
        Polynom p12(2,mass8);
        double mass9[]={1,2}; // 1+ 2x
        Polynom p13(1 ,mass9);

        p13*=p12;
        p13.Show();

        getch();

}
 

 Профиль  
                  
 
 Re: Класс полином.
Сообщение19.11.2009, 19:31 
Заслуженный участник


26/07/09
1559
Алматы
2inlaf
Сразу скажу, что не разобрался с вашим кодом. Но мне показалось странным присваивание sum[i]=0 в реализации перегруженного оператора *= учитывая объявления Polynom new_Pol(b+m), sum(new_Pol). Т.е., я так понимаю, для класса Polynom должен быть перегружен оператор [], но я его объявления/определения не нашел... Возможно просто запутался... Скомпилировать и проверить самостоятельно тоже не получилось...

 Профиль  
                  
 
 Re: Класс полином.
Сообщение24.11.2009, 21:01 


14/11/09
7
подскажите пжл. как правильней реализовать оператор присваивания числа свободному члену.
Polynom & Polynom::operator = (double op)
{
Polynom tmp(*this);
size_t i;
for (i=0; i < m_Dim; ++i)
{
tmp.m_Pol[0]=op;
m_Pol[i+1]+=tmp.m_Pol[0];
}
return *this;
}

 Профиль  
                  
 
 Re: Класс полином.
Сообщение24.11.2009, 21:33 
Заслуженный участник


26/07/09
1559
Алматы
Не понял вопроса. Почему не так:
Используется синтаксис C++
Polynom &Polynom::operator =(double op)
{
    delete[] m_Pol;
    m_Dim=0;
    m_Pol=new double[1];
    m_Pol[0]=op;

    return *this;
}
 

Я имел ввиду, что скаляр -- это ведь просто полином нулевой степени, то есть у такого полинома есть только свободное слагаемое. :)

У вас очень странный код...

 Профиль  
                  
 
 Re: Класс полином.
Сообщение24.11.2009, 23:05 


14/11/09
7
фейл.
крашится.
но если попробывать m_Pol=new double[m_Dim=1];
но я так понял, что он просто приравнивает полином числу 2.
мне же необходимо в многочлене заменить свободный член на заданный и вернуть многочлен.

 Профиль  
                  
 
 Re: Класс полином.
Сообщение25.11.2009, 00:29 
Заслуженный участник


26/07/09
1559
Алматы
Цитата:
фейл.
крашится.

Мне до сих пор непонятен смысл поля m_Dim. Но дело, кажется, в нём....

Цитата:
мне же необходимо в многочлене заменить свободный член на заданный и вернуть многочлен.

Используется синтаксис C++
    m_Pol[0]=op;
    return *this;
 

:) Кажется, вам нужно отдохнуть недельку от этого кода, а потом вернуться к нему и переписать с нуля... :)

-- Ср ноя 25, 2009 03:35:05 --

А под отладчиком где именно ошибка происходит, на какой строке?

 Профиль  
                  
 
 Re: Класс полином.
Сообщение25.11.2009, 10:22 


14/11/09
7
m_Dim - cтепень полинома.
m_Pol - кол-во коэфицентов.
т.е кол-во коэфицентов полинома равно m_Dim +1 .

 Профиль  
                  
 
 Re: Класс полином.
Сообщение27.11.2009, 00:19 
Заслуженный участник


26/07/09
1559
Алматы
Цитата:
m_Pol - кол-во коэфицентов.

Ну уж точно не количество. :)

 Профиль  
                  
 
 Re: Класс полином.
Сообщение06.12.2009, 18:51 
Заслуженный участник


27/04/09
28128
Зачем хранить и степень, и количество коэффициентов вместе?

 Профиль  
                  
Показать сообщения за:  Поле сортировки  
Начать новую тему Ответить на тему  [ Сообщений: 15 ] 

Модераторы: Karan, Toucan, PAV, maxal, Супермодераторы



Кто сейчас на конференции

Сейчас этот форум просматривают: нет зарегистрированных пользователей


Вы не можете начинать темы
Вы не можете отвечать на сообщения
Вы не можете редактировать свои сообщения
Вы не можете удалять свои сообщения
Вы не можете добавлять вложения

Найти:
Powered by phpBB © 2000, 2002, 2005, 2007 phpBB Group