Newsgroup: it.comp.lang.c
Titolo: elimina il primo carattere da una stringa

Ciao, mi serve una Funzione che cancella semplicemente il primo
carattere da una stringa.
il prototipo della funzione è
void EliminaPrimoCarattere(char *buffer);
Qualcuno mi può aiutare?

Qualcuno mi puņ aiutare?
Scrivo al volo (non compilato):
#include <stdlib.h>
....
void EliminaPrimoCarattere(char *buffer) {
  if (buffer & buffer[0]!='\0') {
     int i=1;
     while (1) {
         buffer[i-1] = buffer[i];
         if (buffer[i] == '\0')
            break;
         --i;
     }
  }
}

 - Mostra testo tra virgolette -
Guarda vi è un errore nell'if, vi è una "&" che non so a cosa serva...


immagino che intendessi ++i invece che --i.
Io farei:
void EliminaPrimoCarattere(char *buffer) {
   int i=0;
   assert(buffer!=0);
   if (buffer[0]==0) return;
   do {
     buffer[i]=buffer[i+1];
   } while (buffer[i++]);
}
E.

 Guarda vi è un errore nell'if, vi è una "&" che non so a cosa serva...
Il codice era solo d'esempio, è il concetto di fondo che deve essere
chiaro.
L'and (quello corretto è quello che ho riscritto) serve a verificare che
la stringa non sia nulla (per qualsivoglia valore di "nulla" :-)
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

Qualcuno mi puň aiutare?
void EliminaPrimoCarattere(char *buffer)
{
if (buffer [0] != '\0')
   strcpy (buffer,buffer+1);
}

 }
Secondo me dovresti togliere lo strlen dal ciclo for. Questo rende 
l'algoritmo di complessita n^2 invece che n.
E.

 }
:-)
Immagino che il suo problema reale fosse implementare l'algoritmo ;-)


 Immagino che il suo problema reale fosse implementare l'algoritmo ;-)
Eppoi io non sono sicuro che cosě funzioni... le stringhe si 
"overlappano", siamo sicuri che strcpy faccia quello che ci si aspetta?
Bisognerebbe usare memmove.
E.

Stranamente non e` stata postata 
la soluzione piu` semplice:
char *p,*buffer
p=buffer;
while (!*p) 
  {
     *p=*(p+1);
      p++;
  }

 la soluzione piu` semplice:
Allora, volendo proprio comprimere:
void removeFirst(char *buffer) {
   while (*(buffer++))
     *(buffer-1)=*buffer;
}

 }
- funzioni cosi` dovrebbero essere 
  dichiarate inline
- non e` piu' compatta del mio ciclo 
  poiche' contiene una sottrazione 
  in piu`
Spiegazione:
il ciclo che ho scritto una volta compilato 
e` perfettamente equivalente a:
 
  while (!*p) *p=*(++p);
ma non soffre dei suoi problemi.

 ma non soffre dei suoi problemi.
si, infatti questa va evitata.
E.

 definito. 
Questo e` il problema a cui mi riferivo.

 "overlappano", siamo sicuri che strcpy faccia quello che ci si aspetta?
No anzi, č esplicitamente definito come un undefined behaviour.
E' un errore grosso come una casa.
-- 
blog:  
http://www.akropolix.net/rik0/blogs
 | Uccidete i filosofi,
site:  
http://www.akropolix.net/rik0/
      | tenetevi riso e
forum: 
http://www.akropolix.net/forum/
     | bacchette per voi.

 Questo e` il problema a cui mi riferivo.
Quindi non è perfettamente equivalente.  :)
Uno ha un problema e l'altro no. 
Poi non che la cosa mi cambi nulla, anche io preferisco la tua
scrittura, perchè molto più leggibile.


 void EliminaPrimoCarattere(char *buffer);
Č un prototipo suicida: non č in grado di sapere se *esiste* quel primo
carattare. In generale č buona pratica ogni volta che si passa un
puntatore passare anche la dimensione dell'area di memoria cui punti.


puntatore passare anche la dimensione dell'area di memoria cui punti.
Vedi sopra.  Nel caso delle stringhe non è necessario.

 grado di sapere sia se il puntatore è NULL, sia se la stringa è vuota.
Visto e considerato che la maggior parte dei bachi di software C sono
legati precisamente al passare in giro puntatori senza specificarne a
dimensione, resta comunque buona pratica farlo.
Si paga un piccolo prezzo e si evitano magagne maggiori. Anche perchè
sono tutti bachi estremamente difficili da prendere.


dimensione, resta comunque buona pratica farlo.
Tu parlavi di non essere in grado, da parte della funzione, di
riuscire a capire se la stringa ha un primo carattere ed io mi
riferivo a questo: semplicemente non è vero, perché esiste una
convenzione in C e se la convenzione viene rispettata, è possibile, da
parte di una funzione, capire se la stringa è vuota o meno (nel senso
logico più comune di "vuota": non possiede caratteri).
La "buona pratica" che consigli ha un senso nel caso si voglia rendere
più sicura la funzione (e su questo concordo), non nel caso in cui si
voglia fornire alla funzione la "capacità" di capire se la stringa è
vuota o meno; questa capacità ce l'ha già.

 vuota o meno; questa capacità ce l'ha già.
Questo è vero. Mi sono espresso male.


char *TogliIlPrimo(char *Str)
{
    return Str + 1;
}
No? 


L'OP ha chiesto esplicitamente che la funzione torni void.
E.