String splitten (Programmiersprache: C)

Gast #1663694
Hallo beisamen,

kann mir jemand dabei helfen einen String nach einem bestimmten 
Trennzeichen zu splitten ? Der String sind immer so aus:  a:b;eineZahl#

Der String wird vom PC zum µC mit UART gesendet. Ich habe es mit 
strtok_r versucht, aber irgendwie klappt das nicht.

Danke !
Leon schrieb:

> Der String wird vom PC zum µC mit UART gesendet. Ich habe es mit
> strtok_r versucht, aber irgendwie klappt das nicht.

Dann solltest du deinen Versuch, der "irgendwie nicht klappt" zeigen. 
Dann kann man auch gezielt helfen und auf deine Defizite eingehen.
Gast
Hier ist mein Versuch:
1
char string[] = "a:b;100#"
2
char *tmp;
3

4
char *links;
5
char *rechts;
6

7
links=strtok_r(string,";",&tmp);
8
rechts=strtok_r(NULL,",",&tmp);

Laut diesen Code müsste doch in "links" a:b und in "rechts" 100# drin 
sein oder nicht ?
Leon schrieb:
> Hier ist mein Versuch:
>
>
1
> char string[] = "a:b;100#"
2
> char *tmp;
3
> 
4
> char *links;
5
> char *rechts;
6
> 
7
> links=strtok_r(string,";",&tmp);
8
> rechts=strtok_r(NULL,",",&tmp);
9
>
>
> Laut diesen Code müsste doch in "links" a:b und in "rechts" 100# drin
> sein oder nicht ?

Kommt drauf an, was du unter 'drinn sein' verstehst.
links und rechts sind einfach nur Zeiger in den originalen String, so 
ähnlich wie ein Lesezeichen eine Stelle in einem Buch markiert aber 
selber keinen Text hält.

Aber um auf die Frage einzugehen: Ja, links und rechts müssten auf die 
entsprechenden Abschnitte in string zeigen (und string ist dabei mit \0 
Zeichen modifiziert worden)

Die spannende Frage lautet daher: Was machst du in den nicht gezeigten 
Code-Teilen?
Gast
kann ich dann anhand dieser Leesezeichen den Stringabschnitt in eine 
Variable packen, die ich dann z.b. mit UART wieder zurück zum PC sende ?

Wenn ja wie mache ich das am besten ? mit strncpy ?
Leon schrieb:
> kann ich dann anhand dieser Leesezeichen den Stringabschnitt in eine
> Variable packen, die ich dann z.b. mit UART wieder zurück zum PC sende ?

Sicher kannst du.

> Wenn ja wie mache ich das am besten ? mit strncpy ?

"Am besten" ist immer relativ.

Ja, strncpy wäre eine Möglichkeit. Eine andere wäre es, die einzelnen 
Stringteile gar nicht umzukopieren. Hängt halt alles immer davon ab, ob 
es eine Möglichkeit gibt, dass sich 'string' während dieser Operation 
verändert oder nicht.

Beim Umkopieren wiederrum hat man das Problem, dass man die maximale 
mögliche Länge der Teilstrings vorher abschätzen muss. Wenn es dafür 
eine sinnvolle Obergrenze gibt und ev. Vorkehrungen trifft, dass die 
Teilstrings die Arrays für die Kopie nicht überlaufen, dann ist auch das 
natürlich eine Möglichkeit.
1
  char string[] = "a:b;100#"
2
  char *tmp;
3
  char part1[30];
4
  char part2[30]; 
5

6
  char *links;
7
  char *rechts;
8
 
9
  links=strtok_r(string,";",&tmp);
10
  rechts=strtok_r(NULL,",",&tmp);
11

12
  // die Einzelteile in Sicherheit bringen
13
  strncpy( part1, links, sizeof( part1 ) );
14
  part1[ sizeof( part1 ) - 1 ] = '\0';
15

16
  strncpy( part2, rechts, sizeof( part2 ) );
17
  part2[ sizeof( part2 ) - 1 ] = '\0';
18
  
19
  // mach was damit
20
  uart_puts( part1 );
21
  uart_puts( part2 );
Dein Beispiel oben funktioniert im Prinzip; abgesehen davon,
daß ein Semikolon fehlt.
(Wäre schön, wenn man hier kompilierbaren Originalquelltext
reinkopieren würde, und nicht irgendetwas, was so ähnlich
aussieht).

Hier mit kopieren:
1
  char string[] = "a:b;100#";
2
  char *tmp;
3

4
  char *links;
5
  char *rechts;
6

7
  char links_kopie[20];
8
  char rechts_kopie[20];
9

10
  links=strtok_r(string,";",&tmp);
11
  rechts=strtok_r(NULL,",",&tmp);
12

13
  printf( "<%s><%s>\n", links, rechts );
14

15
  strncpy( links_kopie, links, sizeof(links_kopie) );
16
  strncpy( rechts_kopie, rechts, sizeof(rechts_kopie) );
17

18
  printf( "<%s><%s>\n", links_kopie, rechts_kopie );
Klaus Wachtler schrieb:

>   strncpy( links_kopie, links, sizeof(links_kopie) );
>   strncpy( rechts_kopie, rechts, sizeof(rechts_kopie) );

Aufpassen.
Wenn du strncpy so wie hier benutzt, bist du nicht wirklich sicher. 
strncpy hängt kein \0 Byte an, wenn die Destination droht überzulaufen. 
Du hast dann zwar beim Umkopieren keinen Schaden angestellt, kriegst 
dann aber mit Sicherheit bei der Arbeit mit der Kopie Probleme.

Ist mir ehrlich gesagt ziemlich unverständlich, warum man hier nicht 
konsequent genug war, in diesem Fall ein abschliessendes \0 Byte zu 
fordern. Denn so wie es jetzt ist, ist strncpy auch nur ein 'pain in the 
ass'

Möchte nicht wissen, wieviele Funktionen
1
char* strncpy_safe( char* dest, const char* source, size_t num )
2
{
3
  char* res = strncpy( dest, source, num );
4
  dest[ num - 1 ] = '\0';
5
  return res;
6
}
weltweit mittlerweile geschrieben wurden.
So ist das strncpy gefährlich. links_kopie und rechts_kopie sind nicht 
zwangsläufig 0-terminiert.

Korrekt lautet die strncpy-mimik hier:

strncpy( links_kopie, links, sizeof(links_kopie) - 1 );
links_kopie(sizeof(links_kopie) - 1) = 0;

... gleichartig mit rechts_kopie.

Bernhard

p.s. da war ich etwas langsam mit dem Schreiben.
Gast
und mit   strncpy( part1, links, sizeof( part1 ) ); kopiere ich von 
links in part1 soviel rein, wie in part1 überhaupt rein passt, also 
sizeof( part 1) um somit ein Überlauf zu vermeiden... das klingt sehr 
gut.
Gast
Wenn ich mit nun mit printf(part1); den Part ausgeben möchte, meldet der 
Compiler eine Warnung: format not a string literal and no format 
arguments.

Ok die letzte Fehlermeldung bedeutet, dass ich keine 
Formatierungsargumente angegeben habe, aber wie löse ich das Problem mit 
dem string ? Oder sollte man lieber nicht printf benutzen um 
Variableninhalte auszugeben ?
Leon schrieb:
> Wenn ich mit nun mit printf(part1);...

Das ist Quark.
Wenn man keine Formatierung braucht, ist printf() unpassend.
Und wenn schon, dann printf("%s",part1), weil du sonst Probleme
bekommst, wenn im String ein Prozentzeichen auftaucht.
Gast
Entschuldigt mich, wenn ich so viel rum antworte, aber wenn ich nun von 
dem part1 nur den zweiten "char" ausgeben möchte, mache ich das mit 
puts(&part1[2]);  Wenn ich nun das ohne & mache bekomm ich ein Fehler, 
da der Compiler ja nicht den char-Wert ausgibt, sondern die 
Speicheradresse vom Zeiger oder wie verstehe ich das ?  Ich weiß das man 
mit dem &-Operator an den Wert der Variablen ran kommt.
Lies doch mal ein C-Buch...

Mit puts gibt man nicht ein Zeichen aus, sondern einen
nullterminierten String.
Willst du das zweite Zeichen haben, geht das mit putchar(&part1[1])
([1] statt [2], weil es bei 0 anfängt zu zählen).

puts(&part1[2]) würde ab dem dritten Zeichen bis zum Ende ausgeben.
Gast
Ich hab ein C-Buch hier neben mir legen und lese auch parallel dazu !

Danke ! Ich werde auch keine weiteren Fragen mehr stellen und euch von 
diesen Qualen erlösen g
Gast
Der Programmcode hängt davon ab, was Du mit dem String machen willst, ob 
Du den String vom µC weiter brauchst, und wo Du das Ergebnis halten 
willst.

strtok_r zu benutzen... Na ja, mit einem Mikroskop kann man auch nageln. 
strchr wäre besser.

Angenommen, der String vom µC liegt in instr[]:

char instr[128];

dann, um das erste ';'-Zeichen im instr zu finden, ruft man strchr so 
auf:

char *semi;
. . .

semi = strchr(instr, ';');


Nicht vergessen zu prüfen, ob ';' gefunden wurde:

if (semi==NULL) {
  printf("Scheisse, der µC hat ungültigen String ohne ; geschickt!\n");
  return;
}

Fall 1:

Der Inputstring brauchst Du nicht mehr, dann kannst Du zwei Teile in 
instr halten:

*semi++ = '\0';

Der erste Teil ist instr, der zweite Teil ist semi:

// Testausdruck
printf("Teil 1: %s\nTeil 2: %s\n", instr, semi);

Fall 2:

Der Inputstring brauchst Du weiter, und zwar unverändert, dann musst Du 
die Teile irgendwo hinkopieren.

Fall 2a:

Die Zielstrings (die Teile vom µC-String) sind statische Arrays:

char teil1[128], teil2[128]; // hier wird genug Platz allokiert,
// daher muss man sich nicht um die Länge kümmern

*semi = '\0';
strcpy(teil1, instr);
strcpy(teil2, semi+1);
*semi = ';';   // den µC-String wiederherstellen
// Testausdruck
printf("Teil 1: %s\nTeil 2: %s\n", teil1, teil2);


Fall 2a:

Die Zielstrings werden dynamisch allokiert. Vorteil: der Speicher wird 
sparsamer benutzt; Nachteil: man muss am Ende die Zielstrings freigeben.

char *teil1, *teil2;

*semi = '\0';
teil1 = strdup(instr);
teil2 = strdup(semi+1);
*semi = ';';   // den µC-String wiederherstellen
// Testausdruck
printf("Teil 1: %s\nTeil 2: %s\n", teil1, teil2);


// nachdem die Teile bearbeitet wurden, sollen sie freigegeben werden
free(teil1);
free(teil2);


Wenn Du den Originalstring brauchst, kannst Du auch diesen kopieren und 
weiter mit der Kopie wie im Fall 1 arbeiten:

char instr[128], kopiestr[128];
char *semi;
. . .

strcpy(kopiestr, instr);
semi = strchr(kopiestr, ';');
if (semi!=NULL) {
  *semi++ = '\0';
  // Testausdruck
  printf("Teil 1: %s\nTeil 2: %s\n", kopiestr, semi);
}
else {
  printf("bad string!\n");
}
Gast
Hallo,

ich lese über die Serielle Konsole Werte ein.

Diese bestehen aus einem Buchstaben(klein) sowie maximal 3 Zahlen.

Wie kann ich nun am besten diese Aufteilung machen.

In cmd lade ich den ersten Buchstaben aus dem string rein. Macht dieser 
keinen Sinn wird der String gelöscht -> Falsche Eingabe.

Wie kann ich nun am einfachsten die restlichen Zeichen aus dem String 
auslesen?
1
void cmd_switch(void)
2
{
3
  char cmd = uart_string[0];
4
  
5
  switch(cmd)
6
  {
7
    case 'm':
8
    uart_puts_p(PSTR("MOTOR\r\n"));
9
    break;
10
    
11
    case 'l':
12
    uart_puts_p(PSTR("LEDS\r\n"));
13
    break;
14
    
15
    case 's':
16
    uart_puts_p(PSTR("SPEED\r\n"));
17
    break;
18
    
19
    case 'u':
20
    uart_puts_p(PSTR("UEBERSICHT"));
21
    break;
22
    
23
    default:
24
    uart_puts_p(PSTR("ERROR\r\n"));
25
    memset(uart_string, 0, UART_MAXSTRLEN);
26
  }
27
}
Karl Heinz schrieb:
> Ja, strncpy wäre eine Möglichkeit. Eine andere wäre es, die einzelnen
> Stringteile gar nicht umzukopieren. Hängt halt alles immer davon ab, ob
> es eine Möglichkeit gibt, dass sich 'string' während dieser Operation
> verändert oder nicht.
>
> Beim Umkopieren wiederrum hat man das Problem, dass man die maximale
> mögliche Länge der Teilstrings vorher abschätzen muss.

oder er merkt sich die Position ; +1 und setzt in ; die /0

damit ist der String links terminiert und rechts war er ja schon 
terminiert nur muss er den String rechts als Pointer gemerkt den Start ; 
+1 zuweisen.

Vorteil, kein zusätzlicher Speicherplatzbedarf und kein Umkopieren.

Antwort schreiben

Eine eigene Frage? Dieser Thread ist über 16 Jahre alt. Stell sie in einem eigenen Thread – dort lesen mehr Leute mit, und sie wird öfter und schneller beantwortet.

Neuen Thread starten

Eine Lösung, Ergänzung oder Rückmeldung zu diesem Thread? Dann antworte hier.

Formatierung
  • [c]C-Code[/c]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] – Link zu einem Artikel
  • Verweis auf einen anderen Beitrag: Rechtsklick auf dessen Beitrags-ID (#8078628), „Adresse kopieren“, in den Text einfügen

Mehr zur Formatierung

Längeren Sourcecode als Anhang, nicht in den Text. JPG nur für Fotos und Scans; Zeichnungen und Screenshots als PNG oder GIF. Siehe Bildformate.

Schon registriert? Anmelden

Wird nicht angezeigt. Wir schicken dir einen Link; sobald du damit bestätigst, erscheint dein Beitrag.

Mit dem Abschicken legst du einen kostenlosen Account an und erkennst die Nutzungsbedingungen und die Datenschutzerklärung an.