Funzione in C

[legolas977]

Devo creare una funzione che mi permetta di rintracciare alcuni valori all'interno di un buffer di esadecimali, i valori che mi interessa salvare sono associati ad alcuni ID.
Ecco il buffer (La posizione 0 del buffer è il numero degli elementi):
17 00 04 FF FF 80 FF 09 06 FF 80 FF FF FF FF 10 02 FF 80 13 03 FF 80 FF
-IN NERETTO HO INDICATO GLI ID CHE DOVRO' RINTRACCIARE
-IN VERDE IL NUMERO DEGLI ELEMENTI DEL BUFFER
-IN ROSSO IL NUMERO DEGLI ELEMENTI DA SALVARE ASSOCIATI AL SINGOLO ID (che è quello che precede).
-IN BLU I VALORI DA SALVARE ASSOCIATI AL RELATIVO ID PRECEDENTE.
Per intenderci, faccio un esempio, devo salvare i byte FF 80 DEL ID "10" e FF FF 80 FF DEL ID "00".
La lunghezza dei singoli blocchi rimane sempre fissa, il problema è che a volte il buffer che ricevo puo avere blocchi in piu o in meno e la lunghezza dello stesso non è fissa(quella indicata in verde).

Io parto dalla seguente condizione iniziale:
Ho una funzione alla quale passerò ID da 0 a 100 con un ciclo FOR.
La stessa funzione dovrà restituirmi i valori (quelli in blu) che trova per ogni ID rintracciato nel buffer (facendo attenzione alla posizione in cui potenzialmente possa trovarsi questo benedetto ID), mettendomeli in buffer.
Grazie del gentile aiuto.

[MrX87]

bhà onestamente non ho ben afferrato cosa indica il numero scritto in verde!! perchè tu dici che è il numero di elementi del buffer...ma in questo caso ci sono più di 17 elementi!! bhà....poi comunque puoi gestire la lunghezza del vettore per memorizzare gli elementi con la allocazione dinamica!!

[legolas977]

0x17 elementi (23).
I valori sono esadecimali

[_Claudio]

Originariamente inviato da legolas977

Devo creare una funzione che mi permetta di rintracciare alcuni valori all'interno di un buffer di esadecimali, i valori che mi interessa salvare sono associati ad alcuni ID.
Ecco il buffer (La posizione 0 del buffer è il numero degli elementi):
17 00 04 FF FF 80 FF 09 06 FF 80 FF FF FF FF 10 02 FF 80 13 03 FF 80 FF
-IN NERETTO HO INDICATO GLI ID CHE DOVRO' RINTRACCIARE
-IN VERDE IL NUMERO DEGLI ELEMENTI DEL BUFFER
-IN ROSSO IL NUMERO DEGLI ELEMENTI DA SALVARE ASSOCIATI AL SINGOLO ID (che è quello che precede).
-IN BLU I VALORI DA SALVARE ASSOCIATI AL RELATIVO ID PRECEDENTE.
Per intenderci, faccio un esempio, devo salvare i byte FF 80 DEL ID "10" e FF FF 80 FF DEL ID "00".
La lunghezza dei singoli blocchi rimane sempre fissa, il problema è che a volte il buffer che ricevo puo avere blocchi in piu o in meno e la lunghezza dello stesso non è fissa(quella indicata in verde).

Io parto dalla seguente condizione iniziale:
Ho una funzione alla quale passerò ID da 0 a 100 con un ciclo FOR.
La stessa funzione dovrà restituirmi i valori (quelli in blu) che trova per ogni ID rintracciato nel buffer (facendo attenzione alla posizione in cui potenzialmente possa trovarsi questo benedetto ID), mettendomeli in buffer.
Grazie del gentile aiuto.

La cosa che mi viene in mente è fare un albero B+ usando le liste.
Elegante, snello e comodo.

[AnonimoVeneziano]

Beh, la struttura in questione del buffer è un array di byte.

E' abbastanza semplice fare quello che vuoi sapendo che il buffer è così composto :

[#elementi][ELEMENTI : [ID blocco][#elementi blocco][elementi blocco] ]

Mi viene in mente qualcosa del genere:

struct nodo_valori {
    int numero_elementi;
    unsigned char* valori;
    struct nodo_valori* next;
};

typedef struct nodo_valori nodo_valori;
typedef nodo_valori* lista_valori;

lista_valori funzione(unsigned char* buffer)
{
    lista_valori lista = NULL;
    lista_valori* current_next = &lista;
    int numero_elementi = buffer[0];
    int elementi_estratti = 1;
    int elementi_blocco = 0;
    int id_blocco = 0

    while (elementi_estratti < numero_elementi)
    {
          *current_next = (lista_valori) malloc(sizeof(nodo_valori));
          id_blocco = buffer[elementi_estratti];
          elementi_estratti++;         
          elementi_blocco = buffer[elementi_estratti];
          elementi_estratti++;
          *current_next->numero_elementi = elementi_blocco;
          *current_next->valori = (unsigned char*) malloc(sizeof(unsigned char)*elementi_blocco);
          *current_next->next = NULL;
          memcpy(*current_next->valori, buffer+elementi_estratti, elementi_blocco);
          elementi_estratti += elementi_blocco;
          current_next = &(*current_next->next);
   }

    return lista;
}

Spero di aver capito quello che volevi e di non aver fatto errori grossolani visto che è un po' che non uso il C.

Ciao

[legolas977]

In modo un po piu semplice senza puntatori? qualcuno puo aiutarmi.
Grazie mille ugualmente

[_Claudio]

Originariamente inviato da legolas977

In modo un po piu semplice senza puntatori? qualcuno puo aiutarmi.
Grazie mille ugualmente

Senza l'uso di liste non saprei proprio, l'unica cosa che so è che usando vettori o matrici è impossibile per definizione (grandezza definita a priori) e non è certo una soluzione definire un vettore enorme e sperare in bene. Poi a questo mondo tutto è possibile e se non hai grandi obiettivi e il programma è ad uso tuo personale usa pure un vettore enorme tanto tu sai qual'è il limite di elementi.
Io però mi guarderei bene dal distribuirlo in giro visto che come si sa gli utenti la prima cosa che faranno è usare come non va usato ciò che gli passi quindi faresti figure.