Gibt es eine einfache Möglichkeit, mit der Klasse QVariant mit hexadezimal-strings?

Diesem code-Beispiel funktioniert wie ich es erwarten würde:

v = QVariant("123456");
qDebug() << v; //QVariant(QString, "123456")
v.convert(QVariant::Int);
qDebug() << v; //QVariant(int, 123456)
v.convert(QVariant::String);
qDebug() << v; //QVariant(QString, "123456")

Wo, wie dies nicht:

v = QVariant("0xBEEF");
qDebug() << v; //QVariant(QString, "0xBEEF")
v.convert(QVariant::Int);
qDebug() << v; //QVariant(int, 0)
v.convert(QVariant::String);
qDebug() << v; //QVariant(QString, "")

Gibt es eine einfache Möglichkeit, um die Klasse QVariant Arbeit mit hexadezimal-strings, so das zweite Beispiel würde funktionieren, so etwas wie dieses:

v = QVariant("0xBEEF");
qDebug() << v; //QVariant(QString, "0xBEEF")
v.convert(QVariant::Int);
qDebug() << v; //QVariant(int, 48879)
v.convert(QVariant::String);
qDebug() << v; //QVariant(QString, "48879")
InformationsquelleAutor Samuel Harmer | 2012-02-09
  1. 2

    Beim konvertieren einer qvariant zu einem numerischen Wert, den Sie angeben müssen, die Basis. Auch stellen Sie sicher, dass der Wert passt in int/long/longlong oder dann ist die Konvertierung schlägt fehl, für, dass Grund statt.

    QVariant v = QVariant("0xDEADBEAF");
bool test;
qDebug() << v.toString().toLongLong(&test,16);
qDebug() << test;

    erzeugt die korrekte Ausgabe

    3735928495 
true

    während 

    QVariant v = QVariant("0xDEADBEAF");
bool test;
qDebug() << v.toString().toInt(&test,16);
qDebug() << test;

    Ausgabe 

    0
false
    • Guter Punkt, und ich habe aktualisiert mein Frage reflektieren einen sinnvolleren Beispiel. Aber ich denke, dass Ihre Argumentation für das scheitern ist falsch. "0xBEEF" wandelt auf 0 statt 48879 was nicht überlaufen. Having said, die, ich würde glücklich sein, zu akzeptieren, Ihre Antwort, wenn Sie entfernen Sie die fehlerhaften bits und aktualisieren, um die übereinstimmung der geänderten Frage, wie es eine gute Lösung, danke. 🙂
    • Ja und Nein. Im Fall von QVariant::convert() fehlschlägt, weil es nicht weiß, welche Basis für die Konvertierung aus. Das passiert in der "0xBEEF" Fall aswell. Aber wenn Sie geben die Basis, es schlägt fehl, weil es nicht in der "0xDEADBEEF", um eine juristische int wegen überlauf. So QVariant("OxBEEF").toString.toInt(&test,16) erfolgreich ist, während die QVariant("OxDEADBEEF").toString.toInt(&test,16) nicht. Ich werde aktualisieren, meine Antwort.
    • Richtig, aber das QVariant-Konvertierungs-routine für eine Zahl, die als string gespeichert ist ein Versuch, anhand der Zeichen in der Zeichenfolge enthalten (d.h. "1" == 1, aber nicht in "m1stake"). Ich war der Hoffnung, dass es die gleiche Art von Versuch für einen hex-string gespeichert, in C++ - notation (d.h. "a" == 10 im "0xa" aber nicht in "di0xan"). QVariant anscheinend nicht die Mühe machen einen solchen Versuch (basierend auf dem Ergebnis meiner "0xBEEF" Beispiel).
    • Ich denke, es wird einfach nur angenommen sein eine base-10-Zahl und schlägt fehl, wenn seine nicht. Die Standardeinstellung für QString::toInt() ist die Basis 10, und ich vermute, das ist die Funktion, die QVariant::convert () - Aufrufe, um die Konvertierung zu tun.
    • Nicht so. Und ich werde Ihnen sagen, warum! Und danke auch wieder für die Beantwortung meiner Frage, und, die mich finden, die Fehler in QVariant 🙂
    InformationsquelleAutor Kimmeh
  2. 1

    Nachdem die Punkte aus, indem diese Antwort zu numerischen überlauf, ich habe einige der Untersuchung, und es scheint die QVariant die Konvertierungs-Routinen fehlerhaft sind. Den einfachsten Weg, um zu konvertieren eine QVariant sicher ist durch die Verwendung von QString s Umbauten statt. Auch dies scheint, wie die einfachste Art und Weise zu verwenden, QVariant mit hexadezimal-strings. Ich habe zusammengefasst meine Erkenntnisse unten. Die Kommentare wäre die Ausgabe von anrufen zu qDebug() << v; an diesem Punkt im code.

    Szenario 1: gespeicherte Rufnummer als hexadezimal-string

    v = QVariant("0xBEEF"); //'QVariant(QString, "0xBEEF") '
v = v.toString().toInt(0, 16); //'QVariant(int, 48879) '

v = QVariant("0xDEADBEEF"); //'QVariant(QString, "0xDEADBEEF") '
v = v.toString().toInt(0, 16); //'QVariant(int, 0) '

    Der einfachste und sicherste Weg, um die Konvertierung von string-die-steht-ein-dezimal-Zahl in eine Zahl geben, ist die Verwendung QString s toInt(bool * ok = 0, int base = 10) Methode.

    Szenario 2: Anzahl, werden als dezimal-string

    v = QVariant("123456"); //'QVariant(QString, "123456") '
v.convert(QVariant::Int); //'QVariant(int, 123456) '

    QVariant ist convert(Type t) Methode funktioniert wie man es erwarten würde in diesem Szenario.

    v = QVariant("2147483649"); //'QVariant(QString, "2147483649") '
v.convert(QVariant::Int); //'QVariant(int, -2147483647) '

v = QVariant("9223372036854775807"); //'QVariant(QString, "9223372036854775807") '
v.convert(QVariant::Int); //'QVariant(int, -1) '

    Jedoch mit der gleichen Methode, wenn der string eine Zahl enthält, die zu groß für den Datentyp bewirkt, dass ein silent-überlauf, statt etwas zu tun, die mehr nützlich, wie die Rückgabe von false und Einstellung der QVariant zu 0.

    v = QVariant("2147483649"); //'QVariant(QString, "2147483649") '
v = v.toString().toInt(); //'QVariant(int, 0) '

v = QVariant("9223372036854775807"); //'QVariant(QString, "9223372036854775807") '
v = v.toString().toInt(); //'QVariant(int, 0) '

    Durch die Verwendung der gleichen Methode wie in Szenario 1 kann man verhindern, dass dies geschieht, und auch das optionale *bool parameter der toInt() werden, alarmiert der Ausfälle.

    InformationsquelleAutor Samuel Harmer
Schreibe einen Kommentar