aus string '.' heraustrennen

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.

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++);

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.