struct a{};
//Die Basisklasse aller Klassen in dieser Hierarchie; vom Template-Typen unabhängig; macht nichts besonderes, sondern dient lediglich der Identifikation

template<typename T>
struct b : a{};
//Hier sind je nach Typ T Dinge drin, die für die abgeleiteten Klassen interessant sind

template<typename T>
struct c : b<T>{};
template<typename T>
struct d : b<T>{};
//Gibt noch 'ne Menge mehr, hier einfach mal exemplarisch zwei Stück

template<typename L, typename R>
struct add_helper {
	L l;
	R r;
	add_helper(const L &l, const R &r) : l(l), r(r) {}
	//Schlussendlich stecken hier dann einige interessante Dinge drin, die mit l und r operieren
};

template<typename L, typename R, typename = typename std::enable_if<std::is_base_of<a, L>::value && std::is_base_of<a, R>::value>::type>
add_helper<L, R> operator+ (const L &l, const R &r)
{
	return add_helper<L, R>(l, r);
}

int main()
{
	some_l33t_func(c<int>(...) + d<float>(...));
}

Kann das Konflikte geben mit anderen überladenen Operatoren? Wie würdet ihr sowas machen? Das Ziel ist es nur, dass ich einen operator$ habe für beliebige von a abgeleitete Typen, der nur so eine Helper-Klasse zurückgibt.

template<typename L, typename R, typename std::enable_if<std::is_base_of<a, L>::value && std::is_base_of<a, R>::value, int>::type = 0>
add_helper<L, R> operator+ (const L &l, const R &r)
{
    return add_helper<L, R>(l, r);
}

Auf diese Weise ist die Bedingung teil der Signatur des Templates, so dass es keine Probleme bereit, den operator noch anderweitig mit einer anderen Bedingung zu überladen.

Kann das Konflikte geben mit anderen überladenen Operatoren?

Das kann nur Konflikte mit anderen überladenen Operatoren ergeben, wenn du diese so auslegst, dass sie auch auf von a abgeleitete Klassen operieren. Ist einer der beiden Operanden nämlich nicht (sichtbar) von a abgeleitet, wird die Spezialisierung gar nicht zum Candidate Set hinzugefügt.

Edit: Frage hat sich geklärt.