C++ Zwei Klassen unter einen Hut bringen!

[Nuts-S]

Hallo,
ich habe ein Problem, ich habe zwei Klassen, in denen fast das gleiche steht, sind von der selben Basisklasse abgeleitet.
Nun habe ich das Problem, dass ich beide Klassen in die selbe Liste aufnehmen muss.

Ich habe bereits versucht mit einem Template das ganze zu machen, aber ich glaube ich habe noch nicht so richtig verstanden wie man dieses benutzt

//welche Rolle spielt der Teil in den Klammern? kommen da jetzt die möglichen Datentypen rein, oder ein virtueller, den ich mir dann zurechtlege?

template<class Fach> class F
{
private:
	Fach* m_fach;
	int m_size;
public:
	F(int size=20){m_size=size;m_fach=new Fach[m_size];}
	~F(void){delete [] m_fach;}
};
class Regal
{
private:
	bool belegung[10][20];
	F** regal;
	F* t_regal;
	int m_size;
public:
                Regal(bool type);
};

Regal::Regal(bool type)
{
	if(type)
		t_regal=new F<Ton>[m_size];
	else
		t_regal=new F<Bild>[m_size];
}

Bild und Ton sind die beiden Klassen.

Es wäre sehr nett, wenn sich jemand um das Wirrwarr in meinem Kopf kümmern könnte!
Vielen Dank im voraus.

 

[thooomy]

ööhm also ich weiss nicht ganz was du genau machen willst
aber mit templates ist denk ich der falsche Ansatz (da muss immer genau
das gleiche drinnen stehen)

wie immer empfehle ich bei solchen dingen diesen link:
http://www.cpp-tutor.de/cpp/toc.htm

 

[Tobias K.]

moin


Ich glaube das Thema gab es hier schon mal


mfg
umbrasaxum

 

[Endurion]

A) Wenn du von einer gemeinsamen Basis abgeleitete Klassen in irgendeinen Container packen willst, sollte der vom Typ der Basis sein. In dem Fall kannst du dann auch nicht die Klassen direkt reinsetzen, sondern musst Pointer benutzen.

B) Mit der STL bekommst du eine wundervolle Sammlung an fertigen Template-Containern, die dir viel Arbeit abnehmen.

Ich weiss nicht, wie die Basisklasse von Ton und Bild bei dir heisst, ich nenne sie mal Basis.
So wie das bei dir aussieht, willst du eigentlich keine Liste im klassischen Sinn, sondern ein dynamisches Array. Dafür gibt's in der STL den std::vector. Das könnte dann so aussehen:

#include <vector>

class Regal
{
private:
	bool belegung[10][20];
  std::vector<Basis*>    m_Inhalt;
public:
};

Um jetzt dein Regal zu füllen:

// du kannst alle Objekte reinpacken, die von Basis abgeleitet sind
// WICHTIGE VORAUSSETZUNG: virtueller Destruktor in Basis

m_Inhalt.push_back( new Ton );
m_Inhalt.push_back( new Bild );

// auslesen
for ( size_t i = 0; i < m_Inhalt.size(); ++i )
{
  m_Inhalt[i]->VirtuelleFunktionVonBasis();
}

Achtung: Der Container hat keine Ahnung von Pointern, deshalb musst du die eingetragenen Elemente selbst wieder deleten:

std::vector<Basis*>::iterator  it( m_Inhalt.begin() );
while ( it != m_Inhalt.end() )
{
  Basis*  pBasisObjekt = *it;
  delete pBasisObjekt;
  
  ++it;
}
m_Inhalt.clear();

Das ist nur ein grober Abriss, mach dich mal über die STL schlau, da ist eine Menge praktischer Sachen drin enthalten. Die Syntax ist gelegentlich gewöhnungsbedürftig, aber die Funktionalität ist es wert.


Manchmal hab ich zuviel Zeit...

 

[Nuts-S]

Vielen Danke für die sehr umfassende Antwort. Ich bin inzwischen auch auf die STL gestossen und lese mir alles durch.
Ist nicht ganz einfach zu schlucken, wenn man das alles zu erstenmal ließt!

Danke auch an thooomy, die Seite ist echt gut!
Entschuldigung an umbrasaxum, habe vorher gesucht, aber nicht lange, das gebe ich zu!