Spis treści Poprzednia strona: Stałe Następna strona: Typy

Zmienne są bardzo podobne do stałych. Właściwie to są jeszcze prostsze. Żeby ze stałej zrobić zmienną trzeba pominąć słówko const. Właściwie stała jest zmienną, a słówko const zabrania tylko zmieniania jej wartości. Definicja zmiennej wygląda więc tak:

int a = 37;
int b;
string imię;
string nazwisko;

Wartość zmiennej można nadać w momencie jej tworzenia (tak jak dla stałych, tak jak w linii 1 powyżej), albo później przy pomocy tzw. instrukcji przypisania [assignment] składającej się z nazwy zmiennej, operatora przypisania (jest nim pojedynczy znak równości), nowej wartości dla zmiennej i średnika (który kończy instrukcję):

b = 123456789;
imię = "Gina";
nazwisko = "Lollobrigida";

Wartość zmiennej można zmieniać w dowolnym miejscu programu (po definicji zmiennej jeśli to zmienna lokalna, czyli zdefiniowana w ciele metody, tzn. między nawiasami { i }).

Czy wartość, którą przypisujemy zmiennej (tzn. liczba albo tekst) jest stałą? W pewnym sensie. Nie ma jednak swojej nazwy. Ma tylko wartość. Jest to tzw. literał. Kod źródłowy programu w języku C# składa się ze słów kluczowych (znamy już using, namespace i const), identyfikatorów (to na przykład nazwy przestrzeni nazw, klas, zmiennych, stałych, metod), operatorów (na przykład operator dodawania +, operator = przypisania wartości, operator @ wyłączenia trybu interpretowania symboli specjalnych w tekstach), literałów (wartości dla stałych i zmiennych), odstępów (spacje, tabulatory, znaki nowej linii) i komentarzy (liniowych, blokowych lub XML-owych). Elementy takie jak średniki, przecinki, kropki i nawiasy to znaki punktacji [punctuation], oddzielające i grupujące pozostałe elementy języka wymienione wcześniej, czyli tzw. tokeny.

Nazwy zmiennych zwykle piszemy małymi literami, a jeśli składają się z wielu słów, to tylko każde słowo z wyjątkiem pierwszego zaczynamy od wielkiej litery, albo oddzielamy słowa podkreśleniem.

int i, j, k,m,n=3,p,q;
m = 45;
int zmiennaBezWartości;
int zmienna_z_wartością = 24;
Console.WriteLine(m);
Console.WriteLine(zmienna_z_wartością);
Console.WriteLine(zmiennaBezWartości);

Można definiować wiele zmiennych (z wartościami początkowymi – np.: zmienna n – lub bez) tego samego typu (np.: int) w jednej linii, oddzielając je o siebie przecinkami (patrz linia 1 powyżej). Linie 5 i 6 są poprawne, ale linia 7 nie. Po definicji zmiennej użycie jej nazwy zwykle (bo nie na przykład po lewej stronie operatora przypisania) oznacza pobranie wartości zmiennej, więc wartość ta musi być już wcześniej przypisana. Linia 7 spowoduje błąd. Czy będzie to błąd kompilacji, czy wykonania. W języku C# jest to błąd kompilacji. Należy o tym pamiętać, bo są języki gdzie użycie zmiennej zmiennaBezWartości będzie poprawne (np.: w języku C będzie miała nie wiadomo jaką wartość – to nie to samo, co losową – a w języku C++ będzie miała domyślnie wartość zero). Po prostu nie wolno definiować zmiennej nie przypisując jej żadnej wartości, a potem odczytać z niej wartość. Czegoś takiego kompilator nie przepuści. Przepuści natomiast definicję zmiennej, której nigdzie nie używamy (zmienne i, j, k, n, p, q w przykładzie). Nie będzie to błędem, ale dostaniemy ładne (bo podkreślone na zielono) ostrzeżenie, że jest nieużywana zmienna albo że przypisano jej wartość i ta wartość nigdy nie została użyta (tzn. odczytana). Należy pozbyć się złych nawyków z innych przestarzałych języków programowania, w których wszystkie zmienne należało definiować na początku bloku instrukcji. To jest przeszłość. Aby mieć czysty kod (tzn. nie tylko bez błędów, ale i bez ostrzeżeń) dobrą praktyką jest definiowanie zmiennych zawsze z przypisaniem im pierwszej (początkowej) wartości i dopiero tam, gdzie po raz pierwszy dostępna jest dla nich ta wartość. Ponadto należy definiować zmienne tak, aby miały jak najmniejszy zasięg [scope].

Definicje zmiennych występują w tzw. metodach i są to tzw. zmienne lokalne tych metod. W języku C# nie ma pojęcia zmiennych globalnych. Zmienne zdefiniowane poza metodą, czyli w klasie, nazywamy polami [fields] tej klasy. Aby były one dostępne w statycznej metodzie Main, ich definicja też musiałaby być statyczna, czyli poprzedzona słowem kluczowym static. Stałe są domyślnie statyczne. Wrócimy do tego później.

Przykładowy program

class Program
{
    const int PozycjaX = 35;
    const int PozycjaY = 6;

    static void Main(string[] args)
    {
        int x = PozycjaX;
        int y = PozycjaY;
        Console.SetCursorPosition(x, y    ); Console.Write("┌───┬───┬───┐");
        Console.SetCursorPosition(x, y + 1); Console.Write("│   │   │   │");
        Console.SetCursorPosition(x, y + 2); Console.Write("│   │   │   │");
        Console.SetCursorPosition(x, y + 3); Console.Write("│   │   │   │");
        Console.SetCursorPosition(x, y + 4); Console.Write("├───┼───┼───┤");
        Console.SetCursorPosition(x, y + 5); Console.Write("│   │   │   │");
        Console.SetCursorPosition(x, y + 6); Console.Write("│   │   │   │");
        Console.SetCursorPosition(x, y + 7); Console.Write("│   │   │   │");
        Console.SetCursorPosition(x, y + 8); Console.Write("├───┼───┼───┤");
        Console.SetCursorPosition(x, y + 9); Console.Write("│   │   │   │");
        Console.SetCursorPosition(x, y +10); Console.Write("│   │   │   │");
        Console.SetCursorPosition(x, y +11); Console.Write("│   │   │   │");
        Console.SetCursorPosition(x, y +12); Console.Write("└───┴───┴───┘");
        Console.ReadKey(true);
    }
}

Zmienne x i y w liniach 11 i 12 to zmienne lokalne metody Main. Nie bardzo ma to sens, bo po co definiować zmienne x i y tylko po to żeby miały stałą wartość. Sens jest gdzie indziej: skrócenie zapisu i to, że te zmienne przydadzą nam się dalej w tym kursie.

Spis treści Poprzednia strona: Stałe Następna strona: Typy