ich bin mir unsicher, ob mein Denkansatz zur Kombination von Templates, Polymorphie und Operatorenüberladung falsch ist.

Ich versuche eine Funktion zu schreiben, der ich ein Objekt übergeben kann, dass sämtliche Datentypen enthalten kann, ohne eine Templatefunktion zu benutzen.

Hierzu eine Beispielklasse:

template<class t>
class testClass
{
	public:
		t& operator[](long int i)
		{
			return tArray[i];
		}
	private:
		t tArray[10];	
}

Einen Pointer auf ein Objekt dieser Klasse möchte ich jetzt einer Funktion übergeben, ohne zur Kompilierzeit zu wissen, welchen Datentyp t zur Laufzeit hat.

Ich habe nun versucht eine nicht-Template Klasse zu schreiben und die Beispielklasse von selbiger abzuleiten. Dadurch kann ich einen Pointer der übergeordneten Klasse, der auf ein Objekt der Beispielklasse zeigt übergeben. Das funktioniert allerdings nur solange ich keine Rückgabewerte des Datentyps t benötige (wie z.B. bei der Überladung des Indexopperators t&).

Gibt es eine Möglichkeit dies dennoch zu benutzen, oder muss ich in diesem Fall auf die Opperatorenüberladung verzichten?

C++ ist Typsicher, dass heisst, dass der Typ von einem Objekt sich nicht zur Laufzeit ändern kann.

Grüssli

t& operator[](long int i)
        {
            return tArray[i]; // nicht &tArray[i];
        }

Das Problem hat sich mittlerweile erledigt, aber ich erkläre trozdem nochmal was ich vor hatte. Ich wollte Elemente in einer Funktion vertauschen können, ohne vorher deren Datentyp zu kennen.

Gestern abend bin ich aber drauf gekommen wie ich mein Problem lösen kann:
Ich benutze statt

*(testObj)[0] = *(testObj)[1];

eine Methode, mit der ich zwei Elemente tauschen kann.

class Liste
{
	public:
		virtual void ArraySwitch(long int index1, long int index2) = 0;
};

template<class t>
class tplListe : public Liste
{
	public:
		void ArraySwitch(long int index1, long int index2)
		{
			//tmp = tArray[index1];
			//tArray[index1] = tArray[index2];
			//tArray[index2] = tmp;
			std::cout << "Switched : " << index1 << " " << index2 << std::endl;
		}
	private:
		t tArray[10];
		t tmp;
};

void testFunc(Liste* p1, long int i, long int j);

int main()
{
	Liste * TplListe1 = new tplListe<int>();

	testFunc(TplListe1,1,2);

    system("PAUSE");
    return EXIT_SUCCESS;
}

void testFunc(Liste* p1, long int i, long int j)
{
	p1->ArraySwitch(i,j);
}

Damit klappt alles so, wie ich wollte.
Vielen Dank an alle, die sich die Zeit genommen haben mir zu helfen.

Aber ist eigentlich auch egal was ich zum lernen programmiere, da es sowieso für fast alles Bibliotheken gibt.

So ist es eigentlich auch sinnfrei, dass ich Bubble- und Quicksort programmiert hab

So ist es eigentlich auch sinnfrei, dass ich Bubble- und Quicksort programmiert hab

Naja, der Punkt ist, dein Ansatz ist falsch...

Und was meinst du damit genau?

schau dir std::swap an und dann schau dir deine lösung an.

du brauchst keine klassen, virtuelle funktionen, etc. du brauchst einfach nur templates. der typ der variablen steht nämlich zur compilezeit fest.