Hallo!

Meiner DLL in (c++60 geschrieben) will ich einen String übergeben (mit c#, vb etc).


Der übergebene String soll wie eine ASCII-Datei aufgebaut sein.

Bsp:
Test V01
man 10
Axel 5
Gewicht 20
STRCOP 25 //vor STRCOP ist ein Tab
Test V02
man 10
Flip 5
Gewicht 20
STRCOP 45 //vor STRCOP sind 5 Leerzeichen
Bla2 15


Obiges soll als String im gesamten übergeben werden.

==> Wie lese ich diese Daten in c++ nun ein?

Man bedenke es gibt hier "ENTER" und "Tab" bzw. "Leerzeichen". Ich brauche die Texte hieraus, um diese dann in der DLL weiter verarbeiten zu können.
Und hier habe ich ein (großes!) Defizit in c++.

Ich hoffe, jemand hat ne Idee oder kann mir eine Internet-Adresse zum Nachlesen nennen.

Vielen Dank!

Normalerweise wird man aus dem String Token extrahieren. Dafür gibts eine C-Funktion:

char *strtok( char *strToken, const char *strDelimit )

Die Delimiter sind in Deinem Fall die "ENTER"-Zeichen, also "\n" (evtl. auch "\r\n", je nach dem). Funktionieren tut das in etwa so:



#include <string.h>
#include <stdio.h>

char string[] = "A string\tof ,,tokens\nand some more tokens";
char seps[] = " ,\t\n";
char *token;

void main( void )
{
printf( "%s\n\nTokens:\n", string );
/* Establish string and get the first token: */
token = strtok( string, seps );
while( token != NULL )
{
/* While there are tokens in "string" */
printf( " %s\n", token );
/* Get next token: */
token = strtok( NULL, seps );
}
}

^aus der MSDN-Library entnommen^

Hallo!

Vielen Dank für Deine Antwort. Aber ich habe immer noch ein Problem.
Und zwar:

Nehmen wir die Zeile:

char string[] = "A string\tof ,,tokens\nand some more tokens";

Bei mir befindet sich dieser Text in einem char* xyz.
Wie kann man nun einen 'String' vom Typ char* xyz in einen std::string umwandeln?

Ich habe arge Probleme damit! Ich hoffe Du kannst mir helfen.

Danke!

Also ob der String in einem char[] oder char* steht, ist im Prinzip egal (weil es mehr oder weniger das Gleiche ist). strtok kannst Du doch mit dem char* aufrufen, also wozu konvertieren?

Hallo!

Danke für die Antwort!

Kannst Du Dir bitte mal folgenden Code angucken:


#include <stdio.h>
#include <string.h>


void load(char* xyz);

char seps[] = " ,\t\n";
char *token;

int main ()
{
load("A string\tof ,,tokens\nand some more tokens");
return 0;
}
void load(char* xyz)
{
printf( "%s\n\nTokens:\n", xyz );
/* Establish string and get the first token: */

token = strtok( xyz, seps ); //***Anmerkung siehe unten

while( token != NULL )
{
/* While there are tokens in "string" */
printf( " %s\n", token );
/* Get next token: */
token = strtok( NULL, seps );

}
}

***Anmerkung: Zwar kann ich das Programm kompilieren ohne Fehler. aber es bricht beim Debuggen bzw. Ausführen zusammen "Unbehandelte Ausnahme: Zugriffsverletzung)

Deswegen hatte ich mir gedacht, ich wandle meinen char* xyz in ein std::string um, dann klappts. Was meinst Du zu obigem?

Danke im voraus!
Gruß

Wie kann man nun einen 'String' vom Typ char* xyz in einen std::string umwandeln?

So:

Code :

1	string abc = xyz  // wobei xyz ein char* ist

der std::string hat einen Konstrukter, der einen char* aufnimmt.
@How bitte benutze Code-Tags !!

Gruss Homer

Anscheinend ist beim copy&paste bei Dir was schief gegangen, aber egal. Das Problem liegt in dem Aufruf der Funktion load() mit einer Stringkonstante. Diese wird (vom Compiler) erzeugt, wenn Du die Funktion mit dem String direkt aufrufst. strtok verändert aber den übergebenen String, indem es "\0" an die Stellen schreibt, wo ein gefundenes Token endet. In Deine Stringkonstante kann es aber nix schreiben, weil's eben eine Konstante ist. Der String muß vor dem Aufruf in ein char text[] = "A string\tof ,,tokens\nand some more tokens" und dann die Funktion load mit load(tester) aufgerufen werden. Dann ****t des...

Danke! Es läuft nun endlich!

Aber ich stehe vor einem neuen Problem.

Wie mache ich es am besten, wenn ich bspw. diesen string "A string\tof ,,tokens\nand some more tokens" nehme und jedes Wort einzeln einer anderen Funktion übergeben möchte?

Ich habe es mit for-Schleifen probiert auch mit if-Abfragen, aber irgendwie kriege ich es einfach nicht hin.

Wenn ich bspw. den Wert in token übergeben will und dann wieder zurück in die Schleife möchte um dann bei dem zweiten Wort anzufangen, um den wieder zu übergeben etc. bricht alles bei mir zusammen.

Ich hoffe, ich habe mich verständlich genug ausgedrückt, wenn nicht, bitte anmosern...!

Also ich erklär mal kurz die Funktionsweise von strtok(), damit Du weißt wo vermutlich der Fehler liegt.

Ein String ist in C nichts weiter als ein Zeiger auf das erste Zeichen des Textes, der in dem String enthalten ist. Dieser Text steht irgendwo (hintereinander) im Speicher, in der char*-Variablen steht lediglich die Adresse des ersten Zeichens vom String. C weiß prinzipiell nicht, wo der String aufhört, deshalb werden Strings mit einer "\0" abgeschlossen (\0 ist ein Sonderzeichen, es sind also nicht zwei Zeichen, sondern nur ein besonderes, das man mit \0 symbolisiert). Dieses Zeichen zeigt an, das der String an dieser Stelle aufhört. Im Speicher steht also ein Text für gewöhnlich ungefähr so:

Das ist ein Text.\0
^ (Zeiger auf den String)

strtok() durchläuft den String nun einfach von vorne nach hinten und wenn es einen der angegebenen Delimiter findet, ersetzt es ihn mit einer \0. Wäre also das Leerzeichen einer dieser Delimiter, dann würde strtok den String bis zum ersten Leerzeichen durchlaufen

Das ist ein Text.\0
^ (hier ist der Delimiter)

und ihn ersetzen. Das würde also dann so aussehen:

Das\0ist ein Text.\0

In dem token steht ein Zeiger auf das Zeichen des Originaltextes, bei dem zuletzt der Delimiter gefunden wurde. In diesem Fall ist das der selbe Zeiger wie der auf den Originalstring, weil ja erst ein Token gefunden wurde:

Das\0ist ein Text.\0
^ (token zeigt hier hin)

Da nun strtok das Leerzeichen mit der \0 ersetzt hat, ist der String auf den token zeigt an dieser Stelle zu Ende. Ergo: "Das" ist der String auf den token zeigt. Beim nächsten Aufruf von strtok sieht die Situation folgendermaßen aus:

Das\0ist\0ein Text.\0
^ ^(das wurde von strtok ersetzt
(hier zeigt token hin

Also das nächste Token ist "ist". Das geht immer so weiter, bis das Ende des Originalstrings erreicht wurde, also das \0 von "Das ist ein Text.\0".

token zeigt also immer auf einen Teil des Originalstrings. Wenn man jetzt diesen Teilstring an eine Funktion übergibt, ist das grundsätzlich kein Problem. Nur sollte diese Funktion nichts daran verändern, außer man weiß, was man tut. strtok kommt sonst möglicherweise ins Schleudern (warum erklär ich jetzt nicht... ).

Beispiel:

Code :

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

#include <string.h> #include <stdio.h>   char string[] = "A string\tof ,,tokens\nand some  more tokens"; char seps[]   = " ,\t\n";   void DoSomething(char* temp) {       printf("%s\n", temp); }     void main() {      char* token;      token = strtok( string, seps );      while( token != NULL ) {            DoSomething(token);              token = strtok( NULL, seps );     } }

Hallo!

Zuerst einmal, vielen Dank für die Geduld!

Ich danke Dir für die ausführliche Erklärung. Jetzt hab' ich es mit strtok verstanden!


Allerdings konnte ich mein Problem mit diesen Schleifen und Funktionssprüngen nicht lösen.

Ich sitze zur Zeit nicht vor meinem eigenen Computer, habe also den Code nicht parat, aber so ungefähr baut sich alles auf:


Nehmen wir an der Stringinhalt (MeinString) setzt sich folgendermaßen zusammen: "Hallo ich bin es.\n Wie geht es Dir"

Meine Funktion Funk1

Code :

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

bool Funk1(char* MeinString) {     ...     //char MeinString zu string xyz umwandeln     // if-Abfrage (mache solange weiter bis der gesamte String (xyz) durchgearbeitet ist)       Funk2(xyz);     if (!xOk) return false;       if (keyword == "Hallo")     {         //tue das     }     if (keyword == "ich")     {         //tue das     }       if (keyword == "bin")     {         //tue das     }     if (keyword == "es")     {         //tue das     }       ...   ... }

hat den gesamten Inhalt des Strings (MeinString) und übergibt es an eine Zwischenfunktion Funk2 mit dem String xyz.

Code :

1 2 3 4 5 6 7

void Funk2(string xyz) {     ...     string bla;     bla = Funk3(xyz)  //Funktionsaufruf Funk3 ... }

Diese FUnk2 ruft die Funktion Funk3 auf

Code :

1 2 3 4

string Funk3(string xyz) {       return Funk4(xyz);    ////Funktionsaufruf Funk4, ermittle Wort aus dem String }

Funk3 ruft dann schlußendlich die Funk4 auf

Code :

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

string Funk4(string xyz) {    string keyword ="";      char* token;      token = strtok( xyz, seps );      while( token != NULL ) {            //************ Problem 1              token = strtok( NULL, seps );     }      keyword = token; //war es glaube ich, genau weiß ich es momentan nicht      return keyword; }

Nun habe ich insofern ein Problem, wie ich durch die Funktionen mich codemäßig durcharbeiten muß.

Problem 1:
Funk4 soll das ermittelte Wort (keyword) zurückliefern (aber sich auch merken, wo es bei der nächsten Suche weitergeht, nämlich bei Wort zwei, also müßte ein weiterer Zwischenstring her, der den "Reststring" abspeichert, der in meinem Code jedoch fehlt.

Problem 2:
Liegt in der Ursprungsfunktion (Funk1). Hier müßte ich irgendwie eine Abfrage hinbekommen, der die Funktion (Funk2) solange immer wieder aufruft, bis der gesamte String durchgearbeitet ist und alle Inhalte (Worte) einzeln an die Funktion (Funk1) übergeben und verarbeitet sind, und da scheiterts bei mir kläglich. Irgendwie habe ich mich so verrannt, daß ich aus dieser "Endlosschleife" nicht mehr rauskomme.

Gruß

Ach ja, was ich noch vergessen hab zu obigem anzumerken:

Eigentlich glaube ich, daß die Funktion (Funk4) nicht nur das ermittelte Wort (keyword) zurückliefern muß, sondern auch den "Reststring" (nennen wir es mal rString, damit die Funk1 überhaupt weiß, was er beim nächsten Aufruf von Funk2, Funk3 etc. weitergeben soll. Oder liege ich damit total falsch?!

Gruß

Also ich versteh nicht so ganz, was Du eigentlich vor hast...

Erklär mal bitte, warum Du für jede Teilaufgabe gleich 'ne neue Funktion schreibst und was Du am Ende eigentlich machen willst...

Ich sehe es auch so, daß zumindest die Funktion Funk3 wegfallen könnte, weil sie (scheinbar) überflüssig ist. Aber Funktion Funk2 ist notwendig, weil Funk2 eine weitere wichtige Abprüfung durchführt, nämlich, ob der erste Teil (Wort) des Strings bestimmte Voraussetzungen erfüllt, und das ist nun mal getrennt von allem anderen gelöst worden.

Frage: Gibt es nun keine Hoffnung für mich, oder ist es irgendwie lösbar, wenn ich zumindest auf die Funktion (Funk3) verzichte?

Danke!

Ich hab Dir da oben ein kleines Programm hingeschrieben, was eigentlich ganu das macht, was Du willst (oder nicht?!). Der String wird im Hauptprogramm geparsed (aus dem Hauptprogramm kannst Du genauso gut 'ne Funktion machen, die dann im neuen Hauptprogramm aufgerufen wird) und mit der Funktion [I]DoSomething(char* temp)[/B] kannst Du die Prüfung des Tokens machen. Je nach dem Ergebnis der Prüfung entscheidest Du dann (innerhalb der DoSomething()-Funktion) über das weitere Vorgehen.

Mehr kann ich dazu auch nicht sagen...

Ich gebe offen zu, Deine Ausführungen haben mich schon sehr weit gebracht!
Dafür danke ich Dir auch sehr, ich weiß, inzwischen nerve ich ab... Mich nervt es wirklich auch sehr, ich will aber das Handtuch noch nicht hinschmeisen und deshalb habe ich nun alles so umgestellt, daß zuerst die Funktion mit strtok durchgegangen wird und dann die ursprüngliche Funktion (Funk1), wo die einzelnen Worte, die von der strtok-Funktion übergeben werden, verarbeitet werden. Das ist im Endeffekt viel einfacher zu realisieren.

Dort, wo ich noch ein Problem habe ist, wo ist der "Reststring"?

In "token" ist ja das aktuell gefundene Word

In "xyz" ist der ursprüngliche gesamte String (Hallo ich bin es.\n Wie geht es Dir)

in "****?" soll der Reststring (bspw. beim ersten Durchgang:"ich bin es.\n Wie geht es Dir") sein.

Wie kriege ich nun diesen RestString heraus? Hast Du dazu einen Tip? Dann ist das 'Generve' hoffentlich vorbei!

Danke für die Geduld!