Lottospiel erstellen (Problembehebung in C++)

[wennoder]

Hi
wir sollen als Aufgabe ein Lottospiel erstellen mit mindestens 4 Klasse( Lotto, Tippzettel , Adresse, Ziehung)
Das Spiel funktioniert so das der Spieler eine Tippzettel ausfüllt dafür muss er auch seine Adresse hinterlassen so wie seine 6 Glückszahlen.
Dann werden in der Klasse Ziehung die 6 Lottozahlen gezogen
danach werden die Ergebnisse in der Klasse Lotto und in der Funktion ergebnisAusgeben() bekannst gegeben was auch mein Problem ist.
Ich weiß nicht wie ich den Tippzettel so wie die Lottozahlen in die Funktion bekomme so damit ich sie vergleichen kann.

Lotto.h

/*@(#) Lotto.h */

#ifndef LOTTO_H_H
#include <string>
#include <iostream>
#include <vector>
using namespace std;
#define LOTTO_H_H

#include "Tippzettel.h"
#include "Ziehung.h"
#include "Adresse.h"
class Lotto
{

public:
	void ergebnisAusgeben();
	int getTippzettelanzahl() const;
	Lotto(int Tippzettel);
	void LottoGUI();
	void setTippzettelanzahl(int tippzettelanzahl);
	void setzen();
	void ziehen();
	 Lotto();
	~Lotto();

private:
	Tippzettel *pTippzettel[3];
    Ziehung *pZiehung[6];

	int Tippzettelanzahl;

};

#endif

Lotto.cpp

#include "Lotto.h"

void Lotto::ergebnisAusgeben(void)//da wird das Ergebnis ausgegeben 
{

}
int Lotto::getTippzettelanzahl(void) const
{
	return Tippzettelanzahl;
}
Lotto::Lotto(int Tippzettel)
{

}
void Lotto::LottoGUI()// Hauptmenü des Spiels
{

	int auswahl;
	cout<<"Lotto Menue"<<endl;
	cout<<"1 Tippzettel ausfuellen"<<endl;
	cout<<"2 Glueckszahlen ziehen"<<endl;
	cout<<"3 Ergebnis ausgeben"<<endl;
	cout<<"0 Beenden"<<endl;
	cout<<"Auswahl(0-3): ";
	cin >> auswahl;

	switch (auswahl)
	{
		case 0: cout<<"Das Spiel wird beenden"<<endl;
				  break;

		case 1: cout<<"Sie koennen jezt einen Tippzettelausfuellen"<<endl;
				  setzen();
				  LottoGUI();
				  break;

		case 2: cout<<"Es werden die Glueckszahlen gezogen"<<endl;
			      ziehen();
				  LottoGUI();
				  break;

		case 3: cout<<"Das Ergebnis ist"<<endl;
				  ergebnisAusgeben();
				  LottoGUI();
				  break;

		default: cout<<"Ungueltige Eingabe"<<endl;
				 LottoGUI();
				 break;
	}

}
void Lotto::setTippzettelanzahl(int tippzettelanzahl)
{

}
void Lotto::setzen()// Ausfüllen des Tippzettels
{

	Tippzettel aus;
	aus.getAdresse();

}
void Lotto::ziehen() //Lottozahlen werden gezogen
{   

	Ziehung ziehen;
	ziehen.ziehen();

}
Lotto::Lotto()
{

}
Lotto::~Lotto()
{

}

Tippzettel.h

/*@(#) Tippzettel.h */

#ifndef TIPPZETTEL_H_H
#include<string>
#include<iostream>
#include<vector>
using namespace std;
#define TIPPZETTEL_H_H

#include "Adresse.h"
#include "Lotto.h"
#include "Ziehung.h"
class Tippzettel
{

public:
	void ausfüllen();
	void getAdresse();
	int getGetippteZahl();
	void setGetippteZahl(int getippteZahl);
	Tippzettel();

private:
	int getippteZahl;
	Adresse *pAdresse;

};

#endif

Tippzettel.cpp

#include "Tippzettel.h"

void Tippzettel::ausfüllen()// der tippzettel wird ausgefüllt
{
	getAdresse();
       getGetippteZahl();

}
void Tippzettel::getAdresse()// Die adresse wird geholt
{

	vector<string> dA(3);
	Adresse get;
	dA[0]=get.getName();
	dA[1]=get.getOrt();
	dA[2]=get.getStrasse();

}
int Tippzettel::getGetippteZahl() // die glückszahlen werden abgefragt
{
	vector<int> gZ(6);
	int zahl;
	cout<<"Bitte geben sie ihre Glueckszahlen ein(1-49)"<<endl;
	cout<<"Bitte erste Zahl eingeben: ";
	cin >>zahl;
	gZ[0]= zahl;
	cout<<"Bitte zweite Zahl eingeben: ";
	cin >> zahl;
	gZ[1]= zahl;
	cout<<"Bitte dritte Zahl eingeben: ";
	cin >> zahl;
	gZ[2]= zahl;
	cout<<"Bitte vierte Zahl eingeben: ";
	cin >> zahl;
	gZ[3]= zahl;
	cout<<"Bitte fuenfte Zahl eingeben: ";
	cin >> zahl;
	gZ[4]= zahl;
	cout<<"Bitte sechste Zahl eingeben: ";
	cin >> zahl;
	gZ[5]= zahl;
	for (int i=0; i<=5; i++)
	{
		cout << "Glueckszahl " <<i+1<<": "<< gZ[i]<< endl;
	} 
	return getippteZahl;
}
void Tippzettel::setGetippteZahl(int getipptereZahl)
{

}
Tippzettel::Tippzettel()
{

}

Adresse.h

/*@(#) Adresse.h */

#ifndef ADRESSE_H_H
#include <string>
#include <iostream>
#include <vector>
using namespace std;
#define ADRESSE_H_H

#include "Lotto.h"
#include "Tippzettel.h"
#include "Ziehung.h"
class Adresse
{

public:

	Adresse();
	string getName();
	string getOrt();
	string getStrasse();
	void setName(string name);
	void setOrt(string ort);
	void setStrasse(string strasse);

private:
	string name;
	string ort;
	string strasse;

};

#endif

Adresse.cpp

#include "Adresse.h"

Adresse::Adresse()
{
	this->name;
	this->ort;
	this->strasse;
}
string Adresse::getName() // holt namen
{
	cout<<"Bitte Name eingeben: ";
	cin >> name;
	return name;
}
string Adresse::getOrt() // holt ort
{
	cout<<"Bitte Ort eingeben: ";
	cin >> ort;
	return ort;
}
string Adresse::getStrasse() // holt strasse
{
	cout<<"Bitte Strasse eingeben: ";
	cin >> strasse;
	return strasse;
}  
void Adresse::setName(string name)
{

	this->name;
}
void Adresse::setOrt(string ort)
{

	this->ort;
}
void Adresse::setStrasse(string strasse)
{
	this->strasse;
}

Ziehung.h

/*@(#) Ziehung.h */

#ifndef ZIEHUNG_H_H
#include <string>
#include <iostream>
#include <vector>
using namespace std;
#define ZIEHUNG_H_H

#include "Adresse.h"
#include "Lotto.h"
#include "Tippzettel.h"
class Ziehung
{	
public:
	void ergebnisAusgeben(int gezogeneZahl);
	void ziehen();
	Ziehung();

private:
int gezogeneZahl;

};

#endif

Ziehung.cpp

#include "Ziehung.h"
#include <cstdlib>
#include <time.h>

void Ziehung::ziehen() // die 6 Lottozahlen werden gezogen funkt auch 
{
//bestimmt ihre 6 Lottozahlen
int i =0;
int zufallszahl[6];
int zahlen[49];
int r;

while (i < 6)
{
	cout << "bestimme zahl" << i+1 << endl;
		do
		{
			srand(time(NULL)* time(NULL)); 
			r = rand() %49+1;

		}while (zahlen[r] == 1);
			zahlen[r] = 1;
			zufallszahl[i] = r+1;
			i++;

}
//die gezogenen Zahlen sotieren und ausgeben
for (int x=0; x<6; x++)
{
	for (int y=0; y<5; y++)
	{
		if (zufallszahl[y] > zufallszahl[y+1])
		{
			int temp = zufallszahl[y];
			zufallszahl[y] = zufallszahl [y+1];
			zufallszahl[y+1] = temp;
		}

	}
}
	for (int i=0; i<=5; i++)
	{
		cout << "Lottozahl " << i+1 <<": "<< zufallszahl[i]<< endl;

	} 

}
void Ziehung::ergebnisAusgeben(int gezogeneZahl)
{

}
Ziehung::Ziehung()
{

}

main.cpp

#include "Lotto.h"
#include <iostream>
using namespace std;

int main()
{
	const int Lottospieler =3;

	Lotto myLotto(Lottospieler);
	myLotto.LottoGUI();

	system("pause");

}

[wennoder]

im prinzip muss ich wissen wie ich ein string oder vektor der klasse b in klasse a aufrufen kann und verwenden kann.

[wxSkip]

wennoder schrieb:

im prinzip muss ich wissen wie ich ein string oder vektor der klasse b in klasse a aufrufen kann und verwenden kann.

Klasse b sollte eine Memberfunktion bekommen, mit der du einen String aus der Klasse a abfragen kannst und in Klasse a kannst du diese Funktion dann auf dem b-Objekt aufrufen.

[f.-th.]

Kenne die neuesten C++ Ideen nicht auswendig.

Die Code_Guards in den Headern hab ich so nicht in Erinnerung.
Dann würde ich nur die Header, die in dem jeweiligen Header unbedingt includiert werden müssen, dort includieren.

Auch

using namespace std;

würde ich im Header meiden. In der .cpp -Datei kannst du die ja setzen, wenn du die nutzen willst.

Wenn du bei dem einen C-Header die C++ Variante setzen würdest, sähe das besser aus

MfG f.-th.

[Furble Wurble]

Vielzuviel Code. Daher bekommst Du auch so spärliche Antworten.

Ich versuche mich trotzdem mal an ein paar allgemeinen Antworten:
Du hast getter und setter nicht verinnerlicht und noch eine Wissenslücke was C++ betrifft.
Z.B. der Kontruktor von Adresse macht gar nix, weil Du keine Zuweisungen, oder Initialisierungen oder sonstwas drinstehen hast:

Adresse::Adresse()
{
	this->name; // tut nix! Gemeint name = "foo" ?
	this->ort;  // tut nix! Gemeint ort  = "bar" ?
	this->strasse; // tut auch nix! ...
}

Schau Dir nochmal Konstruktoren an, und besonders wie man in Konstruktoren sog. Initialisierungslisten benutzt.

Zum Setter:
Setter "Setzen" Attribute. Deine Setter machen gar nichts:

void Adresse::setName(string name)
{
	this->name;  // macht gar nix! Gemeint war this->name = name ?
}

Zum Getter:
Getter "Holen" Attribute - und verändern im Regelfall nicht das Objekt dessen Attribut sie holen. Deine Getter setzten den Namen und geben ihn zurück:

string Adresse::getName() // holt namen  (sic!)
{
	cout<<"Bitte Name eingeben: ";
	cin >> name;  // setzt den namen dieses Adresse-Objekts
	return name;
}

Ich denke damit hast Du schon mal eine Weile zu tun - und danach sehen wir weiter.

Hier ist noch ein kommentiertes Beispiel einer Klasse, die so ähnlich ist, wie 'Adresse' bei Dir:

#include <iostream>
#include <string>

class Zitat_des_tages{
  const std::string zitat;
  // Hilfsfunktion um das Zitat zu erfragen. veraendert das Objekt nicht. Daher 'const'
  std::string frag_nach_string(const std::string& frage) const;
public:
  Zitat_des_tages() : zitat(frag_nach_string("Gib mir ein Zitat: ")) { }  // Konstruktor mit Initialisierungsliste
  const std::string& get_zitat() const { return zitat; }  // getter. veraendert nix: daher 'const'
  /* kein Setter: Das Zitat des Tages laesst sich nicht veraendern! */
};

/* schreibt den string 'frage' nach cout, liest eine Zeile von cin und gibt diese als string zurueck */
std::string Zitat_des_tages::frag_nach_string(const std::string& frage) const{
  std::string result;
  std::cout << frage;
  std::getline(std::cin, result); // std::getline: wichtig, bitte merken! ;)
  return result;
}

int main(){
  Zitat_des_tages t;
  std::cout << "Zitat des Tages: " << t.get_zitat() << '\n';
}

[wennoder]

okj danke für die antworten ich hab mal die Klasse Adresse dem entsprechend geändert:

#include "Adresse.h"

void Adresse::holadresse()
{
	cout<<"Bitte Name eingeben: ";
	cin >> name;
	cout<<"Bitte Ort eingeben: ";
	cin >> ort;
	cout<<"Bitte Strasse eingeben: ";
	cin >> strasse;
}

Adresse::Adresse()
{

}
string Adresse::getName() const
{
	return name;
}
string Adresse::getOrt() const
{
	return ort;
}
string Adresse::getStrasse() const
{
	return strasse;
}  
void Adresse::setName(string name)
{	
	this->name = name;
}
void Adresse::setOrt(string ort)
{
	this->ort = ort;
}
void Adresse::setStrasse(string strasse)
{
	this->strasse = strasse;
}

[Furble Wurble]

Oki. Sieht doch gleich viel besser aus. (Den leeren Konstruktor kannst Du noch entfernen.)
Und nochwas: Häufig geben Programmierer Ihrem Drang nach für alles mögliche getter und setter zu schreiben - aber wo wirst Du, nachdem Du einmal holAdresse() aufgerufen hast noch mal die Adresse ändern müssen?

Dann weiter im Text:

/*@(#) Tippzettel.h */

#ifndef TIPPZETTEL_H_H
#include<string>
#include<iostream>
#include<vector>
using namespace std;
#define TIPPZETTEL_H_H

#include "Adresse.h"
#include "Lotto.h"
#include "Ziehung.h"
class Tippzettel
{

public:
    void ausfüllen();
    void getAdresse();
    int getGetippteZahl();
    void setGetippteZahl(int getippteZahl);
    Tippzettel();

private:
    int getippteZahl;
    Adresse *pAdresse;
};

#endif

Sind diese Header automatisch generiert oder so?
Ist jedenfalls alles Quark.
Um's einfach zu halten: Du brauchst natürlich nur das inkludieren, was Du auch benutzt. Das ist im Falle dieses Headers: gar nix!
Interessant ist in diesem Fall, dass Du sogar "Adresse.h" nicht einbinden musst, da Du nur einen Zeiger (pAdresse) auf Adresse benutzt. D.h. Du musst dem Compiler nur eine sog. _Vorwärtsdeklaration_ präsentieren, damit er weiss, dass Adresse eine Klasse ist.

Die sog. using Direktive hat in einem Header auch nichts verloren, da jeder der den Header inkludiert diese gleich "mitaufschnappt". Abgesehen davon: brauchst Du sie eh nicht.

Zurück zu diesem Zeiger auf Adresse, "pAdresse". Warum überhaupt ein Zeiger? Mmach Die Adresse zu einem Member des Tippscheins (zu einem Tippschein gehört eine Adresse) - erspart Dir viel Ärger und es wird kein Pointergefrickel geben.

Ähnliches gilt für den Header Lotto.h: lass die Pointer weg und spendiere zwei Vektoren aus der Standardbibliothek. einen std::vector<Ziehung> und einen std::vector<Tippzettel>.

Ich durchblick jetzt den Ablauf, den Du Dir für Dein Programm vorgestellt hast nicht zur gänze, aber eine Ziehung sollte evtl. Ihre 6 Lottozahlen auch in einem Vektor speichern. Den kannst Du dann über einen Getter für alle, die es interessiert zugänglich machen:

class Ziehung
{   
public:
    void ergebnisAusgeben() const;
    void ziehen();  // Vector füllen - evtl. Privat? Siehe Konstruktor...
    Ziehung() { ziehen(); } // Eine Ziehung füllt den Vektor sofort, wenn sie erstellt wird...
    const std::vector<int>& get_gezogenene_zahlen() const { return gezogene_zahlen; } // z.B.
private:
    std::vector<int> gezogenen_zahlen;

};

Schon wieder 'ne Menge Zeug: Vorwärtsdeklaration, std::vector, using directive - aber: watt mut, datt mut!

wennoder schrieb:

im prinzip muss ich wissen wie ich ein string oder vektor der klasse b in klasse a aufrufen kann und verwenden kann.

Ist das mittlerweile klar, z.B. Durch get_gezogene_zahlen(), oben?

Furble Wurble (nach Diktat Bierchen geöffnet und Fußball geschaut.)

[wennoder]

danke für die schnelle antwort

ja das mit der Klasse Adresse find ich auch überflüssig aber die Vorgaben sind mindestens 4 Klassen zu verwenden

[wennoder]

okj hab jetzt mal die Klassen Ziehung und Tippzettel etwas geändert wie folgt:

/*@(#) Tippzettel.h */

#ifndef TIPPZETTEL_H_H
#pragma once
#include<string>
#include<iostream>
#include<vector>

#define TIPPZETTEL_H_H
#include "Adresse.h" //Hab den Pointer jetzt einfach weg gelassen hat besser funktioniert

class Tippzettel
{	
public:
	void ausfüllen();
	void getAdresse();
	const std::vector<int>& get_getippte_zahlen() const {return getippte_zahlen;} // hab mir gedacht das wenn ich das in Ziehung verwende kann ich das das auch hier machen
	const std::vector<std::string>& get_adresse() const {return adresse;}
private:
	std::vector<int>getippte_zahlen;
	std::vector<std::string>adresse;	 	
};

#endif

/*@(#) Ziehung.h */

#ifndef ZIEHUNG_H_H
#pragma once
#include <string>
#include <iostream>
#include <vector>
#define ZIEHUNG_H_H

class Ziehung
{	
public:
	void ziehen();
	void ergebnisAusgeben()const;
	//Ziehung(){ziehen();};  // wenn ich den drin lass und die funktion get_gezogene_zahlen() aufrufe wird das ganze noch mal ausgeführt also könnte ich den löschen oder?
	const std::vector<int>& get_gezogene_zahlen() const {return gezogene_zahlen;}
private:
	std::vector<int>gezogene_zahlen;

};

#endif

hab in allen klassen das

using namespace std;

raus

okj der nächste schritt ist bei Lotto in der funktion ergebnisAusgeben() die vectoren gezogene_zahlen und getippte_zahlen zu vergleichen und die über einstimmungen bekannt geben

void Lotto::ergebnisAusgeben(void)
{
	Ziehung zieh;
        zieh.get_gezogene_zahlen();

}

[wennoder]

[quote="wennoder"]okj hab jetzt mal die Klassen Ziehung und Tippzettel etwas geändert wie folgt:

/*@(#) Tippzettel.h */

#ifndef TIPPZETTEL_H_H
#pragma once
#include<string>
#include<iostream>
#include<vector>

#define TIPPZETTEL_H_H
#include "Adresse.h" //Hab den Pointer jetzt einfach weg gelassen hat besser funktioniert

class Tippzettel
{	
public:
	void ausfüllen();
	void getAdresse();
	const std::vector<int>& get_getippte_zahlen() const {return getippte_zahlen;} // hab mir gedacht das wenn ich das in Ziehung verwende kann ich das das auch hier machen
	const std::vector<std::string>& get_adresse() const {return adresse;}
private:
	std::vector<int>getippte_zahlen;
	std::vector<std::string>adresse;	 	
};

#endif

/*@(#) Ziehung.h */

#ifndef ZIEHUNG_H_H
#pragma once
#include <string>
#include <iostream>
#include <vector>
#define ZIEHUNG_H_H

class Ziehung
{	
public:
	void ziehen();
	void ergebnisAusgeben()const;
	//Ziehung(){ziehen();};  // wenn ich den drin lass und die funktion get_gezogene_zahlen() aufrufe wird das ganze noch mal ausgeführt also könnte ich den löschen oder?
	const std::vector<int>& get_gezogene_zahlen() const {return gezogene_zahlen;}
private:
	std::vector<int>gezogene_zahlen;

};

#endif

hab in allen klassen das

using namespace std;

raus

okj der nächste schritt ist bei Lotto in der funktion ergebnisAusgeben() die vectoren gezogene_zahlen und getippte_zahlen zu vergleichen und die über einstimmungen bekannt geben

void Lotto::ergebnisAusgeben(void)
{
	Ziehung zieh;
        zieh.get_gezogene_zahlen();

}

[/quoute]

[Furble Wurble]

wennoder schrieb:

ja das mit der Klasse Adresse find ich auch überflüssig aber die Vorgaben sind mindestens 4 Klassen zu verwenden

Ich wollte nicht so verstanden werden, dass Du auf die Adresse-Klasse verzichtest. Die ist durchaus sinnvoll und war auch von Dir gut angelegt. Ich habe gemeint, dass Ziehung ein Member der Klasse Adresse haben soll, statt eines Zeigers auf ein solches Objekt.

class Tippzettel
{
public:
    void ausfüllen();
    void getAdresse();
    int getGetippteZahl();
    void setGetippteZahl(int getippteZahl);
    Tippzettel();

private:
    int getippteZahl;
    Adresse adresse_; // "Tippzettel hat eine Adresse"
};

wennoder schrieb:

okj der nächste schritt ist bei Lotto in der funktion ergebnisAusgeben() die vectoren gezogene_zahlen und getippte_zahlen zu vergleichen und die über einstimmungen bekannt geben

Ich hoffe Du bist des englischen mächtig genug um die Internetquellen zum Thema C++ Standardbibliothek zu lesen oder dass Du ein Buch zum Thema hast. Eine solche Referenz wirst Du nämlich hoffentlich in Zukunft häufig benutzen.
In Deinem Fall wird es darauf hinauslaufen, dass Du beide Vektoren sortierst (std::sort() aus <algorithm>) und danach die Schnittmenge bestimmst (std::set_intersection() auch aus <algorithm>). Ganz klar eigentlich.
Allerdings wirst Du Dich mit einem weiteren sehr wichtigen Idiom von C++ vertraut machen müssen: _Iteratoren_.

Deine Header sind noch zu umfangreich. Schmeiss alle Includes rauss, die Du im Header nicht brauchst. Inkludiere in der Datei mit der Implementierung alles was Du brauchst (und nicht mehr!).

Analog zum Beispiel mit dem Zitat des Tages gebe ich Dir noch ein Beispiel der beiden Algorithmen:

#include <vector>
#include <algorithm> // sort, set_intersection
#include <iterator>  //back_inserter

int main(){
  std::vector<int> v1 = {1, 2, 3, 4, 5, 6}, v2 = {0, 2, 4, 6, 8}; // c++11 - aber die Idee ist klar... ;)
  // Beide Vektoren sortieren:
  std::sort(v1.begin(), v1.end());
  std::sort(v2.begin(), v2.end());
  // Die Schnittmenge soll hier hinein:
  std::vector<int> intersec;
  // und jetzt die Schnittmenge bestimmen:
  std::set_intersection(v1.begin(), v1.end(), v2.begin(), v2.end(), std::back_inserter(intersec));
  // intersec ist jetzt [ 2, 4, 6 ]
}

Wie Du dass jetzt für Dein Programm einsetzen kannst musst Du selbst herausfinden.

Standardbibliothek und Iteratoren...wichtiges Zeux!

[wennoder]

nochmals danke

hab aber irgendwie immer noch das problem die vektoren der Klasse Ziehung und Tippzettel aufzurufen in der Klasse Lotto. das sotieren ist mittlerweile das geringere Problem.

[Furble Wurble]

wennoder schrieb:

nochmals danke

hab aber irgendwie immer noch das problem die vektoren der Klasse Ziehung und Tippzettel aufzurufen in der Klasse Lotto.

Immer gerne.
Ich versteh nicht, was Dein Problem ist. (Weil ich auch keine Lust habe mich durch Deinen ganzen Code zu lesen.)

Mach mal ein kleines Beispiel mit zwei Klassen: (Ziehung und Lotto z.B.), das Dein Problem aufweist - evtl. löst Du dann Dein Problem sowieso.

[wennoder]

void Lotto::ergebnisAusgeben(void)
{
	Ziehung zieh;
	Tippzettel tipp;
	sort(zieh.gezogene_zahlen.begin(),zieh.gezogene_zahlen.end());
	sort(tipp.getippte_zahlen.begin(),tipp.getippte_zahlen.end());

	vector<int> intersec;
	set_intersection(zieh.gezogene_zahlen.begin(),zieh.gezogene_zahlen.end(),tipp.getippte_zahlen.begin(),tipp.getippte_zahlen.end(), back_inserter(intersec));

	copy(intersec.begin(), intersec.end(), ostream_iterator<int>(cout, " "));
}

okj also eine Fehlermeldung kommt nicht aber ich hab trotzdem keine Ausgabe(im Fall das getippte_zahlen und gezogene_zahlen übereinstimmungen haben.

[wennoder]

i -858993460 int
+this 0x0038f8b0 {Tippzet=0x0038f8b0 Zog=0xcccccccc gezogene_zahlen1=[0]() ...} Lotto * const
+tipp {getippte_zahlen=[0]() adresse=[0]() } Tippzettel
+intersec [0]() std::vector<int,std::allocator<int> >
+zieh {gezogene_zahlen=[0]() } Ziehung

das kommt wenn ich ich einen Haltepunkt nach dem sotieren und vergleichen mache die vectoren sind alle leer ob wohl ich davor etwas reingeschrieben hab. Am Ende des jeweiligen reinschreibens sind die vectoren getippte_zahlen und gezogene_zahlen mit 6 Zahlen besetzt.

[wennoder]

okj hab das Problem selbst lösen können
jetzt funktioniert es.
danke noch mal für eine Hilfe