Wie speichert man eine Art von "null" in C++ double oder int Variable?

Question

Ich habe eine Klasse, die wie diese

struct A { 
    double a1; 
    int b1; 
    double a2; 
    int b2; 
}; 

Ich habe abzulesen eine Datei Wert für a1, b1, a2 und b2 aussieht. Die meiste Zeit sind alle vier Zahlen in der Datei, aber manchmal gibt es nur zwei Zahlen.

Wenn zwei Zahlen sind, möchte ich die Werte in a1 speichern und b1 und ich möchte in a2 und b2 „nichts“ speichern. Wenn a2 und b2 Zeiger wären, könnte ich ihnen einfach zuweisen nullptr, aber sie sind keine Zeiger.

Kann ich etwas in double und int Variablen speichern, um anzuzeigen, dass "nichts" gespeichert ist?

Ich weiß Boost.Optional ist verfügbar, aber ich versuche, diese Bibliothek zu vermeiden.

Answer 1

Sie könnten NAN dem doppelten a2 zuweisen, was auch anzeigen würde, dass der int b2 ungültig ist.

This page für NAN-Nutzung.

Answer 2

Entweder haben Sie einen Wert, der nicht legal ist oder nicht. Wenn Sie einen Wert haben, der nicht legal ist (wie -1), verwenden Sie ihn als Sentinel. Wenn nicht, dann nein. Verwenden Sie Boost.Optional oder rollen Sie Ihre eigene Klasse "value plus boolean".

Answer 3

1. Sie können einen Wert auswählen, die nicht in den Textdateien (ein unzulässiger Wert) sein kann, wie 0, -1, std::numeric_limits<int>::max(). Wenn Sie die Daten verarbeiten, verwenden Sie den Wert nur, wenn er nicht dem ungültigen Wert (oder Sentinel) entspricht.

2. Fügen Sie ein bool angibt, wie viele Werte gibt es:

   struct A { 
       double a1; 
       int b1; 
       double a2; 
       int b2; 
       bool has_4_nums; 
   }; 
   

3. einen Zeiger verwenden (int* oder std::unique_ptr<int> per @ Peter Pei Guo) und nullptr zuweisen, wenn sie nicht existieren.

Answer 4

Sie können nicht. Ich kann an zwei alternative Möglichkeiten denken:

1. Verwendung int *; oder
2. Verwenden Sie einen Wert, der in Ihrem Kontext sicher ungültig ist. Zum Beispiel, wenn es nie negativ sein kann, dann verwenden Sie -1, um null anzuzeigen. Aber ich bevorzuge immer noch den ersten Weg, da seine Korrektheit nicht von der Anforderung oder dem Kontext abhängt.

Answer 5

Sie haben eine zwei Optionen boost::optional und damit die Abhängigkeit zu vermeiden Boost: Der std::experimental::optional Compiler

• verwenden, die von GCC verfügbar ist 4.9+ (und Clang in der letzten Versionen IIRC) mit -std=c++14.

• Verwenden Sie die "Referenzimplementierung" von Andrzej Krzemieński für std::experimental::optional von GitHub. Es ist nur Header, so dass Sie nur den Header zu einem Projekt kopieren können (natürlich auf die Lizenz bezahlen)

Answer 6

Sieht aus wie Sie Probleme haben, weiter die Straße hinunter gehen. Die Notwendigkeit zu wissen, wie viele Werte gültig sind, wird durch die Codebasis gestreut.

Ich schlage vor, eine Fabrik und Basisklasse zu haben. Im Wesentlichen werden Sie mindestens zwei Klassen haben:

struct two_values 
{ 
    double a1; 
    int b1; 
}; 

struct four_values : public two_values 
{ 
    double a2; 
    int b2; 
}; 

Wenn explizit eine Funktion, die vier Werte erfordert, verwenden Sie die four_values Struktur in der Erklärung. Ansonsten verwenden Sie die Struktur two_values in der Funktionsdeklaration.

Diese Beziehung besagt, dass eine four_values Instanz in jeder Funktion verwendet werden kann, die eine two_values Struktur benötigt.

Alternative
Eine Alternative ist std::vector für Ihre Artikel zu verwenden:

struct Container 
{ 
    std::vector<double> a_values; 
    std::vector<int> b_values; 
}; 

Ein Vorteil dieser Konstruktion ist, dass die Vektoren kann Ihnen sagen, wie viele Artikel gibt es und das Konzept ist erweiterbar, in falls du 6 Gegenstände brauchst.

Answer 7

Alternativ können Sie zusätzliche Mitglied hinzufügen zu wissen, ob normale Mitglieder betroffen sind, so etwas wie:

struct A { 
    double a1; 
    int b1; 
    double a2; 
    int b2; 
    bool is_assigned[4]; 
}; 

oder

struct A { 
    double a1; 
    int b1; 
    double a2; 
    int b2; 
    double* p_a1; // point to a1 when initialized, else nullptr 
    int* p_b1; // point to b1 when initialized, else nullptr 
    double* p_a2; // point to a2 when initialized, else nullptr 
    int* p_b1; // point to b2 when initialized, else nullptr 
}; 

Answer 8

struct A { 
    double a1; 
    int b1; 
    double a2; 
    int b2; 

}; 

hierfür können Sie einfach jede Art der Nutzung Variable, um anzugeben, ob diesen Variablen zwei oder vier Werte zugewiesen sind.

nehmen wie einen Variablennamen zugeordnet = -1

Also, wenn Ihr Eingangswert positiv sind dann, wenn zwei Werte in Datei sind dann nur

a2 = b2 = assigend

Also, wenn Sie machen checken Sie dann einfach, ob der Wert von a2 und b2 -1 oder etwas anderes ist,