I am having trouble with overloading the += operator when template
parameters are used. I have a class holding an array (called "derived"
in the following example) which derives from a base class ("base"). I
want to be able to add:
1) any derived array holding class to any other derived array holding
class
2) any derived array holding class to a literal value (e.g int, double,
etc) for which addition is defined for the type in the array.
I would like both + and += operators and for appropriate casting to be
handled. A minimal example of what I am trying to do is below (note
that the derived class holds only one value for simplicity).
The two + operators work fine with GCC (versions 3.4 and 4.1). But the
two += don't work when defined together (they work fine when defined
one at a time). When performing derived<L> += derived<R> the
operator+=(base<L,D>, R) is selected rather than operator+=(base<L,LD>,
base<R,RD>). Borland C++ Builder has this problem and a similar one
with the the binary addtion operator. I am really confused about GCC
because the operator prototypes are practically the same, so it would
seem that the the problem += and + operators are either both correct or
wrong.
Using operator+=(base<L,D>, L) works, but without automatic casting I
am after. Any suggestions on how to get around this problem, at least
in GCC would be great!
Example program (88 lines):
#include <iostream>
// curiously recurring base class
template <typename T, typename D>
class base
{
public:
T& operator[](std::size_t i) { return static_cast<D&>(*this)[i]; }
const T& operator[](std::size_t i) const { return static_cast<const
D&>(*this)[i]; }
};
// curiously recurring derived class
template <typename T>
class derived : public base<T, derived<T> >
{
public:
derived(T t) : t_(t) {}
T& operator[](std::size_t i) {return t_; }
const T& operator[](std::size_t i) const {return t_; }
private:
T t_;
};
// type promotion trait
template <typename L, typename R>
class promote
{
};
template<>
class promote<int, double>
{
public:
typedef double type;
};
// binary addition operators with casting
template <typename L, typename D, typename R>
derived<typename promote<L,R>::type>
operator+ (const base<L, D>& l, const R& r)
{
std::cout << "base + literal" << std::endl;
typedef typename promote<L,R>::type P;
return derived<P>(static_cast<P>(l[0]) + static_cast<P>(r));
}
template <typename L, typename DL, typename R, typename DR>
derived<typename promote<L,R>::type>
operator+ (const base<L, DL>& l, const base<R, DR>& r)
{
std::cout << "base + base" << std::endl;
typedef typename promote<L,R>::type P;
return derived<P>(static_cast<P>(l[0]) + static_cast<P>(r[0]));
}
// self-assigned addition
template <typename L, typename D, typename R>
void
operator+= (base<L, D>& l, const R& r)
{
std::cout << "base += literal" << std::endl;
l[0] += static_cast<L>(r);
return;
}
template <typename L, typename DL, typename R, typename DR>
void
operator+= (base<L, DL>& l, const base<R, DR>& r)
{
std::cout << "base += base" << std::endl;
l[0] += static_cast<L>(r[0]);
return;
}
int main()
{
derived<int> d1(2);
derived<double> d2 = d1 + 3.; // base + literal
derived<double> d3 = d1 + d2; // base + base
d3 += 3.; // base += literal
d2 += d3; // base += base
}
