# [C++] lokale Variable an neuen Thread (pthread) übergeben



## pc-world (30. Jan 2011)

Hallo,

ich habe mich bis jetzt hauptsächlich mit der Java-Programmierung beschäftigt und will jetzt auch ein wenig etwas in C++ arbeiten.
Als ich angefangen habe, mich mit C++ zu befassen, ist mir die Frage gekommen, was das ganze Theater mit den Pointern und Referenzen soll. In Java dagegen geht das ja alles ziemlich einfach.
Was mich derzeit besonders stört, ist, dass der Speicherzugriff nicht beim Kompilieren "kontrolliert" wird, und ich mich ziemlich häufig mit segmentation faults beschäftigen muss. Unter Java brauch man ja nicht mal über sowas nachzudenken, und in C++ kann man ewig suchen, bis man den eigentlichen Fehler gefunden hat.

Nun die eigentliche Frage:
Wie kann ich einem Thread (pthread/Linux) eine lokale Variable übergeben?

Der Thread wird folgendermaßen erstellt:

```
string server = eineFunktion(); // eine Funktion() gibt einen Pointer zu einem char-Array zurück
string user = eineFunktion();
string pw = eineFunktion();
struct initftp_struct str = {server, user, pw}; // initftp_struct ist eine Struktur, die drei Strings enthält

pthread_t thread;
int ret = pthread_create(&thread, NULL, initftp_thread, (void*) &str);
```

Die Thread-Funktion:

```
void* initftp_thread(void *ptr) {
	usleep(50000);
	struct initftp_struct *str = (struct initftp_struct*) ptr;
	andereFunktion(&(str->server), &(str->user), &(str->pw)); // Prototyp: void andereFunktion(string *server, string *user, string *pw);
}
```

Beim Aufruf von andereFunktion() erhalte ich einen segmentation fault. Diese Funktion versucht lediglich, mit den ihr übergebenen Werten zu arbeiten.
Warum ich diesen Speicherzugriffsfehler erhalte, ist mir eigentlich auch klar:
Ich übergebe dem Thread Adressen zu lokalen Variablen, die im anderen Thread ihre Gültigkeit verloren haben.
Nur weiß ich nicht, wie ich es anders machen könnte - wie gesagt komme ich aus der Java-Welt, in der alles anders zu funktioneren scheint.

Ich würde mich freuen, wenn ihr mir ein paar Gedankenanstöße geben könntet!


----------



## musiKk (30. Jan 2011)

Lokale Variablen liegen auf dem Stack, der - wie Du richtig erkannt hast - beim Verlassen der Funktion wieder abgebaut wird, womit die lokalen Variablen nicht mehr existieren. Um Speicher auf dem Heap zu erhalten, gibt es [c]malloc[/c]. Der muss später dann wieder mit [c]free[/c] freigegeben werden. Tutorials dazu gibts genug im Netz.
Im Prinzip ist das das gleiche wie in Java; dort liegen alle Objekte auf dem Heap und lokale Variablen (Referenzen auf diese Objekte) auf dem Stack. Man bekommt davon nur nichts mit.


----------



## Siassei (31. Jan 2011)

malloc und free sind C
In C++ solltest du new und delete verwenden.


----------



## pc-world (2. Feb 2011)

Danke!
Ich habe es jetzt mit new und delete gelöst, geht ziemlich einfach, wenn man weiß wie.


----------



## pc-world (2. Feb 2011)

Noch eine kurze Frage:

```
// angenommen, ich habe folgende Struktur:
struct abc {
	string *var;
}

// in einer Funktion:
string *var = new string("text");
struct abc *str = new abc;
str->var = var;

// in einer anderen Funktion (z. B. in einem anderen Thread):
delete str->var; // nötig?
delete str;
```

Ist die vorletzte Zeile nötig, also dass der "Inhalt" der Struktur noch gesondert gelöscht werden muss, bevor die Struktur an sich gelöscht wird?


----------



## HoaX (2. Feb 2011)

Ja, ist nötig, außer du verwendest eine Kopie von var noch irgendwo anders.


----------



## MasterK (5. Feb 2011)

Obwohl man in dem fall wahrscheinlich eher keinen string pointer, sondern ein string objekt verwenden würde. Also var muss wahrscheinlich kein pointer sein.
Das ist etwas, was java-entwickler gern in c++ machen: alle objekte mit new anlegen, weil mans so gewohnt ist. Wie du in deinem eingangspost schon bemerkt hast, java und c++ unterscheiden sich. Man muss nur wissen, warum


----------

