Wie kann man lokale Variablen von eingebauten Typen in C++ standardmäßig initialisieren?

Question

Wie initialisiere ich eine lokale Variable vom primitiven Typ in C++ standardmäßig? Wenn ich zum Beispiel eine typedef:

typedef unsigned char boolean;//that's Microsoft RPC runtime typedef

Ich würde gerne die folgende Zeile ändern:

boolean variable = 0; //initialize to some value to ensure reproduceable behavior
retrieveValue( &variable ); // do actual job

in etwas, das die Variable automatisch standardmäßig initialisieren würde - ich muss ihr keinen bestimmten Wert zuweisen, sondern brauche nur, dass sie jedes Mal, wenn das Programm läuft, auf denselben Wert initialisiert wird - dasselbe wie bei einer Konstruktorinitialisierungsliste, wo ich etwas haben kann:

struct Struct {
   int Value;
   Struct() : Value() {}
};

とのことで、その Struct::Value wird jedes Mal, wenn eine Instanz erzeugt wird, standardmäßig auf denselben Wert initialisiert, aber ich schreibe den tatsächlichen Wert nie in den Code.

Wie kann ich das gleiche Verhalten für lokale Variablen erreichen?

Answer 1

Sie können nachbilden. dieses Verhalten durch die folgenden Punkte:

boolean x = boolean();

oder, allgemeiner ausgedrückt,

T x = T();

Dies führt zu einer Standard-Initialisierung x wenn eine solche Standardinitialisierung existiert. Allerdings ist das Schreiben von T x wird bei lokalen Variablen nie funktionieren, egal was Sie tun.

Sie können auch placement-new verwenden, um einen "Konstruktor" aufzurufen, sogar für POD:

T x;
new (&x) T();

Beachten Sie, dass dieser Code zu undefiniertem Verhalten bei Nicht-POD-Typen führt (insbesondere bei Typen, die einen nicht-trivialen Destruktor haben). Damit dieser Code mit benutzerdefinierten Typen funktioniert, müssen wir zunächst den Destruktor des Objekts aufrufen:

T x;
x.~T();
new (&x) T();

Diese Syntax kann auch für PODs verwendet werden (garantiert durch §§5.2.4/12.4.15), so dass der obige Code unterschiedslos verwendet werden kann für cualquier Typ.

Answer 2

    int var = int();
    string str = string();
    ...

...oder ein beliebiger Typenname Ihrer Wahl.

Answer 3

Sie könnten einen Wrapper bereitstellen, der sich durch überladene Konvertierungsoperatoren wie der zugrunde liegende Typ verhält.

#include <cassert>

template <class T>
class Type
{
    T t;
public:
    Type(const T& t = T()): t(t) {}
    operator T&() { return t; }
    operator const T&() const { return t; }
};

int main()
{
    Type<unsigned char> some_value;
    assert(some_value == '\0');
}

Die Verwendung von Konvertierungsoperatoren sollte eigentlich kein Problem darstellen.

Answer 4

Einbettung in die Struktur (Boolean) wie in Ihrem Beispiel und Zugriff über ein öffentliches Mitglied (Boolean::value). Es mag nicht die eleganteste Lösung sein (etwas Ballast für einen geringen Nutzen), aber es ähnelt dem, was Sie bereits gezeigt haben.

Answer 5

Wenn ich die ursprüngliche Frage richtig verstehe, will der Fragesteller damit sagen, dass er möchte, dass Variablen eines bestimmten Typs immer denselben Anfangswert haben, dass es ihm aber egal ist, wie dieser Wert lautet, weil er ihn nie sehen wird. Liege ich da richtig?

Wenn ja, dann ist meine Frage an den Poster folgende: Wenn Sie die Variablen nicht initialisieren würden, hätten sie zufällige Anfangswerte... aber Sie sagten, dass Sie sich die Anfangswerte nie ansehen - warum ist es also wichtig, dass sie zufällig sind?

Ich denke, die Schlüsselfrage ist: Was wollen Sie hier erreichen?