c++ Theard std::string übergeben

[bigbertinator]

Hallo,

Ich hoffe ihr könnt mir helfen, bei einem Problem. Ich muss einen Theard starten, nicht schwer an sich. Nun muss dieser Theard auf einen std::string zugreifen können und verändern können.

Ich hoffe ihrkönnt mir helfen.

 

[Knoxx]

Und wo liegt nun dabei dein Problem?

 

[bigbertinator]

Ihc weiß nicht wie ich einen Thread erstelle und einen std::string als Parameter übergebe.

 

[Extinction]

@Knoxx
Ich denke mal, dass sein Problem in der üblichen Übergabe per void* -Typ liegt. Aber WAS für Threads er benutzt, hat er natürlich nicht erwähnt...

@bigbertinator
Ein wenig googeln hätte es auch getan... Mal ein kurzes Beispiel mit SDL_Threads:

SDL_Thread *thread;

int say_str(void *str)
{
	std::string *s = (std::string*)str ;
	std::cout << *s << std::endl;
	*s="Bye, bye!";
	return 0;
}

int main(int argc, const char* argv[])
{
	std::string s="Hallo!";
	void *tmp=&s;
	thread = SDL_CreateThread( say_str,  tmp );
       /* Hier evtl. sleep-befehl einbauen, damit der Thread auch genug Zeit zum ändern hat
       bei mir gings auch ohne. */
	std::cout << s << std::endl;
	return 0;
}

Hier noch was zum lesen über void Pointer:
http://www.imb-jena.de/~gmueller/kurse/c_c++/c_void.html

 

[bigbertinator]

Hey, thx für die lösung

Klappt alles Wunderbar.

Nächstesmal versuche ich mich besser auszudrücken.


Edit:

Gibt es auch eine Möglichkeit, 2 Werte zu übergeben? Versucht habe ich es, aber war nicht sehr erfolgreich -.-

 

[LionC]

definiere eine struktur die du mit den beiden werten füllst und übergebe die.

noch eleganter ist es natürlich, wenn du eine allgemeine argumentstruktur erstellst, die dynamisch ist(also so viele argumente aufnehmen kann wie benötigt).

stichwort: malloc^^

giyf

 

[Extinction]

Praktisches Beispiel zur Struktur:

SDL_Thread *thread;

struct data{
	int a;
	int b;
};

int say_str(void *str)
{
	data *s = (data*)str ;
	data x=*s;
	std::cout << x.a << " - " << x.b << std::endl;
	return 0;
}

int main(int argc, const char* argv[])
{
	data s;
	s.a=1;
	s.b=2;
	void *tmp=&s;
	thread = SDL_CreateThread( say_str,  tmp );
	return 0;
}

 

[bigbertinator]

Danke Leute für diese super Lösung, sogar mit Codebeispiel, mein Hetzschlägt höher

MfG bigbertinator

 

[LionC]

nomma ein beispiel zu einer dynamischne argumentklasse:

class arguments
{
public:
  arguments(int howmany)
  {
    thearray = malloc(sizeof(void*)*howmany);
  }
  ~arguments()
  {
    free(thearray);
  }
  void** thearray;
}

nun kannst du thearray einfach als void* array benutzen und mit argumenten füllen, musst dann halt in der funktion noch den void* auf deinen benötigten typ casten.

LionC

 

[bigbertinator]

Durch diese Möglichkeiten, kann ich aber nicht mehr die Adressen übergeben, so dass ich auf die Originalstrings zugreifen kann, oda?

Sprich, dass ich in meinem Thread einen String veränder. Siehe 1 Beispiel von Extinction.

 

[LionC]

hm..stimmt

dann müsstest du mit enum etc arbeiten das wird dan aber en bissel kompliziert.....dann mach lieber ne eigene struct für jedes prog^^

 

[bigbertinator]

Jo, denke das ist das beste, jedoch scheiterte es bei mir mit pointer beim struct -.- ich weiß einfach net warum. Naja ich versuche es iwi hinzubekommen.

bigbertinator

 

[Lesco]

Original von Extinction
Praktisches Beispiel zur Struktur:

SDL_Thread *thread;

struct data{
	int a;
	int b;
};

int say_str(void *str)
{
	data *s = (data*)str ;
	data x=*s;
	std::cout << x.a << " - " << x.b << std::endl;
	return 0;
}

int main(int argc, const char* argv[])
{
	data s; // <- riskant
	s.a=1;
	s.b=2;
	void *tmp=&s;
	thread = SDL_CreateThread( say_str,  tmp );
	return 0;
}

Diese Vorgehensweise ist potentiell gefährlich. Du legst die Datenstruktur hier auf dem Stack an, d.h. beim Verlassen der Funktion werden die Daten später überschrieben. In main() geht das noch, da beim Verlassen von main das Programm endet, aber ansonsten kann das dazu führen, dass man in dem Thread mit kaputten Daten weiterarbeitet. Stattdessen sollte man lieber malloc() oder new verwenden.

 

[Extinction]

@Lesco
Klar, alles was sich im Gültigkeitsbereich von main() befindet, wird auch mit dem beenden gelöscht. Darum entweder sicherstellen, dass main() nicht vor dem Thread beendet wird, oder dass man die Strukturen in den Gültigkeitsbereich vom Thread aufnimmt oder einfach einen Gültigkeitsbereich wählen, der beide Funktionen umfasst (was aber wohl am Ziel der Parameterübergabe vorbeischießt).
Zur allergrößten Not kann man vor dem returnen der Mainfunktion ja auch etwas 'a la:

void SDL_WaitThread (SDL_Thread *thread, int *status);

machen.

Aber ich glaube es war auch gewünscht, in den selben Speicher wie main() zu schreiben.

 

[bigbertinator]

Ja, die main Funktion läuft die ganze Zeit, die Threads werden vorm schließen der main Funktion beendet.

Aber ich muss nun 2-3 Varaibeln übergeben, die ich im Thread verändern kann. Sprich mit Pointern übergeben, jedoch gelingt es mir nicht -.-

 

[LionC]

pointer wird nix, du darfst nicht in andere threads schreiben, musst returns benutzen.

 

[bigbertinator]

Gut, aber da bräuchte ich echt hilfe, denn

thread + return + void == 0 ahnung

Aber warum geht dass net mit Pointern, ohne struct funktioniert es doch auch.

bigbertinator

 

[Lesco]

Ein Pointer allein reicht nur, wenn du lediglich ein Argument übergeben willst. Bei mehreren musst du diese in ein Struct zusammenfassen(oben sind Beispiele), da du nur einen void* zur Verfügung hast, um dem Thread Informationen zu übermitteln.

du darfst nicht in andere threads schreiben, musst returns benutzen.

Ich glaube du redest da von Prozessen. Speicher ist nicht eindeutig einem Thread zugeordnet, jeder kann da rein schreiben. Man muss nur aufpassen, dass der Speicher auch während der gesamten Ausführungszeit gültig bleibt, daher ist es sinnvoll diesen auf dem Heap und nicht in einem Funktionsstack anzulegen.