aus string '.' heraustrennen

[HerrmannA (Gast)]

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

[Jörg W. (dl8dtl) (Moderator)]

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:

char x[] = "10.10";
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.

[Werner B. (Gast)]

Falls du die Position des '.' nicht kennst..

char *pp = strchr(x, '.');
if(pp != NULL) 
   memmove(pp, &pp[1], strlen(pp));

[Karl heinz B. (kbucheg)]

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.

[Karl heinz B. (kbucheg)]

Da hat wieder mal der Tepfullerteufel zugeschlagen:

>    *(dest++) = (*src++)

     *(dest++) = *(src++);

[Thomas (Gast)]

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 :-/

[Jörg W. (dl8dtl) (Moderator)]

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.

[Karl H. (kbuchegg)]

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.

[HerrmannA (Gast)]

Danke das so gehts.

Keine lästigen For schleifen.