Confrontare due valori che hanno un numero arbitrario di bit in C

Question

Ho creato un sistema di tipizzazione dinamica in C, al fine di creare un dizionario che può contenere valori di diverse larghezze bit. La struttura dell'oggetto dinamico è:

typedef struct
{
    void* Pointer;
    unsigned char Size;   
} Dynamic;

Ho bisogno di confrontare due di queste dinamiche che tengono letture A2D e quindi confrontare la differenza contro un valore delta per determinare se si è verificato un cambiamento. Una soluzione che ho potuto venire in mente è di gettare loro di char array e confrontarli byte per byte, ma questo non l'odore giusto. Ho anche l'idea di produrre un array di puntatori a funzione in base al numero di byte (o forse il tipo) Dynamics riprendono e solo fare una funzione di comparazione per ogni tipo supportato. Qualcuno può suggerire un approccio diverso? Ci si sente come mi manca qualcosa.

UPDATE:

Grazie per raccontarmi memcmp, ma ho ancora il problema di come faccio ad avere il delta dei due valori? Da quello che posso dire, memcmp solo restituisce un indicatore di quale valore è più grande, non è la differenza tra loro.

Aggiorna per aggiornare:

I suoi scopre che memcmp è inutile perché l'architettura che sto la compilazione contro è little endian.

Se dovessi fare un'implementazione bignum me poi ephemient si sente come la strada giusta da percorrere, ma ho deciso che sto solo andando a memcpy i valori nella più grande tipo di possibile (cioè unsigned long long) che avrò per affrontare e solo di lavoro per la matematica con quelli. Non riesco a pensare a nessun motivo per cui questo non avrebbe funzionato, ma riconosco che avrei potuto essere molto sbagliato, come C / manipolazione della memoria diretta non è il mio forte.

Answer 1

E 'qualcosa di simile è sufficiente?

#include <string.h>
int compare(Dynamic *a, Dynamic *b) {
    if (a->Size != b->Size) return a->Size - b->Size;
    return memcmp(a->Pointer, b->Pointer, a->Size);
}

La creazione di un gruppo di funzioni specializzate se ne eseguono operazioni molto simili sembra eccessivo.

Addendum

Se si desidera calcolare le differenze ...

int diff(Dynamic *a, Dynamic *b, Dynamic *d) {
    int i, borrow = 0;
    signed char *ap = a->Pointer, *bp = b->Pointer, *dp = d->Pointer;

    assert(a->Size == b->Size && b->Size == d->Size);

    for (i = 0; i < a->Size; ap++, bp++, dp++, i++) {
        // symmetric difference
        *dp = *ap ^ *bp;

        // arithmetic difference, assuming little-endian
        *dp = borrow += *bp - *ap;
        borrow >>= 8;
    }
}

Answer 2

Forse mi manca qualcosa di troppo ... ma perché non si usa memcmp?

Answer 3

Se si sta cercando di implementare la funzionalità bignum (e si potrebbe prendere in considerazione qualcun altro (prima google colpito 'bignum in C')), è quasi certamente desidera calcolare la differenza per sottrazione. La maggior parte delle CPU implementano confrontare facendo proprio questo e quindi utilizzando il segno del risultato o zeroness per <,> o ==.

Answer 4

Guarda, io sono un geek matematica, lo so, ma la questione di fondo suona come "Accidenti, che cosa è l'ordinamento naturale di queste cose?"

E 'i bit di dati grezzi sottostanti, come un bignum? Poi li getteranno a unsigned char e li confrontano in un ciclo. Un piccolo pensiero di l'ordine in cui si confronta lo renderà più efficiente. Un punto interessante è quando la lunghezza di A ≠ lunghezza B:? È A ≠ B quindi, per definizione, o è il valore numerico che si sta confrontando, in tal caso importanti byte di 0x00 non sono significativi

Answer 5

Se avete bisogno solo confrontare per l'uguaglianza - l'uso memcmp (). Se avete bisogno di contare il numero di bit (o byte) differiscono - implementare una funzione simile a memcmp () che attraversa entrambi gli array char, confrontare e contare i modelli non corrispondenti

.

Answer 6

presumo che le dimensioni bit variabili sono causa di alcuni valori che sono più grandi di altri. Se si può garantire che il numero di bit significa sempre che il numero bit è impostato, allora si può prima confrontare le dimensioni e se le dimensioni sono uguali, poi fare i confronti di byte senza segno. Ad esempio "01" necessita solo 1 bit per memorizzare, quindi le sue dimensioni sarebbe 1, e "100101" richiede 6 bit per memorizzare così la sua dimensione è 6. Se la dimensione (a)> dimensione (b), quindi (a)> (b).

Sono questi memorizzati in grande o little endian?