#include "Socket.h"
#include "TheServer.h"

void TheServer::handleConnection(int _client){
    cout << "Client Connected!" << endl;
    sendText(_client,"Willkommen auf dem Server");
    client.push_back(_client);
    startWaitingForMessages(_client);
    //CLOSE(_client);
}
TheServer::TheServer(){
}
void *TheServer::stWaitForMessages(void *_arg){
    struct theServerClient client;
    client=*(struct theServerClient *)_arg;
    TheServer *sv=client.server;
    sv->waitForMessages(client.client);
}
void TheServer::waitForMessages(int _client){ // <<------
}
void TheServer::startWaitingForMessages(int _client){
    struct theServerClient client;
    client.server= this;
    client.client=_client;
    pthread_t thread;
    pthread_create(&thread,NULL,stWaitForMessages,&client);
}

die funktion die mit <<------ gekennzeichnet ist macht irgendwie probleme
ich compiliere unter windows mit mingw...

also wenn in dieser funktion zb cout << "a"; drinsteht gibts ein problem fehler senden teil segmentation fault nehm ich an... wenn nichts drin steht gibts keine probleme... es muss irgendwo an der sache mit dem pthread liegen... ich ralls irgendwie ned, kann mir wer helfen?

danke dir, Hunger

die funktion darf teil einer klasse sein,

Strenggenommen nichtmal das. Die Funktion muss extern "C" void ()(void) sein.

Es funktioniert zwar oft (wenn nicht zur Zeit immer) mit einer statischen Methode, es steht aber nirgends geschrieben dass eine statische Methode dasselbe Calling-Interface haben muss wie eine freie extern "C" Funktion, ist also per se "nicht portabel".

Aber wenigstens lässt sich das leicht "thunken", da man ja einen void* Parameter hat netterweise. (Ich darf garnicht dran denken dass es immer noch Callback-Funktionen gibt die KEINEN "void* userdata" o.ä. haben, sonst werd' ich gleich wieder unrund...)

Natürlich kann man so auch echte Memberfunktionen "einwickeln", ein kleines Template genügt ja.

doch mags schon ich habs ja schon ausprobiert an andrer stelle des macht ja die sache so komisch es geht 2 mal und jetzt grad ned... und leer funktioniert die funktion... also wenn des ned komisch is...

Das klingt sehr nach dem Problem über das wir uns schn mal ausgetauscht hatten.

- Thread I ("main"-Thread) erzeugt Objekt o als Stackvariable;
- Thread I erzeugt Thread II mit (void*) &o als Argument;
- Thread I läuft weiter und vernichtet o am Ende des Blocks
- Thread II will aber (&o)->irgendwas() aufrufen

Obs (noch) gut geht oder (schon) nicht mehr hängt dann vom Scheduling ab; wirkt also ggf. zufällig!

Grüsse

*this

Das objekt existiert also immer noch! was aber NICHT geht ist, dass Thread II jetzt einen Thread III startet der ähnlich funktioniert wie der aufruf von Thread II während Thread I (der Hauptthread) beliebig viele Threads Parallel starten kann.

scheint wohl einafch so zu sein

aber eine so kroteske konstellation sollte denke ich von grund auf überdacht werden wo irgendwelche nebenthreads noch weiter nebenthreads starten... hab ich getan unds geschafft ohne auszukommen was diskutiern wir hier noch? XD

Was du jetzt schreibst kann ich nicht nachvollziehen, ist leider etwas konfus.

void TheServer::startWaitingForMessages(int _client){ 
    struct theServerClient client; // <-- Problem Teil 1
    client.server= this; 
    client.client=_client; 
    pthread_t thread; 
    pthread_create(&thread,NULL,stWaitForMessages,&client); // <-- Problem Teil 2
}

Du übergibst die Adresse von "client" an den neuen Thread, diese Adresse wird aber sofort nach dem pthread_create Aufruf ungültig, da es sich um ein lokales Objekt handelt. Wenn der neue Thread schnell genug losläuft geht es, wenn er zu spät losläuft geht es nicht. Das ist das Problem.

Wenn der echte Code mit dem du Probleme hast anders aussieht solltest du vielleicht den posten. Üblicherweise macht man sowas eher so:

void* TheServer::stWaitForMessages(void* _arg){ 
    std::auto_ptr<theServerClient> client(static_cast<theServerClient*>(_arg)); // ownership übernehmen

    // ...
    return 0;
}

void TheServer::startWaitingForMessages(int _client){ 
    std::auto_ptr<theServerClient> client(new theServerClient);
    client->server= this; 
    client->client=_client; 
    pthread_t thread; 
    if (pthread_create(&thread,NULL,stWaitForMessages,client.get()) == 0)
    {
        // success, "client" gehört jetzt dem Thread
        client.release();
    }
    else
    {
        // fehler, "client" soll vom auto_ptr freigegeben werden
    }
}

Nein, du hast Recht, das ist noch eine Stufe falscher als grundfalsch. Hätte ich das in der Arbeit gesehen wäre ich ausgeflippt und hätte mich 10 Min. nichtmehr beruhigt.

Dazu könnte man noch beachten dass der OP schon eine solche "Diskussion" um genau das Thema mit mir hatte http://www.c-plusplus.net/forum/viewtopic-var-t-is-110668.html
Insofern grenzt das hier auch noch an ein Doppelposting.

DaHunger schrieb:

scheint wohl einafch so zu sein

Nein, ist es nicht. Dein Code ist dubios.

DaHunger schrieb:

hab ich getan unds geschafft ohne auszukommen was diskutiern wir hier noch? XD

Wenn ich sowas lese kommt mir echt die Galle hoch...
Du bist weit davon entfernt mit irgendjemandem über Threads "diskutieren" zu können!
Wenn ich sehe dass Du nach meinem Hinweis mit dem Singleton nicht die Instanz sonern die Klasse "TheServer" genannt hast sehe ich zudem wie ungenau Du diese Dinge durchdenkst.

Aber - Dein Wille ist mir Befehl - nochmal werde ich mir sicher nicht Dein Geschreibsel ansehen!

Grüsse

*this

warum ist mein code denn bitte "grundfalsch"?

ach und, ja tut mir sehr leid dass ich euch 3 mal darauf hingewiesen hab, dass mein problem gelöst ist und ihr euch daher nicht weiter damit befassen müsst...

wisst ihr was ihr habts geschafft, ich hab kb mehr auf des forum, wollte zwar eigentlich etwas aktiver hier werden aber wenn ich so was les dann vergeht mir die lust wieder

tschö
gruß, hunger

Wenn du z.B. die "Variable" (Struktur/Objekt) einfach global machst überlebt "sie" zwar das Verlassen von "startWaitingForMessages", bloss knallts dann irgendwann mal weil "startWaitingForMessages" zu schnell hintereinander aufgerufen wurde, und die "globale Variable" dann beim Loslaufen von Thread N bereits mit den Daten für Thread N+1 überschrieben wurde.

Natürlich kannst du all diese Dinge mit "sowas geht dann eben wohl nicht" abtun, kann dir keiner verbieten, nur dass es nicht stimmt. Gehen tut fast alles, bloss muss man es eben richtig machen. Und nicht falsch.