Frage

Ich habe in C ein dynamisches Typisierungssystem erstellt, um ein Wörterbuch zu erstellen, das Werte unterschiedlicher Bitbreite enthalten kann.Die Struktur des dynamischen Objekts ist:

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

Ich muss zwei dieser Dynamics, die A2D-Messwerte enthalten, vergleichen und dann die Differenz mit einem Delta-Wert vergleichen, um festzustellen, ob eine Änderung aufgetreten ist.Eine Lösung, die ich finden konnte, besteht darin, sie in char-Arrays umzuwandeln und sie Byte für Byte zu vergleichen, aber das sieht nicht richtig aus.Ich habe auch die Idee, ein Array von Funktionszeigern basierend auf der Anzahl der Bytes (oder vielleicht dem Typ) zu erstellen, die die Dynamics beanspruchen, und einfach eine Vergleichsfunktion für jeden unterstützten Typ zu erstellen.Kann jemand einen anderen Ansatz vorschlagen?Es fühlt sich an, als würde mir etwas fehlen.

AKTUALISIEREN:

Vielen Dank, dass Sie mir von memcmp erzählt haben, aber ich habe immer noch das Problem, wie ich das Delta der beiden Werte erhalte?Soweit ich das beurteilen kann, gibt memcmp nur einen Indikator dafür zurück, welcher Wert größer ist, nicht den Unterschied zwischen ihnen.

UPDATE ZU UPDATE:

Es stellt sich heraus, dass memcmp für mich nutzlos ist, weil die Architektur, gegen die ich kompiliere, Little Endian ist.

Wenn ich selbst eine Bignum-Implementierung durchführen würde, dann scheint Ephemient der richtige Weg zu sein, aber ich habe beschlossen, dass ich die Werte einfach in den größtmöglichen Typ speichern werde (d. h.unsigned long long), mit denen ich mich befassen und mit denen ich einfach rechnen muss.Ich kann mir keinen Grund vorstellen, warum dies nicht funktionieren sollte, aber ich erkenne, dass ich mich sehr irren könnte, da C/direkte Speichermanipulation nicht meine Stärke ist.

War es hilfreich?

Lösung

Ist so etwas wie dies ausreichend?

#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);
}

Erstellen einer Reihe von Spezialfunktionen, wenn sie sehr ähnliche Operationen durchführen wie übertrieben scheint.

Nachtrag

Wenn Sie Unterschiede berechnen ...

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;
    }
}

Andere Tipps

Vielleicht bin ich etwas fehlt auch ... aber warum Sie nicht verwenden memcmp?

Wenn Sie vergleichen nur für die Gleichstellung - Verwendung memcmp (). Wenn Sie zählen, wie viele Bits (oder Bytes) unterscheiden - implementieren eine Funktion ähnlich memcmp (), die durch beide char-Arrays läuft, zu vergleichen, und die nicht-Anpassungsmuster zählen

.

Ich nehme an, dass die variable Bit-Größen auf einige Werte zurückzuführen sind größer als andere. Wenn Sie, dass die Anzahl der Bits garantieren kann immer bedeutet, dass Bit-Zahl gesetzt ist, dann können Sie zunächst die Größen vergleichen, und wenn die Größen gleich sind, dann die Byte ohne Vorzeichen Vergleiche tun. Zum Beispiel "01" benötigt nur 1 Bit zu speichern, so dass seine Größe 1 sein würde, und "100101" 6 Bit erfordert, zu speichern, so ist seine Größe 6. Wenn Größe (a)> Größe (b), dann (a)> (b).

gespeichert diese in großen oder kleinen Endian?

scroll top