Hi NiggiBS,

in C# programmiert man nicht wie in C, daher sind deine beiden Tipps hier nicht so sinnvoll.

Ich habe noch nie in C programmiert. Also sind meine Tipps doch sinnvoll.

Ist vielleicht etwas spät, aber vielleicht hilft es ja anderen Lesern:

Du kreierst für jede Eingabe eine neue string-Variable. Das scheint mir unnötig aufwändig.
Ich würde daher zwei Dinge ändern:

1. Variablen am Anfang der Main-Methode deklarieren (oder aber ausserhalb der Methode als globale Variablen.
2. Nur EINE Variable, der nach jeder Eingabe ein neuer Wert zugewiesen wird. Spart ne Menge Code und ist viel übersichtlicher 😉

👍

Der Link auf die Webseite von trivadis, der im trivadis-Logo oben rechts auf dieser Webseite zu finden ist fürt z.Z. auf eine nicht (mehr) existierende Sektion der trivadis-Webseite. Sollte man vielleicht mal ändern 😉

Danke @LaTino und @ErinderDesRades, aber ich kann ehrlich gesagt mit dem Programm nichts anfangen; weder mit, noch ohne GUI.

Danke an alle 🙂

Ich nehme nun bei der besagten Methode den Typ "double".
Damit habe ich keine Überläufe mehr.
Nur bei sehr grossen Zahlen heisst es dann "+unendlich" 😁

"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 🤔

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?

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

👍

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?

Ich habe aus Langeweile ein kleines Programm geschrieben (C#-Konsolenprogramm ohne GUI), das die Fakultät (1234 ... *n) einer eingegebenen Zahl errechnet.
Zuerst habe ich die resultierende Zahl in einer Variable vom Typ "int" gespeichert. Da die Fakultät einer Zahl sehr schnell sehr gross werden kann war das aber natürlich die falsche Wahl. Ich habe mich dann für "double" entschieden.
Mir ist nun aufgefallen, dass ich, als die Zahl noch als "int(32)" gespeichert wurde, keine fehlermeldung o.Ä. bekommen habe. Allerdings passierte folgendes: bei der Zahl 22 wurde mir eine ziemlich hohe negative Zahl ausgegeben; bei 23 ab 23 wurde die Zahl wieder positiv, war aber nicht korrekt. Hat wer ne Idee, wieso das so ist, bzw. wie die Zahl abgespeichert wird, wo doch die Variable zu klein ist?

Hier der Code:
(fakultät ist die besagte Variable)

        static void fakultät_rechner(int eingabe)
        {
            for(int i = 1; i <= eingabe; i++)
            {
                fakultät *= i;               
            }
            Console.Write("!{0} = {1}", eingabe, fakultät);
            Console.ReadLine();
        }

Ich glaube nicht, dass das möglich ist.

Ich verstehe nur Bahnhof ?(

Kurz gesagt, solltest du die Spiellogik in einer Spiellogik-Klasse "nachbauen", und die Oberfläche von dieser Spiellogikklasse steuern lassen. Das wäre die normale Vorgehensweise. So, wie du es machst, gibst du den Buttons eine zusätzliche Bedeutung neben ihrer Funktion als Button, und das sollte man - Gründe sind in dem Artikel oben genannt - vermeiden.

Ok, ich habe mich etwas eingelesen. Klingt erstmal recht logisch, aber im Zusammenhang mit meinem TicTacToe (die Grundidee habe ich übrigens von Hier) stellt sich mir da die Frage: wie könnte ich in diesem Beispiel denn die Logik und die Oberfläche trennen?
(Ich möchte die Aufgabe zwar nur als Einstieg für Leute nutzen, die interesse am Programmieren haben, aber das mit der Trennung interessiert mich nun doch).

Grundsätzlich sieht das so aus, als ob du hier versuchst Spiellogik mit Buttonstatus nachzubauen - für mich nicht nachvollziehbar - aber gut.

Was ist denn daran nicht nachvollziehbar? Verwirrt mich gerade etwas.

Das mit den Flags verstehe ich nicht wirklich (bin noch nicht so erfahren im Programmieren) und es scheint eher kompliziert zu sein. Ist aber nicht schlimm, da es sich ja nur um ein kosmetisches problem handelt 😉

Google, erster Treffer:

>

LaTino

1. Hab ich selber schon gefunden.
2. Hilft mir gar nicht!

Ich habe mir ein TicTacToe-Spiel programmiert. Das Spielfeld besteht aus 3 x 3 Buttons, die beim Start des Spiels grau sein sollen (gilt sowohl für ForeColor als auch für BackColor). Bei einem Klick auf einen der Buttons soll entweder ein rotes "X" auf grünem Hintergrund (bei Spieler 1) oder ein rotes "O" auf blauem Hintergrund (bei Spieler 2) erscheinen.
Das mit dem grünen/blauen Hintergrund funktioniert wie gewünscht.
Aber:
Zum einen wird die Schrift schon beim Start des Spiels schwarz angezeigt, obwohl ich die ForeColor im Entwurf auf "gray" festgelegt habe. Und auch bei Klick auf die Buttons bleibt die Schriftfarbe schwarz.
Nur wenn ich das Spiel resete (ich habe eine Methode geschrieben, die die Ausgangssituation wieder herstellt) wird die schrift wunschgemäss schwarz.

Woran liegt das?

Hier ein Teil meines Codes:
("nr" ist eine int-variable mit einem Wert von 1 - 9; buttons ist eine Liste mit den neun Buttons)

buttons[nr - 1].BackColor = Color.Blue;
buttons[nr - 1].ForeColor = Color.Red;

#Edit:
Folgendes ist mir aufgefallen: die Buttons sind beim Start des programms deaktiviert (Enabled = false;). Wenn ein Button angeklickt wird, wird er ebenfalls deaktiviert um Fehler zu vermeiden. Bleibt der Button aktiviert, so funktioniert das mit der schriftfarbe auch. Ist er aber deaktiviert ist die Schrift immer schwarz. Kann man das irgendwie ändern?