C++ Map Definition Grundlagen

Question

Ich habe ein Problem, das ich nicht lösen kann. Lassen Sie uns sagen, dass ich diese Karte Definition haben:

map<string, int16_t> Registers; 

aber manchmal, ich brauche eine nicht signierte int16_t zu speichern, anstatt eines signierten int16_t. Wie kann ich das tun?

Danke.

Answer 1

Sie können entweder einen größeren Fisch Typ verwenden, wie int32_t, oder verwenden Sie einen boost::variant.

Ein int32_t können alle Werte speichern, die ein oder int16_tuint16_t kann und es den Unterschied zwischen bewahrt, beispielsweise 32768 und -32768 (Zweier-Komplement vorausgesetzt). Wenn Sie ein Casting-Schema mit int16_t und uint16_t verwendet haben, würde der Unterschied zwischen diesen verloren gehen, da beide als 0x8000 gespeichert werden würden. Wenn Sie Werte von 0x8000 teilen möchten, benötigen Sie Out-of-Band-Informationen, die Sie nicht erwähnt haben.

int32_t wird jedoch nicht den Unterschied zwischen 32767 signiert und 32767 unsigned beibehalten. Wenn das wichtig ist, kann diese Informationen speichern.

Answer 2

Sie müssten einen Typ verwenden, der Instanzen eines der Typen speichern kann, die Sie speichern möchten.

Es gibt mehrere Verfahren, z.B. Varianten.

Eine Möglichkeit ist:

class Foo { 
public: 
    enum class Type : char { Int16, Uint16 }; 

    static Foo Int16 (int v)   { Foo ret{Type::Int16}; ret.int16_ = v; return ret;} 
    static Foo Uint16 (unsigned int v) { Foo ret{Type::Uint16}; ret.uint16_ = v; return ret;} 

    int16_t as_int16() const { assert_(Type::Int16); return int16_; } 
    uint16_t as_uint16() const { assert_(Type::Uint16); return uint16_; } 

    Type type() const { return type_; } 

private: 
    Foo (Type type) : type_(type) {} 
    void assert_(Type t) const { if (t != type_) throw "meh"; } 

    union { int16_t int16_; uint16_t uint16_; }; 
    Type type_; 
}; 

Beispiel:

int main() { 
    Foo f = Foo::Int16(4); 
    std::cout << f.as_int16() << '\n'; // okay 
    //std::cout << f.as_uint16() << '\n'; // exception 

    Foo g = Foo::Uint16(4); 
    std::cout << f.as_uint16() << '\n'; // okay 
    //std::cout << f.as_int16() << '\n'; // exception 

    // Switch on its type: 
    switch (g.type()) 
    { 
    Foo::Type::Int16: std::cout << g.as_int() << '\n'; break; 
    Foo::Type::Uint16: std::cout << g.as_uint() << '\n'; break; 
    } 
} 

Dies ist im Grunde ein union die eine Ausnahme auslösen, wenn Sie versuchen, int zu lesen, aber wirklich unsigned int gespeichert; Kinda union das wurde schwer zu benutzen-falsch gemacht.

boost::variant wäre eine andere Option.

Eine dritte Variante, wie bereits von R. Martinho Fernandes erwähnt, wäre die Verwendung eines größeren, signierten Int. Es hängt von Ihrem Anwendungsfall ab, ob Tippfehler relevant sein kann, wenn Sie T speichern und dann als U lesen möchten, wenn Sie Besucher mögen, wenn Sie den Typ überhaupt verfolgen möchten, und so weiter.

Meine gespeicherte Lösung ist auf meinem System 4 Byte groß (wegen der Ausrichtung), ebenso wie eine größere Ganzzahl mit Vorzeichen. Ich denke, weil Sie Ihre Werte in einem Container speichern, wird es nicht möglich sein, die Typ-Tracking während bleiben 2 Bytes zu verpassen, so dass ich denke, Ihr Minimum ist 4 Bytes in jedem Fall.

Answer 3

Entweder Sie führen eine Ebene der Indirektion ein (verlieren den gesamten Punkt des Speicherns von int16_t ziemlich), oder Sie benötigen 2 verschiedene Karten. Es sei denn, Sie zielen auf spezialisierte Hardware ab, oder müssen wirklich Platz sparen, sind Sie besser darin, einen direkten int zu speichern. Es wird insgesamt schneller und weniger mühsam sein.

Answer 4

Wenn die zwei Typen die gleiche Größe haben, können Sie das unsigned int as und int interpretieren. Achte nur darauf, dass du den Überblick darüber behältst, ob dein Wert signiert oder unsigniert ist. Das kann bedeuten, dass es besser ist, einen größeren Typ zu verwenden, damit du nicht mehr aufzeichnen musst.