Russian Qt Forum

C++ (Qt)
class Number
{
    /* ... */
public:
    virtual Number& operator +(Number& n) = 0;
    /* ...  */
}
 
class PNumber : public Number
{
   /* ... */
private:
    int acc;
public:
    PNumber& operator +(Number& n);
   /* ... */
}
 

C++ (Qt)
    virtual Number& Number::operator +(Number& n) = 0;
    ...
    PNumber& PNumber::operator +(Number& n);
 

C++ (Qt)
Number& PNumber::operator +(Number& n)
{
 PNumber * n2 = dynamic_cast <PNumber *> (n);
 if (!n2) assert(0);
 // складываем
 return *this;
}
 

C++ (Qt)
// обычная операция
  int a, b c;
  с = a + b;
 
// теперь все то же но с классами
 friend PNumber operator + ( const PNumber & pn1, const PNumber & pn2 );
 
  PNumber a, b c;
  с = a + b;
 

C++ (Qt)
Nump *n = new PNumb();
Nump *n1 = new PNumb();
n = n + n1;
 

C++ (Qt)
// базовый класс
class Number {
 Number & operator += ( const Number & n1 )  // сам оператор не виртуальный
 {
    return DoVirtalInc(n1);  // но вызывает виртуальный метод
 }
 
 virtual Number & DoVirtalInc( const Number & n1 ) = 0;
};
 
// порожденный класс
class PNumber {
 PNumber & operator += ( const PNumber & n1 )  // обычный не виртуальный оператор
 {
    acc += n1.acc;  // складываем
    return *this;
 }
 
 virtual Number & DoVirtalInc( const Number & n1 ) 
 {
   PNumber * pn1 = dynamic_cast <PNumber *> (&n1); 
   if (pn1) *this += *pn1;
   return *this;
 }
};
 

C++ (Qt)
class TANumber
{
    ...
    virtual TANumber& operator + (TANumber& B) = 0;
 

C++ (Qt)
class TReal : public TANumber
{
    ...
    virtual TReal&  operator + (TANumber& B);
};
 

C++ (Qt)
class TReal : public TANumber
{
    ...
    virtual TNumber &  operator + (TANumber& B);
};
 

C++ (Qt)
virtual bool    operator == (TANumber& B);
 

C++ (Qt)
virtual bool operator == (const TANumber& B) const;
 

C++ (Qt)
class Number
{
public:
    Number() : _x(0) {}
    Number(int x) : _x(x) {}
    Number &operator+(const Number &x) {
        _x += x._x;
        return *this;
    }
    friend std::ostream& operator<<(std::ostream&, const Number&);
    //friend const Number operator+(const Number&, const Number&);
private:
    int _x;
};
 
std::ostream& operator<<(std::ostream& out, const Number& x) {
    out << x._x;
    return out;
}
 
/*
const Number operator+(const Number&x1, const Number &x2) {
    return Number(x1._x + x2._x);
}
*/
 
Number n1 = 1;
Number n2 = 2;
 
Number n3 = n1+(1+n2);
 
cout << n3 << endl;
 
 

C++ (Qt)
class TPNumber
{
   /* .......... */
   TPNumber operator +(const TPNumber &p1);
   /* .......... */
}
 
TPNumber TPNumber::operator +(const TPNumber &p1)
{
        return TPNumber(this->number + p1.number, this->sistemaSchisleniya, this->tochnost);
}
 

C++ (Qt)
Number x = 1;
NumberF y = 3.14;
 
NumberF sum = x + y; // Внимание сюда!
 

C++ (Qt)
Number *n1 = new NumberF(3.14);
Number *n2 = new NumberF(2.71);
 
*n2 = *n2 + *n1; 
 

C++ (Qt)
TPNumber TPNumber::operator +(const TPNumber &p1)
{
        return TPNumber(this->number + p1.number, this->sistemaSchisleniya, this->tochnost);
}
 

C++ (Qt)
TPNumber TPNumber::operator +(const TPNumber &p1) const
 

C++ (Qt)
#include <fstream>  
 
class PNumber {
 ...
};
 

C++ (Qt)
class Number
{
   /* ... ... ... */
public:
    virtual Number& operator =(Number &n) = 0;
    virtual Number& operator +(Number &n) = 0;
    /* ... ... ... */
};
 
class PNumber : public Number
{
   /* ... ... ... */
    Number& operator =(Number &p1);
    Number& operator +(Number &p1);
   /* ... ... ... */
};
 
Number& PNumber::operator +(PNumber &p1)
{
    PNumber *pn;
    Number *n = &p1;
    pn = dynamic_cast<PNumber *>(n);
    pn->number += this->number;
    return *pn;
}
 

C++ (Qt)
enum NumberType {TNumberInt, TNumberF};
 
class Sum;
 
class Number
{
public:
    virtual ~Number() {}
    virtual NumberType type() const = 0;
    virtual Number& operator=(const Number&) = 0;
    virtual Number& operator=(const Sum&) = 0;
};
 
class Sum
{
public:
    Sum(const Number& x1, const Number& x2) : _x1(x1), _x2(x2) {}
    const Number& x1() const { return _x1; }
    const Number& x2() const { return _x2; }
    NumberType type() const { return _x1.type(); }
private:
    const Number& _x1;
    const Number& _x2;
};
 
 
class NumberInt : public Number
{
public:
    NumberInt() : _x(0) {}
    NumberInt(int x) : _x(x) {}
 
    virtual NumberType type() const { return TNumberInt; }
 
    virtual Number& operator=(const Number&x) {
        if (x.type() != TNumberInt)
            throw "error!";
 
        const NumberInt& num = static_cast<const NumberInt&>(x);
        _x = num._x;
        return *this;
    }
 
    virtual Number& operator=(const Sum& s) {
        if (s.type() != TNumberInt)
            throw "error!";
 
        const NumberInt& i1 = static_cast<const NumberInt&>(s.x1());
        const NumberInt& i2 = static_cast<const NumberInt&>(s.x2());
        _x = i1._x + i2._x;
        return *this;
    }
 
    friend const NumberInt operator+(const NumberInt&, const NumberInt&);
    friend std::ostream& operator<<(std::ostream&, const NumberInt&);
private:
    int _x;
};
 
 
std::ostream& operator<<(std::ostream& out, const NumberInt& x) {
    out << x._x;
    return out;
}
 
const Sum operator+(const Number& x1, const Number& x2) {
    return Sum(x1, x2);
}
 
const NumberInt operator+(const NumberInt& x1, const NumberInt& x2) {
    return NumberInt(x1._x + x2._x);
}
 
 
int main()
{
    Number *n1 = new NumberInt(1);
    Number *n2 = new NumberInt(2);
 
    *n1 = *n2 + *n2;
 
    cout << static_cast<const NumberInt&>(*n1);
 
    return 0;
}
 

C++ (Qt)
struct Number {
  virtual const Number* add(const Number* other) const = 0;
};
 
// Собственно операции с "числами"
Number* add(const Number* x, const Number* y) {
  return x->add(y);
}
...
// Реализация двойной деспеччиризации
struct Int;
struct Rational;
struct Real;
 
struct Int : Number {
  virtual const Number* add(const Number* other) const {
    return other->addInt(this);
  }
 
  const Int* addInt(const Int* other) const {
    return new Int(val + other->val);
  }
  const Rational* addRational(const Rational* other) const {
    return other->addInt(this);
  }
  const Real* addReal(const Real* other) const {
    return other->addInt(this);
  }
  int get_val() const {
    return val;
  }
  private:
    int val;
};
 
struct Rational : Number {
  virtual const Number* add(const Number* other) const {
    return other->addRational(this);
  }
 
  const Rational* addInt(const Int* o) const {
    return new Rational(nom + denom * o->get_val(), denom);
  }
  const Rational* addRational(const Rational* o) const {
    return Rational(nom * o->denom + o->nom + denom, denom * o->denom);
  }
  const Real* addReal(const Real* other) const {
    return other->addRational(this);
  }
  private:
    int nom, denom;
};
...
 

C++ (Qt)
struct CTest1 {
	CTest1( void ) : mA(1) {}
	virtual CTest1 & operator + ( CTest1 & src ) = 0;
	virtual CTest1 & Func( void ) = 0;
 
// data	
	int mA;
};
 
struct CTest2 : public CTest1 {
	virtual CTest2 & operator + ( CTest1 & src )
	{
		mA += src.mA;
		return *this;
	}
 
	virtual CTest2 & Func( void )
	{
		++mA;
		return *this;
	}
};
 
int main(int argc, char **argv)
{ 
	CTest2 a, b;
	b = a.Func();
	a = a + b;
	return 0;
}
 

C++ (Qt)
virtual TReal &  TReal::operator + (TNumber& B);   // ну "очень странный" оператор +
virtual TReal TReal::operator + (const TNumber& B) const;  // "нормальный" оператор +
 

C++ (Qt)
virtual TReal & TReal::operator + (const TNumber& B) const;  
 

C++ (Qt)
pn = dynamic_cast<PNumber *>(n);
if (!pn) assert(0);    // добавьте эту строчку
 

C++ (Qt)
pn = dynamic_cast<PNumber *>(n);
if (!pn) assert(0);
 

C++ (Qt)
assert(pn != 0);

C++ (Qt)
virtual TReal &  TReal::operator + (TNumber& B);   // ну "очень странный" оператор +
virtual TReal TReal::operator + (const TNumber& B) const;  // "нормальный" оператор +
 

C++ (Qt)
virtual TReal &  TReal::operator + (TNumber& B);   // ну "очень странный" оператор +
 

C++ (Qt)
class TANumber
{
public:
    virtual ~Number() {}
    virtual TANumber& operator+(TANumber&) = 0;
//...
};
 

C
struct SomeNumber;
 
struct BaseNumber {
  virtual const BaseNumber& operator + (const BaseNumber&) const = 0;
  protected:
    virtual const BaseNumber& add_to(const BaseNumber&) const {throw std::bad_cast();}
    virtual const SomeNumber& add_to(const SomeNumber&) const = 0;
};
struct SomeNumber : BaseNumber {
  virtual const SomeNumber& operator + (const BaseNumber& other) const {
    return other.add_to(*this);
  }
  protected:
    virtual const SomeNumber& add_to(const SomeNumber&) const;
};
 

C++ (Qt)
Number& PNumber::operator +(PNumber &p1)
 

struct AllNumber {
  const AllNumber operator + (const AllNumber& other) const {
    return AllNumber(val.get()->add(other.val.get()));
  }
  private:
    std::auto_ptr<Number> val;
};

C++ (Qt)
struct CFractNumber : public CBaseNumber {
  CFractNumber & operator + (const CBaseNumber & other) const 
  {
    assert(dynamoc_cast <const CFactNumber *> &other) != 0);
    CFractNumber & result = mBuf[mBufCount];
    result = *this;
    mBufCount = (mBufCount + 1) % BUF_SIZE;
    return result += other;
  }
 
  private:
    static int mBufCount = 0;
    static CFractNumber mBuf[BUF_SIZE];
 
    enum {
      BUF_SIZE = 256,
    };
};
 

C++ (Qt)
c = a + b;
 

C++ (Qt)
AbstractNumber *n1 = new RealNumber(3.14);
AbstractNumber *n2 = new RealNumber(2.71);
 
*n1 = *n2 + *n1;
 

C++ (Qt)
RealNumber n1(3.14);
RealNumber n2(2.71);
 
n1 = n2 + n1; 
 

C++ (Qt)
class Number
{
public:
 // ...
    virtual Number& operator +(Number &n) = 0;
    virtual Number& operator -(Number &n) = 0;
    virtual Number& operator /(Number &n) = 0;
    virtual Number& operator *(Number &n) = 0;
//...   
};
 

C++ (Qt)
Number *n1 = new TANumber;
Number *n2 = new TANumber;
 
*n1 = *n1 + *n2;
*n1 = *n1 - *n2;
*n1 = (*n1) * (*n2);
// ...
// и даже так:
TANumber n1;
TANumber n2;
 
n1 = n1 + n2;
n1 = n1 - n2;
// ...
 

C++ (Qt)
struct CFractNumber : public CBaseNumber {
  CFractNumber & operator + (const CBaseNumber & other) const 
  {
    assert(dynamoc_cast <const CFactNumber *> &other) != 0);
    CFractNumber & result = mBuf[mBufCount];
    result = *this;
    mBufCount = (mBufCount + 1) % BUF_SIZE;
    return result += other;
  }
 
  private:
    static int mBufCount = 0;
    static CFractNumber mBuf[BUF_SIZE];
 
    enum {
      BUF_SIZE = 256,
    };
};
 

C++ (Qt)
CFractNumber fun1(const CFractNumber& init, int cnt) {
  CFractNumber& res = init + init;
  for (int i = 0; i < cnt - 1; ++i)
    res = res + init;
  return res;
}
// или чуть подругому:
CFractNumber fun2(const CFractNumber& init, int cnt) {
  const CFractNumber& first = init + init;
  CFractNumber res = first;
  for (int i = 0; i < cnt - 1; ++i)
    res = res + init + first;
  return res;
}
//И где-то в коде:
CFractNumber b = fun1(a, 1000);
CFractNumber d = fun2(c, 1000);