Numere complexe in C++

Ti-am rescris clasa ca template asa cum s-a sugerat mai sus. Am modificat putin si unii din operatori ca sa poti inlantui operatiile (de ex z=x+=y sau x=y=z). Am pus toata implementarea in header deoarece la template compilatorul are nevoie de implementarea clasei cand face instantierea (se genereaza o noua clasa in functie de tipul cu care faci instantierea). Am mai modificat operatorul != sa returneze

!(*this==number)

, astfel daca vrei sa modifici implementarea lui == si != e suficient sa modifici ==. La fel e indicat sa faci la operatori relationali (<,>,<=,>=). Am mai pus la template float ca default. Am adaugat

return stream

la operatorii <<,>>, pentru ca lipsea. Am modificat putin pe fuga asa ca va rog sa imi atrageti atentia daca am gresit pe undeva.

LE: Am adaugat si operatorii unari si am eliminat

using namespace std

#ifndef _COMPLEXNUMBERS_H__
#define _COMPLEXNUMBERS_H__
#include <iostream>
template <typename T=float>
class ComplexNumber
{
typedef ComplexNumber<T> _Cplx;
public:
ComplexNumber() :a(0), b(0){};
ComplexNumber(float a, float  :a(a), b({}
virtual ~ComplexNumber(){}
void SetReal(float a)
{
  this->a = a;
}
void SetImaginary(float 
{
  this->b = b;
}
T GetReal() const
{
  return a;
}
T GetImaginary() const
{
  return b;
}
bool operator==(const _Cplx& number)
{
  return ((a == number.a) && (b == number.);
}
bool operator!=(const _Cplx& number)
{
  return !(*this == number);
}
_Cplx& operator=(const _Cplx& number)
{
  a = number.a;
  b = number.b;
  return *this;
}
_Cplx& operator+=(const _Cplx& number)
{
  a += number.a;
  b += number.b;
  return *this;
}
_Cplx operator-=(const _Cplx& number)
{
  a -= number.a;
  b -= number.b;
  return *this;
}
_Cplx operator*=(const _Cplx& number)
{
  T copyReal = a;
  a = a*number.a - b*number.b;
  b = b*number.a + copyReal*number.b;
  return *this;
}
_Cplx operator/=(const _Cplx& number)
{
  _Cplx a = number * !number;
  *this = (*this * !number) / a;
  return *this;
}
_Cplx operator+(const _Cplx& number)
{
  return _Cplx(a + number.a, b + number.;
}
_Cplx operator-(const _Cplx& number)
{
  return _Cplx(a - number.a, b - number.;
}
_Cplx operator*(const _Cplx& number) const
{
  return _Cplx(a * number.a - b * number.b, a * number.b + b * number.a);
}
_Cplx operator/(const _Cplx& number) const
{
  _Cplx a(*this);
  _Cplx conjugate = !number;
  a *= conjugate;
  _Cplx b = number * conjugate;
  a /= b.GetReal();
  return a;
}
_Cplx& operator++()
{
  ++a;
  return *this;
}
_Cplx& operator--()
{
  --a;
  return *this;
}
_Cplx operator++(int)
{
  _Cplx number(*this);
  ++*this;
  return number;
}
_Cplx operator--(int)
{
  _Cplx number(*this);
  --*this;
  return number;
}
_Cplx& operator+=(T value)
{
  a += value;
  return *this;
}
_Cplx& operator-=(T value)
{
  a -= value;
  return *this;
}
_Cplx& operator/=(T value)
{
  a /= value;
  b /= value;
  return *this;
}
_Cplx& operator*=(T value)
{
  a *= value;
  b *= value;
  return *this;
}
_Cplx operator+(T value)
{
  _Cplx other(a, ;
  other[0] += value;
  return other;
}
_Cplx operator-(T value)
{
  ComplexNumber other(a, ;
  other[0] -= value;
  return other;
}
_Cplx operator*(T value)
{
  _Cplx other(a, ;
  other[0] *= value;
  other[1] *= value;
  return other;
}
_Cplx operator/(T value)
{
  _Cplx other(a, ;
  other[0] /= value;
  other[1] /= value;
  return other;
}
_Cplx operator-()
{
  return _Cplx(-a, -;
}
_Cplx operator+()
{
}
_Cplx operator!() const
{
  return _Cplx(a, -;
}
void power(int p)
{
  _Cplx copy(*this);
  for (int i = 1; i < p; i++)
   *this *= copy;
}
T operator[](int position)
{
  if (position == 0)
   return a;
  if (position == 1)
   return b;
  throw invalid_argument("Indice gresit!\n");
}
const T& operator[](int position) const
{
  if (position == 0)
   return a;
  if (position == 1)
   return b;
  throw invalid_argument("Indice gresit!\n");
}
protected:
T a, b;
};
template <typename T>
std::ostream& operator<<(std::ostream& stream, ComplexNumber<T>& number)
{
stream << number.GetReal();
if (number.GetImaginary() >= 0.0)
  stream << "+";
stream << number.GetImaginary() << "i";
return stream;
}
bool checkNumber(std::string& str)
{
int i, length = str.length();
for (i = 0; i < length; i++)
  if (str[i] != '-' && str[i] != '+' && str[i] != '.' && str[i] != 'i' &&
   (str[i] < '0' || str[i] > '9'))
   return false;
for (i = 0; i < length - 1; i++)
  if (str[i] == str[i + 1] && str[i] == '.')
   return false;
int noOfSigns = 0;
for (i = 1; i < length; i++)
  if (str[i] == '-' || str[i] == '+')
   noOfSigns++;
if (noOfSigns > 1)
  return false;
if (noOfSigns == 1 && str[length - 1] != 'i')
  return false;
return true;
}
template <typename T>
std::istream& operator>>(std::istream& stream, ComplexNumber<T>& number)
{
std::string str;
stream >> str;
while (!checkNumber(str)) {
  cout << "Introdu un numar complex valid: ";
  stream >> str;
}
int positive, pos = 1, length = str.length();
if (str[0] == '-')
  positive = 0;
else {
  if (str[0] == '+')
   positive = 1;
  else {
   positive = 1;
   pos = 0;
  }
}
std::string real;
int i = pos;
while (str[i] != '-' && str[i] != '+' && i < length) {
  real.push_back(str[i]);
  i++;
}
int length_real = real.length();
std::string::size_type sz;
if (real[i - 1 - pos] != 'i') {
  if (positive)
   number.SetReal(stof(real, &sz));
  else
   number.SetReal(-stof(real, &sz));
  if (i < length) {
   if (str[i] == '-')
	positive = 0;
   else
	positive = 1;
   i++;
   real = std::string("");
   while (str[i] != 'i' && i < length) {
	real.push_back(str[i]);
	i++;
   }
   if (positive)
	number.SetImaginary(stof(real, &sz));
   else
	number.SetImaginary(-stof(real, &sz));
  }
}
else {
  if (positive)
   number.SetImaginary(stof(real, &sz));
  else
   number.SetImaginary(-stof(real, &sz));
}
}
template <typename T>
ComplexNumber<T> power(ComplexNumber<T>& number, int p);
#endif

Edited by nightmare392, 07 December 2014 - 18:04.