Wann muss ich Standardwerte für Variablen erstellen und welche nehme ich am Besten?

Ich hoffe die Frage ist nicht all zu doof:

Es kommt vor, dass ich Variablen erstelle, die zu Beginn keinen bestimmten Wert haben müssen, da sie später im Programmablauf einen zugewiesen bekommen.
Theoretisch kann ich ja eine solche Variable erstellen, ohne ihr einen Wert zuzuweisen:

int testZahl;

Unter umständen führt das im Visual Studio aber zu folgender Fehlermeldung:

Fehlermeldung:
"Verwendung der nicht zugewiesenen lokalen Variablen 'testZahl' "

Also muss ich der Variablen von Anfang an einen Wert zuweisen.
Bei Variablen vom Typ int/double nehme ich normalerweise 0.
Bei Variablen vom Typ string oder char bin ich mir immer unschlüssig.

Gibt es da Konventionen welche Werte man Variablen als Platzhalter zuweist?

Hallo NiggiBS,

Beim String kannst einfach

String.Empty

nehmen.

Char.Empty gibts jedoch nicht. Ein Char ist nie leer. Ein Char ist ein Wert, ein String ist eine Collection von Chars. Deswegen kannst du auch über einen String iterieren.

Verwendung der nicht zugewiesenen lokalen Variablen???

Gruss

Coffeebean

Herzlichsten Dank @Coffeebean!
Jetzt verstehe ich auch, was mit der Fehlermeldung genau gemeint ist.

👍

Alle Werttypen (so viele sind das nicht: Zahlen im wesentlichen) werden mit 0 initialisiert.
Boolean wird mit false intialisiert (auch eine 0, eigentlich)
Das gilt auch für Enum (jedes Enum ist auch nur ein mapping auf eine Zahl).

Alle Referenztypen (auch string, alle Klassen) werden mit NULL initialisiert.

Ganz einfach 😃

string.Empty kann man zwar zur Intialisierung nehmen, aber ich würde auch hier auf null zurückgreifen, weil in den meisten Fällen, wo der o.g. genannte Compilerfehler auftreten kann, die Variable auch ungewollt mit einem leeren String belegt werden könnte - und man dann nicht mehr unterscheiden kann.

Schau dir dazu auch mal das Schlüsselwort default an.

LaTino

string.Empty kann man zwar zur Intialisierung nehmen, aber ich würde auch hier auf null zurückgreifen, weil in den meisten Fällen, wo der o.g. genannte Compilerfehler auftreten kann, die Variable auch ungewollt mit einem leeren String belegt werden könnte - und man dann nicht mehr unterscheiden kann.

Richtig. Für den TE ist im Bezug auf das Problem dann auch noch String.IsNullOrEmpty und String.IsNullOrWhiteSpace interessant.

Nur der Vollständigkeit halber...

Gruss

Coffeebean

Boolean wird mit false intialisiert (auch eine 0, eigentlich)

Ich hatte einmal den Fall, dass je nach Eingabe des Users eine Variable vom Typ boolean den Wert "true" oder "false" zugewiesen bekam. Damit die Variable zu Beginn quasi "neutral" war schrieb ich folgendes:

bool? bedingung = null;

Hab ich so irgendwo im Netz gefunden und es funktioniert bestens.
Aber ist das überhaupt zulässig? Oder müsste ich hier wohl oder übel

bool bedingung = false;

schreiben?

Hallo NiggiBS,

zulässig ist es. Wenn man sich was bei gedacht hat ist das auch okay. Ich rede zumindest immer mal mit einem Entwickler drüber, wenn ich bei nem Review sehe, dass eine boolsche Variable nullable ist. Man flanscht im Prinzip einen dritten Wert an eine Variable, die dafür vorgesehen ist nur zwei Zustände zu haben. Daher ist es abhängig davon, was du machen willst.

Vielleicht wäre es besser da ein Enum zu nehmen.

Btw:

bool? asdf

ist nix andres als

Nullable<bool> asdf

Du kannst dann mit

asdf.HasValue

prüfen, ob die Variable einen Wert hat.

Gruss

Coffeebean

Der Threadtitel lautet ja:

Wann muss ich Standardwerte für Variablen erstellen und welche nehme ich am Besten?

Mit welchen du am besten initialisiert wurde ja gesagt. Aber täusch ich mich oder wurde auf das "wann" noch nicht eingegangen?

Es gibt da nämlich einen Unterschied zwischen den Klassenvariablen und den lokalen innerhalb einer Methode (die Fehlermeldung bezieht sich ja auch auf lokale Variablen.)

Wenn dir das schon klar war, dann sorry aber ich hab das selber gerade nochmal für mich getestet 😉

Hallo Buchstabensuppe,

Den Threadtitel habe ich geändert, damit es eindeutiger wird. Ich las aus dem Beitrag, dass das "Wann" auch eine Rolle spielt. Dazu: Scopes - Wobei die Scopes glaube ich weniger eine Frage waren 😃 Zur Vervollständigung aber sicher hilfreich

Gruss

Coffeebean

Gibt es da Konventionen welche Werte man Variablen als Platzhalter zuweist?

"Eigentlich" erscheint diese Fehlermeldung nur dann wenn du eine Variable ausliest, der du noch nichts ausdrücklich zugewiesen hast. In diesem Fall willst du doch tatsächlich wissen welcher Wert verwendet wird und solltest einen zuweisen.

JEDER Variable einen Anfangswert zuweisen ist nicht nötig, wenn du den Wert später zuweist und erst danach ausliest.
Wenn du den Fehler bekommst und nur einfach "irgendetwas" zuweist damit der Fehler nicht mehr erscheint, hast du wahrscheinlich unbemerkt doch einen Lesezugriff im Code.

Um auf deine Frage zurückzukommen, es gibt keine Konvention für einen Wert sondern du solltest den Wert zuweisen den du als erstes benötigst.

"Eigentlich" erscheint diese Fehlermeldung nur dann wenn du eine Variable ausliest, der du noch nichts ausdrücklich zugewiesen hast.

Um auf deine Frage zurückzukommen, es gibt keine Konvention für einen Wert sondern du solltest den Wert zuweisen den du als erstes benötigst.

Im Prinzip ist das korrekt, ja. Die Fehlermeldung kommt, wenn ich den Wert einer Variable ändere. Bsp.:

int zahl1 = 0;
zahl1 += 2;

Wenn ich hier der Variablen "zahl1" beim initialisieren keinen Wert zuweise kommt die Fehlermeldung. Da man zu einer Zahl nur dann 2 addieren kann, wenn man ihren Wert kennt ist hier also tatsächlich ein Lesezugriff versteckt.

Allerdings hatte ich das Problem auch schon bei einer Variablen vom Typ boolean, der ich beim initialisieren keinen Wert zugewiesen hatte, weil das erst später im Programmverlauf geschehen sollte 🤔

Im Prinzip hast du Recht, dass lokale Variablen initialisiert werden müssen, ist nicht immer logisch.

Besonders nicht, weil im Gegensatz zu denen die Membervariablen (in Klassen) implizit, also automatisch, initialisiert werden. Man kann sich direkte Initialisierung angewöhnen, also:

int myInt = GetIntWert();

...aber das geht auch nicht immer. Fehlende Initialisierung ist (bei mir) eine der häufigsten Compiler-Meckereien...

LaTino