Класс полином.

[inlaf]

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

Используется синтаксис 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=(Polynom &no); 
        Polynom & operator=(double no); 
        Polynom & operator+=(Polynom &no); 
        Polynom & operator+=(double no); 
        Polynom & operator-=(Polynom &no); 
        Polynom & operator-=(double no); 
        Polynom & operator*=(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=(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=(double no) 
{
        size_t i;
        for (i=0; i <= m_Dim; ++i)
                m_Pol[i]=no;
        return *this;
}
// Оператор присваивания cо сложением     
Polynom & Polynom::operator+=(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;
                }
                
                //Polynom new_Pol(i);
                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+=(double no) 
{
        size_t i;
        for (i=0; i < m_Dim; ++i)
                m_Pol[i]+=no;
        return *this;
}
// Оператор присваивания c вычитанием
Polynom & Polynom::operator-=(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-=(double no) 
{
        size_t i;
        for (i=0; i < m_Dim; ++i)
                m_Pol[i]-=no;
        return *this;
}
//оператор присваивания с умножением
Polynom & Polynom::operator*=(Polynom & no) 
{
    if (&no != this)
    {
        size_t i,k,j,m_B,m_M;
 
        if (m_Dim > no.m_Dim)
        {
            m_B = m_Dim;
            m_M = no.m_Dim;
        }
        else 
        {
            m_B = no.m_Dim;
            m_M = m_Dim;
        }
                
                 Polynom new_Pol(m_B+m_M-1),
                                         sum(new_Pol);
 
                for(k=0;k <= m_B+m_M-1; ++k)
                
                                new_Pol[k]=0;
                
                *this = new_Pol;
        
        for(i=0; i < m_M;++i)
        {
                        k=i;
            for(j=0;j < m_B;++j)
            {
                new_Pol[k] = m_Pol[j] * no.m_Pol[i];
             k++;
            }
           sum+=new_Pol;
                }
                *this = sum;
        }
        return *this;
}
//для случая,когда правый операнд число
Polynom & Polynom::operator*=(double no) 
{
        size_t i;
        for(i=0; i<m_Dim; ++i)
                m_Pol[i] *= no;
        return *this;
}
//оператор возвидения в степень для случая,когда правый операнд число/
Polynom & Polynom::operator^=(double no)
{
        size_t i;
        for(i=0; i<m_Dim; ++i)
                m_Pol[i] = pow(m_Pol[i],no);
        return *this;
}
 
//Бинарный оператор присваивания с делением
//для случая,когда правый операнд число
Polynom & Polynom::operator/=(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[]={3,1,5};  // 3 + x + 5x^2 
        Polynom p12(2,mass8);
        double mass9[]={1,3}; // 1 + 3x
        Polynom p13(1,mass9);
 
        p13*=p12;
        p13.Show();
 
        getch();
}
 

[worm2]

inlaf писал(а):

Используется синтаксис C++

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

Вроде, перед началом цикла по j надо бы обнулить многочлен new_Pol.

[Nerazumovskiy]

(Оффтоп)

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

[venco]

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

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

(Оффтоп)

Nerazumovskiy в сообщении #261970 писал(а):

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

Нажмите кнопку [развернуть].

[worm2]

Nerazumovskiy писал(а):

(Оффтоп)

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

(Оффтоп)

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

[venco]

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

[inlaf]

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

}
 

[Circiter]

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

[inlaf]

подскажите пжл. как правильней реализовать оператор присваивания числа свободному члену.
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;
}

[Circiter]

Не понял вопроса. Почему не так:

Используется синтаксис C++

Polynom &Polynom::operator =(double op)
{
    delete[] m_Pol;
    m_Dim=0;
    m_Pol=new double[1];
    m_Pol[0]=op;

    return *this;
}
 

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

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

[inlaf]

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

[Circiter]

Цитата:

фейл.
крашится.

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

Цитата:

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

Используется синтаксис C++

    m_Pol[0]=op;
    return *this;
 

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

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

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

[inlaf]

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

[Circiter]

Цитата:

m_Pol - кол-во коэфицентов.

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

[arseniiv]

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