класс полином

[inlaf]

посмотрите пжл. операторы =,+=, когда правый операнд число.

и у меня вопрос по оператору += для 2ух полиномов. сомневаюсь я серавно в правильности его работы.)

еще вопрос как правильней реализовать диффиринцал полинома, когда полином задан конструктором с одним аргументом.

Код: Выделить всё

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]))
		{
			cout<<szbuf.toOem("Ошибка")<<endl;
			exit (-1);
		}
		size_t i;
		for(i=0; i < m_Dim ; ++i)
		{
			m_Pol[i]=i;
		}

	}
}

Код: Выделить всё

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

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

// Оператор присваивания
Polynom & Polynom: :o perator=(const Polynom &ob)
{
	if (this != &ob)
	{
		delete[] m_Pol;

		if (!(m_Pol=new double[m_Dim=ob.m_Dim]))
		{
			cout<<szbuf.toOem("Ошибка! Недостаточно памяти!")<<endl;;
			exit(-1);
		}
		size_t i;

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

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

		double* new_Pol = new double[i];

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

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

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

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

		double* new_Pol = new double[i];

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

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

		m_Pol = new_Pol;
		m_Dim = i;
	}
	return *this;
}
// Оператор присваивания c вычитанием, когда правая часть число.
Polynom & Polynom: :o perator-=(double po) 
{
	Polynom tmp(*this);
	size_t i;
	for (i=0; i <= m_Dim; ++i)
		tmp.m_Pol[0]-=po;
	return tmp;
}
//оператор присваивания с умножением
Polynom & Polynom: :o perator*=(const Polynom &poly)
{
	Polynom tmp(m_Dim-1,m_Pol);
	m_Dim=tmp.m_Dim+poly.m_Dim-1;

	delete [] m_Pol;

	if(!(m_Pol= new double[m_Dim])) 
	{
		cout << szbuf.toOemA("Ошибка! Недостаточно памяти!") << endl;
		exit(-1);
	}
	size_t i,j;

	for(i=0;i<m_Dim;++i)
	{
		m_Pol[i]=0;
	}
	for(i=0; i < tmp.m_Dim; i++)
	{
		for(j=0; j < poly.m_Dim; j++)
		{
			m_Pol[i+j] += tmp.m_Pol[i]*poly.m_Pol[j];
		}
	}
	return *this;
}

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

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

//Бинарный оператор присваивания с делением
//для случая,когда правый операнд число
Polynom & Polynom: :o perator/=(double op)
{
	if (op!=0)
	{
		size_t i;
		for(i=0; i<=m_Dim; ++i)
			m_Pol[i] /= op;
		return *this;
	}
	else cout<<szbuf.toOem("На ноль делить нельзя")<<endl;
}

[inlaf]

Код: Выделить всё

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

//Бинарный арифметический оператор +
Polynom operator+(const Polynom &ob1, const Polynom &ob2)
{
	Polynom temp(ob1);
	return temp+=ob2;
}
//Бинарный арифметический оператор +
//для случая,когда правый операнд число
Polynom operator+(const Polynom &ob1, double op2)
{
	Polynom temp(ob1);
	return temp+=op2;
}

//Бинарный арифметический оператор сложения, когда правый операнд число.
Polynom operator+(double op1, const Polynom &ob2)
{
	Polynom temp(ob2);
	return temp+=op1;
}
//Бинарный арифметический оператор -
Polynom operator-(const Polynom ob1, const Polynom ob2)
{
	Polynom temp(ob1);
	return temp-=ob2;
}
//Бинарный арифметический оператор -
//для случая,когда правый операнд число
Polynom operator - (const Polynom ob1, double op2)
{
	Polynom temp(ob1);
	return temp-=op2;
}
//Бинарный арифметический оператор - , когда правый операнд число.
Polynom operator - (double op1,const Polynom &ob2)
{
	Polynom temp(ob2);
	return temp-=op1;
}
//Бинарный арифметический оператор *
Polynom operator * (const Polynom &ob1,const Polynom &ob2)
{
	Polynom temp(ob1);
	return temp*=ob2;
}
//Бинарный арифметический оператор *
//для случая,когда правый операнд число
Polynom operator * (const Polynom &ob1, double op2)
{
	Polynom temp(ob1);
	return temp*=op2;

}
//Бинарный арифметический оператор * , когда правый операнд число.
Polynom operator * (double op1,const Polynom &ob2)
{
	Polynom temp(ob2);
	return temp*=op1;

}
//Бинарный арифметический оператор /
//для случая,когда правый операнд число
Polynom operator / (const Polynom ob1, double op2)
{
	Polynom temp(ob1);
	return temp/=op2;

}
//Бинарный арифметический оператор ^
//для случая,когда правый операнд число
Polynom operator^(const Polynom &ob1, int op2)
{
	Polynom temp(ob1);
	return temp^=op2;

}
////////////////////////////////
/////////Перегрузки 4///////////
////////////////////////////////
//Бинарный логический оператор ==
bool operator==(const Polynom &ob1,const Polynom &ob2)
{
	if(ob1.m_Dim!=ob2.m_Dim)
	{
			return false;

			for(size_t i=0; i<=ob1.m_Dim; ++i)
	{
		if(ob1.m_Pol[i] != ob2.m_Pol[i])
		{
			return false;
		}
	}
		return true;
	}
}
bool operator==(const Polynom &ob1, double op1)
{
    	size_t i;
		for(i=0; i<=ob1.m_Dim; ++i) 
	{
		if(ob1.m_Pol[i] != op1)
		{
			return false;
		}
	}
	return true;
}
//Бинарный логический оператор !=
bool operator!=(const Polynom &ob1,const Polynom &ob2)
{
	return !(ob1 == ob2);
}

bool operator!=(const Polynom &ob1, double op1)
{
	return !(ob1==op1);
}
double &Polynom: :o perator[](const size_t i) const
{
	if (i <= m_Dim)
		return m_Pol[i];
	else
		cout<<szbuf.toOem("Ошибка!")<<endl;
	exit(-1);        
}

//Операторы Ввода Вывода
istream & operator >>(istream &ris, Polynom &rs)
{
	for (size_t i(0); i<rs.m_Dim; i++)
		cin>>rs.m_Pol[i];
	return ris;
}
ostream & operator <<(ostream &ros, const Polynom cz)
{
	cz.Show();
	return ros;
}

Polynom Polynom::derivative() const
{
	Polynom tmp;
	size_t n = m_Dim;

	if (n > 0)
	{
		tmp.m_Pol = new double [n];
		tmp.m_Dim = (n-1);

		for(int i=0; i < n; i++)
		{
			tmp.m_Pol[i]=(i+1)*m_Pol[i+1];
		}
		return tmp;
	}
	else 
		cout<<szbuf.toOem("Степень полинома должна быть выше нуля")<<endl;exit(-2);
}

double Polynom::evaluate(double x) const
{
	double sum = m_Pol[0];
	double pow = x;
	for(size_t i = 1; i < m_Dim ;++i)
	{
		sum += m_Pol[i]*pow;
		pow *= x;
	}
	return sum;
}

[Ктулху]

Код: Выделить всё

// Оператор присваивания, когда правая часть число
Polynom & Polynom: :o perator=(double op) 
{
    Polynom tmp(*this);
    size_t i;
    for (i=0; i < m_Dim; ++i)
     {
    tmp.m_Pol[0]=op;
    m_Pol[i]+=tmp.m_Pol[0];
     }
    return *this;
}

на самом деле равно

Код: Выделить всё

// Оператор присваивания, когда правая часть число
Polynom & Polynom: :o perator=(double op) 
{
    for (size_t i = 0; i < m_Dim; ++i)
     {
     m_Pol[i] += op;
     }
    return *this;
}

что за "Бинарный арифметический оператор ^" ?
не слыхал о таком

во всех операторов ""операция" с присваиванием" необходимо передустмотреть else для if(&ob != this)
например для +=

Код: Выделить всё

[...]
else {
   for(size_t i = 0; i < m_Dim; ++i)
     m_Pol[i] += m_Pol[i];
}

в operator+=() {} отсутствует delete [] m_Pol до присваивания m_Pol = new_Pol

З.Ы. объем кода переопределия операций может сократится и исчезнет дубликация кода, если сделать преобразование double в Poynom
З.З.Ы. программы запускать надо. тогда исчезнут синтаксичексие ошибки