String splitten (Programmiersprache: C)

Gast #1663694
Lesenswert?
• ▲
▼
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 !
Gast #1663758
Lesenswert?
• ▲
▼
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 ?
#1663759
Lesenswert?
• ▲
▼
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?
#1663770
Lesenswert?
• ▲
▼
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 );
#1663776
Lesenswert?
• ▲
▼
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 );
#1663784
Lesenswert?
• ▲
▼
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.
#1663790
Lesenswert?
• ▲
▼
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 #1663799
Lesenswert?
• ▲
▼
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 #1663801
Lesenswert?
• ▲
▼
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 ?
Gast #1663808
Lesenswert?
• ▲
▼
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.
#1663820
Lesenswert?
• ▲
▼
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 #1664484
Lesenswert?
• ▲
▼
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 #3954280
Lesenswert?
• ▲
▼
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
}
#3954300
Lesenswert?
• ▲
▼
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

Bitte melde dich an, um einen Beitrag zu schreiben.

oder

Mit Google-Account einloggen

Die Registrierung ist kostenlos und dauert nur eine Minute.

Jetzt registrieren