Template + Polymorphie + Operatorenüberladung - Theoriefrage

DMosig

Hallo Forenmitglieder,

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?

Firefighter

Zeig mal deinen bisherigen Code bitte.

Dravere

Du kannst zur Laufzeit keine Klassentemplates überreichen, nur Templateklassen.
Oder anders gesagt, deine präsentierte Klasse, kannst du zur Laufzeit nur übergeben, wenn du auch einen Typen für t definiert hast.

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

Grüssli

Ist da nicht ein Fehler im Code?
Der Rückgabewert des operator[] ist t&, aber du gibst eine Adresse von t zurück.
Müsste es nicht heißen:

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

DMosig

Danke sdfsdfsdds, da hat sich bei meinem Beispiel ein kleiner Fehler eingeschlichen. Ich habe es mal korrigiert.

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.

Braunstein

Kennst du std::swap?

DMosig

Jetzt ja

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

Shade Of Mine

DMosig schrieb:

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

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

DMosig

Und was meinst du damit genau?

Shade Of Mine

DMosig schrieb:

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.