Program received signal SIGSEGV, Segmentation fault.
0x0043f83e in void std::_Construct<Person*, Person*>(Person**, Person* const&)
    (__p=0x101, __value=@0x3e3e38)
    at C:/Programme/MinGW/bin/../lib/gcc/mingw32/3.4.5/../../../../include/c++/3.4.5/bits/stl_construct.h:81
81            ::new(static_cast<void*>(__p)) _T1(__value);

(gdb) bt
#0  0x0043f83e in void std::_Construct<Person*, Person*>(Person**, Person* const&) (__p=0x101, __value=@0x3e3e38)
    at C:/Programme/MinGW/bin/../lib/gcc/mingw32/3.4.5/../../../../include/c++/3.4.5/bits/stl_construct.h:81
#1  0x0043da51 in std::vector<Person*, std::allocator<Person*> >::push_back(Person* const&) (this=0x22fe7c, __x=@0x3e3e38)
    at C:/Programme/MinGW/bin/../lib/gcc/mingw32/3.4.5/../../../../include/c++/3.4.5/bits/stl_vector.h:560
#2  0x00401b6b in main () at cpu.cpp:106

ich verstehe nicht, warum sich der Vektor (s.u.) Dagegen sträubt, einen Person* aufzunehmen. Es liegt aber irgendwie am Vektor, wenn ich einen neuen erzeuge, funktioniert es, aber *nie* mit Film::personen. Wie kann das sein, wo ist der Unterschied, ob ich statt der Stelle schreibe:

vector<Person*> v;
v.push_back(new Person());

oder das schreibe was da unten steht? Aber leider funktioniert das da unten nicht, also muss da ja irgendwas noch anders sein...?

struct Film;
struct Person{
	string name;
	vector<Film*> filme;
	Person():
		name(),
		filme()
	{}
};
struct Film{
	string name;
	vector<Person*> personen;
	Film():
		name(),
		personen()
	{}
};
struct Person_ptr_vergleicher{
	string name;
	Person_ptr_vergleicher(Person*& p):
		name(p->name)
	{}
	bool operator()(Person*& p){
		return name == p->name;
	}
};
struct Film_ptr_vergleicher{
	string name;
	Film_ptr_vergleicher(Film*& f):
		name(f->name)
	{}
	bool operator()(Film*& f){
		return name == f->name;
	}
};
int main(){

	// Liste mit Namen, Filmen und deren Verbindung
	// Liste einlesen.
	vector<Person*> personen;
	vector<Film*> filme;
	ifstream cpu_daten("cpu-daten.txt");
	for(;;){
		string line;
		getline(cpu_daten, line);
		if(line.length() == 0)
			break;
		int delimPos = line.find_first_of('|');
		string name = line.substr(0, delimPos);
		string film = line.substr(delimPos + 1);
		// Nachdem die Liste eingelesen wurde, in Listen speichern.
		Person* neue_person = new Person();
		neue_person->name = name;
		Film* neuer_film;
		neuer_film->name = film;
		vector<Person*>::iterator person_iterator;
		vector<Film*>::iterator film_iterator;

		// Wenn bereits in Liste vorhanden, muss die Person/der Film nicht neu angelegt werden

		if((person_iterator = find_if(personen.begin(), personen.end(), Person_ptr_vergleicher(neue_person))) == personen.end()){
			personen.push_back(neue_person);
			person_iterator = personen.end() - 1;
		}
		else
			delete neue_person;
		if((film_iterator = find_if(filme.begin(), filme.end(), Film_ptr_vergleicher(neuer_film))) == filme.end()){
			filme.push_back(neuer_film);
			film_iterator = filme.end() - 1;
		}
		else
			delete neuer_film;
		// Anschliessend noch Person mit Film und umgekehrt assoziieren		
		(*person_iterator)->filme.push_back(*film_iterator);
=======>(*film_iterator)->personen.push_back(*person_iterator);

	}
	return 0;
}

Woran kann das liegen?

Grüße,
Fabian

struct Person{
    string name;
    vector<Film*> filme;
    Person():
        name(),//wie wäre es wenn du die mal initialisierst
        filme()//das selbe hier.
    {}
};

Holy Crap !? Aber das bezieht sich schon auf das oben gesagte.

Film* neuer_film;
neuer_film->name = film;

Zugriff auf einen uninitialisierten Zeiger -> Undefiniertes Verhalten.

Entweder du arbeitest mit alten POD´s dann halte dich aber auch an deren Logik, oder du benutzt das C++ äquvivalent class .

was ist denn das für ein hinweis? was genau willst du damit sagen?

Firefighter: Warum soll ich nicht struct nehmen? Ich dachte, struct sei wie class , nur dass standardmäßig auf public statt private ist. Ich weiß, ich sollte nicht direkt auf die Elementvariablen zugreifen, aber das Programm ist für eine kleine Aufgabe, daher denke ich, dass die Vorteile von »strengem« Vorgehen hier nicht wirklich zum Tragen kommen, die ganze Sache aber deutlich länger wird.

Ich dachte, struct sei wie

class

, nur dass standardmäßig auf

public

statt

private

ist.

Da liegst Du richtig...

Also was mir zuerst aufgefallen ist.
Entweder du arbeitest mit alten POD´s dann halte dich aber auch an deren Logik, oder du benutzt das C++ äquvivalent class .

Sobald eine class oder struct Member enthält, die keine PODs sind (wie std::string oder std::vector ), ist sie auch selbst kein POD mehr, sondern ein Klassentyp. Und die explizite Initialisierung von Klassentypen ist nicht nötig, wenn diese einen Standardkonstruktor besitzen.