class vbEngine
{
public:

	vbEngine();
	vbEngine(CDatabase &db, bool remove);

	bool GetMannschaft(int id, vector<vbMannschaft*> *mannschaft);
	vbMannschaft *GetMannschaft(int id);

private:

	bool CreateDefaultDatabase(CDatabase &db);

	bool LoadDataFromDatabase(CDatabase &db);

	bool RemoveDatabase(CDatabase &db);

	bool ExecuteSQL(CDatabase &db, LPCTSTR sql);

	string ConvertIntToString(int value);

	vector<vbLiga*> pVectorLiga;
	vector<vbMannschaft*> pVectorMannschaft;
	vector<vbSpieler*> pVectorSpieler;
	vector<vbSpiel*> pVectorSpiel;
};

class vbLiga : public vbEngine
{
public:

	vbLiga(string name, int aufsteiger, int absteiger, int id);

	int GetAufsteiger();
	int GetAbsteiger();
	int GetId();	
	string GetName();

	bool ErzeugeSpielplan();
private:

	int iAufsteiger, iAbsteiger, iId;
	string sName;

};

Die Funktion ErzeugeSpielplan ruft eine Funktion der Basisklasse auf auf. Diese verwendet KLassenvaribalen. das komische erfolt der aufruf von einer abgeleiteten klasse bekomme ich inder funktion für dei anzahl der elemente in einem vector pVectorMannschaft immer 0. Ansonsten ist es ein werte größer 0 was auch richtig ist. kann mir jemand das erklären

das komische erfolt der aufruf von einer abgeleiteten klasse bekomme ich inder funktion für dei anzahl der elemente in einem vector pVectorMannschaft immer 0

Nachdem ich das dreimal gelesen hab vermute ich, dass ich in etwa verstanden hab was du meinst. Wäre aber trotzdem schön wenn du dir die Mühe machen könntest demnächst etwas lesbares zu schreiben. Einmal auf Rechtschreibung prüfen und wohlwollend mit einem Satzzeichen-Verteiler drübergehen schadet nicht.

Was dien Problem angeht: Du zeigst uns ne Menge Deklarationen - mehr als nötig, um genau zu sein. Andererseits zeigst du nicht eine einzige Definition. Damit kann dir keiner sagen was schief läuft, weil niemand sehen kann was du da machst.

Poste uns bitte nochmal Code, und zwar mit folgenden Eigenschaften:
- vollständig, d.h. er compiliert und erzeugt dein problem
- minimal, d.h. nichts unnötiges was nichts mit dem Problem zu tun hat.

bool GetMannschaft(int id, vector<vbMannschaft*> *mannschaft);

- definiert in der klasse vbEngine.
der Aufruf erfolgt in der klasse vbLiga :

bool vbLiga::ErzeugeSpielplan()
{

	// Erzeuge eine Spielplan 
	cout<<iId<<"\n";
	vector<vbMannschaft*> vTeams;
	GetMannschaft(iId,&vTeams);

	cout<<vTeams.size()<<"\n";

	/*// Wenn es keine gerade Anzahl an Mannschaften gibt.
	if (vTeams.size() % 2 != 0)
		return false;

	int iMAx = vTeams.size() - 1;

	for (int j = 0; j < iMAx; j++)
	{
		for (int i = 0; i < vTeams.size() / 2; i++)
		{
		//	vbContest *temp = new vbContest(vTeams[i],vTeams[iMAx - i],);
		}

		// Sichere den letzen Eintrag
		vbTeam *temp = vTeams[vTeams.size() -2];

		// Rotiere die Mannschaften
		for (int k = vTeams.size() - 2; k > 0; k--)
		{
			vTeams[k] = vTeams[k -1];
		}

		// Schreibe den letzten an erste Stelle
		vTeams[0] = temp;
	}*/
	return true;
}

So un nun unertscheidet sich die größe des übergegenen Vector : Die größe ist 0 wenn die funktion aus vbLiga aufgerufen wird - oder die größe ist 140 wenn ich die Funktion

GetMannschaft

aus der basisklasse selbst aufrufe.
Hier ist noch der code der funktion.

bool vbEngine::GetMannschaft(int id, vector<vbMannschaft*> *mannschaft)
{	
	int k = 0; 
	for (int i = 0; i < pVectorMannschaft.size(); i++)
	{
		if (pVectorMannschaft[i]->GetLigaId() == id)
		{
			mannschaft->push_back(pVectorMannschaft[i]);
			k++;
		}
	}

	cout<<"Anza : "<<pVectorMannschaft.size()<<"\n";

	return true;
}

ich vermnute mal das es probleme gibt wenn auf die private elemente einer basisklasse zugegriffen wird über eine public funktion

Dann noch die Antworten für die durhaus berechtigten Fragen meines Vorposters, und danach solltest du dir mal unbedingt das C++-Buch deiner Wahl schnappen und dich über den Sinn und die Verwendung von Referenzen informieren. Hier einen pointer auf den Mannschaftsvector zu übergeben ist eher C-Stil, zudem prüfst du nichtmal ob er NULL ist in GetMannschaft() (Die Überprüfung ist bei Referenzen nicht notwendig).

Ich kenne durchaus noch Menschen die, die ungarische Notation hochhalten, aber selbst damit ist mir das Präfix unklar - Und vermutlich wäre ein sprechender Namensraum verständlicher. Und auch das "p" vor den Vektornamen ist weder UN noch imho sinnvoll (der vector selber ist ja kein Zeiger, sondern enthält nur solche).

5. Mir ist der Sinn dieser Hierarchie unklar.

Liga ist eine Engine? mhhh... Das bezweifel ich doch mal.
Zudem - wenn ich deine Basisklasse richtig verstehe - machst du hier sehr viele Daten und Codeduplikationen. Ich bezweifel das dies ein sinnvolles Design ist, hatte es aber imho schon in einen deiner Vorthreads erwähnt.

Öffentliche Vererbung sollte möglichst nur verwendet werden, wenn man wirklich guten Gewissens sagen kann das "ist ein" erfüllt ist. Ansonsten ist Komposition "enthält ein" oder "verwendet ein" (Sprich: Statt von Engine abzuleiten, die Engine als Membervariable [Je nach Verwendung: Wert, Referenz oder Zeiger] halten) wartbarer.

2. Die Gestaltung folgender Methode halte auch ich für wenig intuitiv:

bool GetMannschaft(int id, vector<vbMannschaft*> *mannschaft);

a. Erwarte ich durch den Namen das EINE Mannschaft zurückgegeben wird.
b. Einen vector für Mannschaften (so lese ich den Vektor) in der Einzahl zu benennen halte ich für ungünstig.
c. Ist ein Fehlschlag von GetMannschaft ein Fehler, oder nur "eine Statusinformation", im letzen Fall mag eine bool-Rückgabe okay sein, in ersteren erwarte ich unter C++ eher eine exception und keine Rückgabe.

Also es ist ja nicht ganz sauber mit der Verebung. Da ja eine Liga nun wirklich keine Engine ist. Aber wie hätte ich den Zugriff auf so eine Funktion gewährleisten können. Wäre friend eien Alternative.

Dankeschön

class Base
{
public:
  int get_foo() { return 1; }
};

class Derived
  : public Base
{
public:
  int get_foo() { return 0; }

  int do_x() { return get_foo(); }
};

Hier ist der Rückgabewert von do_x() 0. Wenn du die Basisfunktion in diesem Beispiel aufrufen möchtest, müsstest du es so schreiben:

int do_x() { return Base::get_foo(); }

Wenn es nicht das Problem ist, dann hast du uns immer noch nicht genügend, bzw. nicht die richtigen Informationen gegeben.

Grüssli

Also es ist ja nicht ganz sauber mit der Verebung. Da ja eine Liga nun wirklich keine Engine ist. Aber wie hätte ich den Zugriff auf so eine Funktion gewährleisten können. Wäre friend eien Alternative.

Wieso machst Du die Engine nicht einfach zu einem Member von Liga?

class vbLiga 
{
public:
    //...
private:
    //...
    vbEngine engine;
    //...
};

...

Eine allgemeine Bitte: Lies dir vor dem Abschicken eines Posts deinen Text nochmal durch - manches davon ist sehr unverständlich. Ich mache selbst genügend Fehler, aber meist ist mein Post dennoch verständlich.

dercooleauswandere schrieb:

Hallo erst mla vielen dank für die vielen antworten. also das "vb" vor den klassen steht einfach für volleyball.

Wäre folgendes nicht besser lesbar (dazu weiter unten noch etwas mehr):

namespace Volleyball {
  class Liga{/*...*/};
  class Mannschaft{/*...*/};
}

dercooleauswandere schrieb:

Die kritik mit dem bol ist berechtigt. allerdings füllt die funktion einen vector mit mannschaften.

Dann ist der Name falsch gewählt - Hier gilt das gleiche wie mit dem Namensraum:

Man liest ein Programm weitaus häufiger, als das man es schreibt. Aussagekräftige Namen erleichtern das Verständnis (=> dadurch häufig auch weniger Fehler) und damit die Wartung.

Im Idealfall kann ein Code fast wie ein Buch lesbar sein, und sogar von Menschen gelesen werden die keine oder nur Minimale Programmierkenntnisse haben.

Zudem (Auch wenn volkard anderer Meinung sein wird) würde ich Code im ersten Moment nicht ausschließlich auf Performance optimieren, sondern auf Verständlichkeit. Sprich: Ich gebe einen vector auch als Rückgabewert, nicht als Rückgabeparameter zurück, wenn die Funktion eine Liste zurückgeben soll. Fehler (ich glaube persönlich wenn eine Id keinen Treffer liefert das dies durchaus ein Fehler darstellt, und nicht ein Status) gebe ich als Exception zurück.

Bei mir sähe die Schnittstelle wohl wie folgt aus (Wenn ich auch den Namen Engine noch ersetzen, deutsch und englisch ungern mische, und ggf. die Engine-Klasse auch splitten würde):

Mannschaft Engine::GetMannschaft(int id); // Mannschaft mit der entsprechenden Id
std::vector<Mannschaft> Engine::GetMannschaften(); // Alle Mannschaften

cu André

So im ersten Schritt werde ich die Engine initialisieren. Dabei werden alle Mannschaften, SPielen Ligen, und Ansetzungen erzeugt. Und jede dieser Klassen hat eine eine Refernz auf die Engine. Meine Frage nun wie bekomme ich einen Refernz von einer klasse auf sich selbst. Geht das über den this Zeiger ?

Vielen Dank

Die Klasse vbLiga ist natürlich keine Engine. Aber si hat ja eine Engine.

So im ersten Schritt werde ich die Engine initialisieren. Dabei werden alle Mannschaften, SPielen Ligen, und Ansetzungen erzeugt. Und jede dieser Klassen hat eine eine Refernz auf die Engine. Meine Frage nun wie bekomme ich einen Refernz von einer klasse auf sich selbst. Geht das über den this Zeiger ?

Vielen Dank

So wie du es darstellst hat eine Liga nichtmal eine Engine, sondern die Engine erzeugt mehrere Ligen - die Liga würde dann bestenfalls eine Referenz auf eine Engine haben, wenn das überhaupt nötig ist. Wenn bei der initialisierung einer Engine alle Ligen erzeugt werden, jede Liga aber wiedrum von einer Engine erbt, dann hast du noch während der Initialisierung der ertsen Engine eine exponentielle Explosion von Objekten, weil jede Liga die erzeugt wird ihre Basis-engine erzeugt, die wiederum X neue Ligen erzeugt....

Du solltest dir wirklich einmal ganz genau überlegen, wer was ist, wer was hat, und wer etwas benutzt. (Vererbung, Member, Referenzen) Das Schema "jeder kennt jeden" schafft zu große Abhängigkeiten und macht aus deinem Design einen dicken, nicht lösbaren Klumpen der recht schnell im Chaos endet.

MenuMain() //Constructor
{
    Button Click();
}

Was soll der Funktionsprototyp im Konstruktor?

Button Click(); // Funktionsprototyp
Button Click; // Variablendeklaration mit Standardkonstruktoraufruf

Und selbst wenn du letzteres meintest: Du würdest eine LOKALE Variable erzeugen, die nur im Konstruktor gültig ist... Der Name ist auch bescheiden gewählt, für mich ist "Click" eine Aktion, kein Objekt.

Du willst wohl eher eine Membervariable:

// Im Header
class MenuMain {
    private:
        Button clickButton; // Membervariable - Objektweit gültig
    //...
}

cu André