Hallo es gibt in der string.h unter Linux eine Funktion die earse heißt und folgendes macht string x=wert; wert="10.10"; x.erase(2,1); hier ist dann x=1010; gibt es sowas auch in der GCC??? will nicht mit schleifen arbeiten. Danke
Sieht nach C++ aus, nicht wahr? Hättest du wahrscheinlich auf dem AVR auch, wenn wir eine C++-Bibliothek hätten (aber das sieht so aus, als würde sich Rolf Magnun mittlerweile dafür interessieren). Anyway, für normale C-Strings kannst du memmove() benutzen:
1 | char x[] = "10.10"; |
2 | memmove(x + 2, x + 2 + 1, strlen(x) - 2 - 1 + 1); |
Dabei stehen die Zweien für die 2 aus deinem erase(), die Einsen für die 1 aus deinem erase() mit Ausnahme der letzten +1: die ist dafür verantwortlich, dass das abschließende '\0' ebenfalls noch mit kopiert wird.
Falls du die Position des '.' nicht kennst..
1 | char *pp = strchr(x, '.'); |
2 | if(pp != NULL) |
3 | memmove(pp, &pp[1], strlen(pp)); |
Hmm. Da kommt überall ein strlen vor. Das schmeckt mir nicht :-) void strdel( char* where, int start, int len ) { strcpy( x + start, x + start + len ); } char x[] = "10.10"; strdel( x, 2, 1 ); wäre naheliegend, geht aber nicht, da strcpy() fordert, dass die strings nicht 'überlappen'. void strdel( char* where, int start, int len ) { char* src = where + start + len; char* dest = where + start; while( *src ) *(dest++) = (*src++) *dest = '\0'; } Ich hab das jetzt nicht getestet, müsste aber funktionieren.
Da hat wieder mal der Tepfullerteufel zugeschlagen:
> *(dest++) = (*src++)
*(dest++) = *(src++);
Mal eine allgemeine Frage: Wenn ich die Wahl habe zwischen mem.. oder str.. Funktionen, welche sind effizienter in der Ausführung? Die mem-Funktionen habe ich bis jetzt nich nie benutzt :-/
mem* ist effizienter, weil es sich nicht um die Erkennung des abschließenden Nullbytes kümmern muss, sondern gesagt bekommt, wie viel Bytes zu bearbeiten sind. Das heißt, die sind natürlich nur effizienter, wenn du nicht stattdessen dann noch ein strlen() aufrufen musst.
Ich halte mich an die einfach Regel: Habe ich ein Byte-Feld ohne eine 'innere Struktur', dann benutze ich die mem...() Familie. Habe ich also Strings (das sind auch nichts anderes als Byte-Felder, nur halt mit dem klitzekleinen Unterschied, dass das Ende mit einem '\0' Byte markiert ist) dann benutze ich die str...() Familie. Die str...() Familie weiss um dieses '\0'-Byte und bezieht es in Schleifen- Abbruchbedingungen ein.
Bitte melde dich an um einen Beitrag zu schreiben. Anmeldung ist kostenlos und dauert nur eine Minute.
Bestehender Account
Schon ein Account bei Google/GoogleMail? Keine Anmeldung erforderlich!
Mit Google-Account einloggen
Mit Google-Account einloggen
Noch kein Account? Hier anmelden.