Operator overloading with templates

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
}