Newsgroup: it.comp.lang.c
Titolo: ridurre un buffer dalla testa

salve a tutti quanti.
Mi ritrovo un buffer, dal quale devo "segare" N byte dalla *testa* e mi 
sto scervellando come un matto per trovare un modo "elegante" per farlo.
(realloc lavora solo dalla cosa, mannaggia).
Attualmente faccio un accroccio simile al seguente codice (riadattato 
per l'occasione):
char* new;
char* buf=(char*)malloc(sizeof(char) * N);
int sizeBuf = N;
sizeBuf = sizeBuf - daTogliere;
new = (char*)malloc(sizeof(char)*(*sizeBuf));
memcpy(new, buf+daTogliere, sizeBuf);
free(buf);
buf=new;
Spero che non sia l'unico metodo, perche' fare tutte le volte memcpy e' 
alquanto bruttino; puo' andar bene se si devono spostare pochi byte e 
poche volte, altrimenti e' un po' troppo onerosa.
Qualche suggerimento ?
(escludendo tutte le possibilita' che prendino in "ballo" una lista)
Grazie infinite
Ciao
	MaX

 Ciao
Ciao a te
-- 
none

 (realloc lavora solo dalla cosa, mannaggia).
Ahime' temo che non ci sia un modo _elegante_ ma _automatico_ per fare
quello che vuoi tu.
Propongo due soluzioni. La prima e` adottare un approccio a mio avviso
piuttosto elegante, che potremmo definire object oriented. Prevede l'uso
di una struttura. La struttura contiene due puntatori: il primo 'start'
e` l'indirizzo dell'intero array; il secondo 'head' e` l'indirizzo
dell'array "troncato". NB. Per semplicita`, il codice che segue _non_
esegue alcun controllo di errore; inoltre non badate ai nomi, alle 2 di
notte non ho troppa fantasia :)
   struct my_cp {
         char * start;
         char * head;
   };
   struct my_cp * my_cp_malloc (int itemnum)
   {
       struct my_cp * p;
       p = malloc(sizeof(struct my_cp));
       p->start = malloc(itemnum * sizeof(char));
       p->head = p->start;
       return p;
   }
   void my_cp_cut (struct my_cp * p, int items)
   {
       p->head += items;
   }
   void my_cp_free (struct my_cp * p)
   {
       if ( !p )
           return;
       free(p->start);
       free(p);
   }
La soluzione puo` essere arricchita a piacimento, magari inserendo
un campo nella struttura con il numero di elementi, usare questo
numero per controllare che la my_cp_cut() non ne tagli piu` di quanti
ce ne siano, ecc...
Tutte le volte in cui devi usare questi array _tagliabili_ in testa,
usi la struct my_cp.
La seconda soluzione, lo ammetto, e` un po' piu` fantasiosa e forse
non molto generalizzabile (dipende da quello che ci devi fare).
Invece di memorizzare l'array dal primo all'ultimo elemento, lo
memorizzi al contrario. Per esempio, invece di
   "cane"
memorizzi
   "enac"
A questo punto tagli alla fine, magari con la realloc() oppure
riempiendo di caratteri '\0' il fondo della stringa, o come preferisci.
Questo equivarra` a tagliare caratteri dall'_inizio_ della stringa.
E` ovvio che, cosi` com'e`, la stringa non ha grandissima utilita`,
per cui sei costretto a reimplementarti un bel po' di funzioni che
manipolano le stringhe in modo che tu ne abbia delle versioni che
capiscano queste stringhe particolari.
A seconda del tipo di manipolazione che devi fare con la stringa,
questo potrebbe essere un lavoro piu` o meno faticoso, per cui la
questa soluzione va valutata con molta attenzione.
In generale, io preferirei la prima.
Saluti,
Marco

Beh la tua soluzione a me pare buona, non elegante ma buona.
L'unica cosa che mi va di chiederti č: sicuro che tu non possa cambiare 
il modo di funzionare del tuo programma?
Mi pare strano (ma credo che avrai comunque un motivo) perchč sia 
necessario troncare la parte iniziale di un buffer, piuttosto che la fine...
Magari se postassi il contesto ti potremmo dire di piů :)
-- 
Quando noi ignoranti eravamo di piů, tutto era piů bello...
(A. Celentano)
Per rispondermi in privato, prima togli l'immondizia dalla testa.

 
HeHe, il tutto e' distribuito su piu' di 4000 righe di codice e su piu' 
files, non penso sia una buona idea ;)
Comunque, grazie a tutti quanti.
Ciao
	MaX