kurz und knapp:

template <typename T>
class Base{
	protected:
		T insert(int loc, T val){
			return val;
		}

		T base_insert(int loc, T val){
			return val;
		}
};

template <typename T>
class Derived : public Base<T>{
	public:
		class I;

		T insert(I i, T val){
			return this->insert(i.i, val); // geht nicht
			return this->base_insert(i.i, val); // geht
			return Base<T>::insert(i.i, val); // geht
		}
};

template <typename T>
class Derived<T>::I{
	public:
		int i;
};

int main(int argc, char *argv[]){
	Derived<int> d1;
	Derived<int>::I i1;

	int x1 = d1.insert(i1, 1);
}

Warum zur Hölle findet der Compiler das insert(int, T) der Basisklasse nicht von selbst?

Warum zur Hölle findet der Compiler das insert(int, T) der Basisklasse nicht von selbst?

vermutlich weils vom insert(int,T) der abgeleiteten klasse verdeckt wird, denn T=int bei deinem test.

Warum zur Hölle findet der Compiler das insert(int, T) der Basisklasse nicht von selbst?

Weil du bereits ein neues insert in der abgeleiteten Klasse deklariert hast und das ganze ein abhängiger Aufruf ist. Schau dich mal im Netz nach templates und depentdant name lookup um.

maximAL schrieb:

Warum zur Hölle findet der Compiler das insert(int, T) der Basisklasse nicht von selbst?

vermutlich weils vom insert(int,T) der abgeleiteten klasse verdeckt wird, denn T=int bei deinem test.

Die abgeleitete Klasse hat aber kein insert(int, T), sondern insert(I, T), deshalb wundert mich ja das Problem.

Die abgeleitete Klasse hat aber kein insert(int, T), sondern insert(I, T), deshalb wundert mich ja das Problem.

Überladung funktioniert nur im gleichen Scope. Die abgeleitete Klasse hat einen anderen Scope als die Basisklasse, daher gibt es keine Überladung sondern eine Überdeckung.

Grüssli

OK, danke, auch wenn die Sache wiedermal sehr unbefriedigend ist

Vielleicht gibt es dir Befriedigung, wenn ich dir sage, dass du eine Funktion in einen Scope reinziehen kannst, über die using Anweisung. Schreib deine Derived Klasse folgendermassen um:

template <typename T>
class Derived : public Base<T>{
    public:
        class I;

        using Base<T>::insert;
        // Dies zieht alle Funktionen mit dem Namen insert
        // aus Base<T> in diesen Scope rein. Die Überladung
        // sollte dann funktionieren.

        T insert(I i, T val){
            return this->insert(i.i, val); // geht nicht
            return this->base_insert(i.i, val); // geht
            return Base<T>::insert(i.i, val); // geht
        }
};

Grüssli