Developing.ru

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

template <class T> class Vector
{  
private:
        size_t m_Dim;                                           // Размер вектора.
        T* m_pVec;                                              //адрес массива с координатами вектора
public:
        Vector(size_t, T*);                             //конструктор с 2-мя параметром
        Vector(size_t);                                         //конструктор с 1-им параметром
        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;      // Вывод вектора.
};

template <class T> Vector<T>::double Vector::GetKof(const size_t i)
{
        if (i > m_Dim)
        {
                cout<<szbuf.toOem("Неправильное значение")<<endl;;
                exit(-1);
        }
        return m_pVec[i-1];
}
template <class T> Vector<T>::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;
}
template <class T> Vector<T>::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;
}
template <class T> Vector<T>::Vector(const size_t Dim, T*):m_Dim(Dim) 
{
        m_pVec=new T[Dim];
        if (!m_pVec)
        {
                cout <<szbuf.toOemA( "Ошибка! Неверный размер вектора." )<< endl;
                exit(-3);
        }
        for(int i=0;i<m_Dim;i++)
                m_pVec[i]=pVec[i];
}
template <class T> Vector<T>::Vector(size_t Dim):m_Dim(Dim) // к-ор с 1им арг
{
        m_pVec= new T[m_Dim=Dim];
        if (!m_pVec)
        {
                cout <<szbuf.toOemA( "Ошибка! Неверный размер вектора." )<< endl;
                exit(-1);
        }
        for(int i=0;i<m_Dim;i++)
                m_pVec[i]=0.0;
}
template <class T> Vector<T>::Vector():m_Dim(0) // к-ор без арг
{ 
        m_pVec=new T[m_Dim+1];
        if(!m_pVec)
        {
                cout<<"Error"<<endl;
                exit (-1);
        }       
}
template <class T> Vector<T>::Vector(const Vector& cv):m_Dim(cv.m_Dim) //конструктор копирования
{
        if (!(m_pVec=new T[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;
}
template <class T> Vector<T>::~Vector()
{
        cout << szbuf.toOemA("Вектор успешно удалён ...") << endl;
        delete[] m_pVec;
}

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

	template <class T> Vector<T> Vector<T>: :o perator+();
	template <class T> Vector<T> Vector<T>: :o perator-();
	template <class T> Vector<T> & Vector<T> operator+=(const Vector<T> &ob); 
	template <class T> Vector<T> & Vector<T> operator+=(T op); 
	template <class T> Vector<T> & Vector<T> operator-=(const Vector<T> &ob);
	template <class T> Vector<T> & Vector<T> operator-=(T op); 
	template <class T> Vector<T> & Vector<T> operator*=(const Vector<T> &vec);
	template <class T> Vector<T> & Vector<T> operator*=(T op); 
	template <class T> Vector<T> & Vector<T> operator^=(int op);
	template <class T> Vector<T> & Vector<T> operator/=(T op);
	template <class T> friend Vector<T> operator+(const Vector<T> &ob1, const Vector<T> &ob2);
	template <class T> friend Vector<T> operator+(const Vector<T> &ob1,T op1);
	template <class T> friend Vector<T> operator-(const Vector<T> ob1, const Vector<T> ob2);
	template <class T> friend Vector<T> operator-(const Vector<T> ob1, T op2);
	template <class T> friend Vector<T> operator*(const T &ob1,const T &ob2);
	template <class T> friend Vector<T> operator*(const T &ob1, T op1);
	template <class T> friend Vector<T> operator/(const T &ob1, T op1);
	template <class T> friend Vector<T> operator^(const T &ob1, int op1);

	template <class T> friend Vector<T> & Vector<T>operator=(const Vector<T> &ob);
	template <class T> friend Vector<T> & Vector<T>operator=(T op); 

	friend bool operator==(const Vector<T> &ob1,const Vector<T> &ob2);
	friend bool operator==(const Vector<T> &ob1, T op1);
	friend bool operator!=(const Vector<T> &ob1,const Vector<T> &ob2);
	friend bool operator!=(const Vector<T> &ob1, T op1);

	double &Vector<T>: :o perator[](const size_t i) const;

	friend istream & operator >>(istream &ris, Vector<T> &rs);
	friend ostream & operator << (ostream &ros, const Vector<T> &cz);

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

template <class T> Vector<T> Vector<T>: :o perator+()
{
	return *this;
}
template <class T> Vector<T> Vector<T>: :o perator-()
{
	size_t i;
	for(i=0;i <= m_Dim; ++i)
		m_pVec[i]=-m_pVec[i];
	return *this;
}

template <class T> Vector<T> & Vector<T>: :o perator+=(const Vector<T> &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;
		}

		T* new_Vec = new T[i];

		for(j=0; j<=k; ++j)
			new_Vec[j] = m_pVec[j]+ob.m_pVec[j];

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

		m_pVec = new_Pol;
		m_Dim = i;
	}
	return *this;
}
template <class T> Vector<T> & Vector<T>: :o perator-=(const Vector<T> &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;
		}

		T* new_Vec = new T[i];

		for(j=0; j<=k; ++j)
			new_Vec[j] = m_pVec[j]-ob.m_pVec[j];

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

		m_pVec = new_Pol;
		m_Dim = i;
	}
	return *this;
}

template <class T> Vector<T> & Vector<T>: :o perator-=(T op) 
{
	size_t i;
	for(i=0; i<=m_Dim; ++i)
		m_pVec[i] -= op;
	return *this;
}
template <class T> Vector<T> & Vector<T>: :o perator+=(T op) 
{
	size_t i;
	for(i=0; i<=m_Dim; ++i)
		m_pVec[i] += op;
	return *this;
}
template <class T> Vector<T> & Vector<T>: :o perator*=(const Vector<T> &vec)
{
	Vector<T> tmp(m_Dim,m_pVec);
	m_Dim=tmp.m_Dim+vec.m_Dim;

	delete [] m_pVec;

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

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

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

template <class T> Vector<T> & Vector<T>: :o perator*=(T op) 
{
	size_t i;
	for(i=0; i <= m_Dim; ++i)
		m_Pol[i] *= op;
	return *this;
}

template <class T> Vector<T> & Vector<T>: :o perator^=(int op)
{
	if (op > 0)
	{
		size_t i;

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

template <class T> Vector<T> & Vector<T>: :o perator/=(T op)
{
	if (op!=0)
	{
		size_t i;
		for(i=0; i<=m_Dim; ++i)
			m_pVec[i] /= op;

		return *this;	
	}
	else cout<<szbuf.toOem("На ноль делить нельзя")<<endl;
}

template <class T> Vector<T> operator+(const Vector<T> &ob1, const Vector<T> &ob2)
{
	Vector<T> temp(ob1);
	return temp+=ob2;

}

template <class T> Vector<T> operator+(const Vector<T> &ob1, T op1)
{
	Polynom temp(ob1);
	return temp+=op1;

}

template <class T> Vector<T> operator-(const Vector<T> ob1, const Vector<T> ob2)
{
	Vector<T> temp(ob1);
	return temp-=ob2;

}

template <class T> Vector<T> operator-(const Vector<T> ob1, T op1)
{
	Vector<T> temp(ob1);
	return temp-=op1;

}

template <class T> Vector<T> operator * (const Vector<T>  &ob1,const Vector<T>  &ob2)
{
	Polynom temp(ob1);
	return temp*=ob2;
}

template <class T> Vector<T> operator * (const Vector<T> &ob1, T op2)
{
	Vector<T> temp(ob1);
	return temp*=op2;
}

template <class T> Vector<T> operator / (const Vector<T> ob1, T op2)
{
	Vector<T> temp(ob1);
	return temp/=op2;
}

template <class T> Vector<T> operator^(const Vector<T> &ob1, int op2)
{
	Vector<T> temp(ob1);
	return temp^=op2;
}
template <class T> Vector<T> & Vector<T>: :o perator=(const Vector<T> &ob)
{
	if (this != &ob)
	{
		delete[] m_pVec;

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

		for (i=0; i <= m_Dim; ++i)
			m_pVec[i]=ob.m_pVec[i];
	}
	return *this;
}

template <class T> Vector<T> & Vector<T>: :o perator=(T op) 
{
	*this=op;
	return *this;
}

bool operator==(const Vector<T> &ob1,const Vector<T> &ob2)
{
	if(ob1.m_Dim!=ob2.m_Dim)
	{
		return false;

		for(size_t i=0; i<=ob1.m_Dim; ++i)
		{
			if(ob1.m_pVec[i] != ob2.m_pVec[i])
			{
				return false;
			}
		}
		return true;
	}
}
bool operator==(const Vector<T> &ob1, T op1)
{
	size_t i;
	for(i=0; i<=ob1.m_Dim; ++i) 
	{
		if(ob1.m_pVec[i] != op1)
		{
			return false;
		}
	}
	return true;
}

bool operator!=(const Vector<T> &ob1,const Vector<T> &ob2)
{
	return !(ob1 == ob2);
}

bool operator!=(const Vector<T> &ob1, T op1)
{
	return !(ob1 == op1);
}

double &Vector<T>: :o perator[](const size_t i) const
{
	if (i <= m_Dim)
		return m_pVec[i];
	else
		cout<<szbuf.toOem("Ошибка!")<<endl;
	exit(-1);        
}

istream & operator >>(istream &ris, Vector<T> &rs)
{
	for (size_t i(0); i <= rs.m_Dim; i++)
		cin>>rs.m_pVec[i];
	return ris;
}
ostream & operator << (ostream &ros, const Vector<T> &cz)
{
	cz.ShowVec();
	return ros;
}