Help with operator overloading

[Zilla]

I have the following simple program. I just want to be able to do math
operations (+, -, =)on Timer sublcasses, but want to handle cases
where either rhs or lhs is an intrinsic value, However, the compile
fails in my g++ 2.95 compiler during the 2nd to last line of the
main() with

template.cpp: In function `int main()':
template.cpp:24 : `operator +<int>(int, const int &)' must have an
argument of class or enumerated type
template.cpp: In method `int & Timer::operator +<int>(const int &)':
template.cpp:97 : instantiated from here
template.cpp:42 : request for member `_value' in `t', which is of non-
aggregate type `int'
template.cpp:43 : static_cast from `Timer *' to `int *'

Seems like the operator+(T& t) function is being called, instead of
the operator+(int) function. Why?
#include <iostream.h>

class Timer {
template<class T>
friend T& operator+(const int value, const T& t);
public:
Timer();
~Timer();

template<class T>
T& operator+(const T& t);
template<class T>
T& operator+(const int value);
template<class T>
T& operator=(const T& t);
template<class T>
T& operator=(const int value);

int _value;
};

template<class T>
T& operator+(const int value, const T& t)
{
static T temp(value);
temp._value=t._ value+value;
return temp;
}

Timer::Timer()
{
}

Timer::~Timer()
{
}

template<class T>
T& Timer::operator +(const T& t)
{
// T* This=dynamic_ca st<T*>(this);
this->_value+=t._val ue;
return *(static_cast<T *>(this));
}

template<class T>
T& Timer::operator +(const int value)
{
T* This=dynamic_ca st<T*>(this);
This->_value+=valu e;
return *This;
}

template<class T>
T& Timer::operator =(const T& t)
{
T* This=dynamic_ca st<T*>(this);
This->_value=t.value ;
return *This;
}

template<class T>
T& Timer::operator =(const int value)
{
T* This=dynamic_ca st<T*>(this);
This->_value=value ;
return *This;
}

class tRCD : public Timer {
public:
tRCD(const int value);
~tRCD();
};

tRCD::tRCD(cons t int value)
{
_value=value;
}

tRCD::~tRCD()
{
}

int main()
{
tRCD trcd1(1);
cout << "trcd1._val ue: " << trcd1._value << endl;
tRCD trcd2(2);
cout << "trcd2._val ue: " << trcd2._value << endl;
trcd1=trcd1+trc d2;
cout << "trcd1._val ue: " << trcd1._value << endl;
trcd1=1+trcd1;
cout << "trcd1._val ue: " << trcd1._value << endl;
trcd1=5;
cout << "trcd1._val ue: " << trcd1._value << endl;
// trcd1.operator= (trcd1.operator +(1));
trcd1=trcd1+1;
cout << "trcd1._val ue: " << trcd1._value << endl;
return 0;
}

[Zilla]

On Mar 23, 8:37 am, "Zilla" <zill...@bellso uth.netwrote:

On Mar 22, 5:33 pm, "Victor Bazarov" <v.Abaza...@com Acast.netwrote:

Zillawrote:

On Mar 22, 4:06 pm, "Victor Bazarov" <v.Abaza...@com Acast.netwrote:
>[..]

> class D1 : public A<D1{ // derived one
> public:
> // constructors are not inherited, so you need one here
> D1(int v) : A<D1>(v) {}
> };

> class D2 : public A<D2{ // derived two
> public:
> // constructors are not inherited, so you need one here
> D2(int v) : A<D2>(v) {}
> };
>[..]

>Would that work? Use it as a starting point.

>V

Thanks, so far it worked for these test cases. It's scary how the
compiler knows how to implement the "=" operation. I'll code it so as
NOT to leave it to chance.

int main()
{
D1 d33(1);
D1 d22(1);
D1 d11=d33;
cout << "d11.value: " << d11.getVal() << endl;
d11=1;
cout << "d11.value: " << d11.getVal() << endl;
d11 = d11 + 1;
cout << "d11.value: " << d11.getVal() << endl;
d11 = 1 + d11;
cout << "d11.value: " << d11.getVal() << endl;
d11 = d22 + d11;
cout << "d11.value: " << d11.getVal() << endl;
return 0;
}

Just to bring it to your attention: it is important to not get the
types mixed up when copy-pasting your code. The class 'D1' is
defined as deriving from 'A<D1>' and 'D2' is from 'A<D2>'. This
is known as CRTP, IIRC. If when you define some 'D3' you make it
derive from 'A<D2>', the stuff can start going wrong and it might
be difficult to find. Or maybe not... Good luck!

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask- Hide quoted text -

- Show quoted text -

Thanks. Yes I noticed this right off. I'm playing with this code now,
and even trying out the straight-forward use of the template, ie,
without the class declarations inheritting the template.

class D1 {
blah()

};

class D2 {
blah()

};

int main()
{
A<D1d1;
A<D2d2;
d1=blah...

}- Hide quoted text -

- Show quoted text -- Hide quoted text -

- Show quoted text -

Ok, I was having problems with your example, so I went back to basics.
I stripped it down to the following code for operator=() only. I can't
even get it to compile...

g++ -c timers.cpp

timers.cpp: In function `int main()':
timers.cpp:35: no match for `tRCD & = double'
timers.cpp:30: candidates are: class tRCD & tRCD::operator =(const
tRCD &)

Why isn't the Timer<T>::opera tor=(...) being seen?

#include <iostream>

////////////////////////////////////////////////////////
// Base class that defines ALL the operations
template<class T>
class Timer {
public:
Timer();
T& operator=(const double v);

double _min;
};

template<class T>
Timer<T>::Timer () : _min(0)
{
}

template<class T>
T& Timer<T>::opera tor=(const double v)
{
// do something
}

class tRCD : public Timer<tRCD{
public:
tRCD() : Timer<tRCD>() {}
~tRCD() {}
};

int main()
{
tRCD t1;
t1=3.0;
cout << "t1.min: " << t1._min << endl;
}

[Victor Bazarov]

Zilla wrote:

On Mar 23, 8:37 am, "Zilla" <zill...@bellso uth.netwrote:

>On Mar 22, 5:33 pm, "Victor Bazarov" <v.Abaza...@com Acast.netwrote:

>>Zillawrote:
On Mar 22, 4:06 pm, "Victor Bazarov" <v.Abaza...@com Acast.net>
wrote:
[..]

>>>> class D1 : public A<D1{ // derived one
public:
// constructors are not inherited, so you need one here
D1(int v) : A<D1>(v) {}
};

>>>> class D2 : public A<D2{ // derived two
public:
// constructors are not inherited, so you need one here
D2(int v) : A<D2>(v) {}
};
[..]

>>>>Would that work? Use it as a starting point.

>>>>V

>>>Thanks, so far it worked for these test cases. It's scary how the
compiler knows how to implement the "=" operation. I'll code it so
as NOT to leave it to chance.

>>>int main()
{
D1 d33(1);
D1 d22(1);
D1 d11=d33;
cout << "d11.value: " << d11.getVal() << endl;
d11=1;
cout << "d11.value: " << d11.getVal() << endl;
d11 = d11 + 1;
cout << "d11.value: " << d11.getVal() << endl;
d11 = 1 + d11;
cout << "d11.value: " << d11.getVal() << endl;
d11 = d22 + d11;
cout << "d11.value: " << d11.getVal() << endl;
return 0;
}

>>Just to bring it to your attention: it is important to not get the
types mixed up when copy-pasting your code. The class 'D1' is
defined as deriving from 'A<D1>' and 'D2' is from 'A<D2>'. This
is known as CRTP, IIRC. If when you define some 'D3' you make it
derive from 'A<D2>', the stuff can start going wrong and it might
be difficult to find. Or maybe not... Good luck!

>>V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask- Hide
quoted text -

>>- Show quoted text -

Thanks. Yes I noticed this right off. I'm playing with this code now,
and even trying out the straight-forward use of the template, ie,
without the class declarations inheritting the template.

class D1 {
blah()

};

class D2 {
blah()

};

int main()
{
A<D1d1;
A<D2d2;
d1=blah...

}- Hide quoted text -

- Show quoted text -- Hide quoted text -

- Show quoted text -

Ok, I was having problems with your example, so I went back to basics.
I stripped it down to the following code for operator=() only. I can't
even get it to compile...

>g++ -c timers.cpp

timers.cpp: In function `int main()':
timers.cpp:35: no match for `tRCD & = double'
timers.cpp:30: candidates are: class tRCD & tRCD::operator =(const
tRCD &)

Why isn't the Timer<T>::opera tor=(...) being seen?

#include <iostream>

////////////////////////////////////////////////////////
// Base class that defines ALL the operations
template<class T>
class Timer {
public:
Timer();
T& operator=(const double v);

double _min;
};

template<class T>
Timer<T>::Timer () : _min(0)
{
}

template<class T>
T& Timer<T>::opera tor=(const double v)
{
// do something
}

class tRCD : public Timer<tRCD{
public:
tRCD() : Timer<tRCD>() {}
~tRCD() {}
};

int main()
{
tRCD t1;
t1=3.0;
cout << "t1.min: " << t1._min << endl;
}

The assignment operator from the base class is hidden by the
assignment operator from the derived class. You need to add
a line with 'using' in it to the 'tRCD' class.

The next thing is to decide what your Timer<T>::opera tor=
is going to return. I am not sure how you're going to handle
that, since you can't really return *this (the usual value
returned from the assignment op).

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask