Zmienne i stałe Komputery operują na danych umieszczonych w pamięci. Pamięć jest podzielona na wiele komórek o stałym rozmiarze (bajtów) do których można odwoływać się poprzez adres, numer komórki.
Zmienne są fragmentem pamięci komputera o określonym rozmiarze do którego możemy się łatwo odwoływać poprzez nazwę, inaczej identyfikator.
Identyfikatory Identyfikatory w języku D buduję się z liter, cyfr oraz znaku podkreślenia. Pierwszy znak identyfikatora nie może być cyfrą. W D można używać znaków narodowych dla identyfikatorów, jednak jeśli kod będzie edytowany przez ludzi z różnych krajów nie jest to najlepszy pomysł. (Znaki narodowe mogą się przydać natomiast przy nauce języka, u młodych uczniów).
Przykłady poprawnych identyfikatorów:
v x3 prędkość sc_d2 p55 V // UWAGA: patrz opis poniżej _syscall // j.w.
nie są poprawne następujące identyfikatory:
4ped // BŁĄD: zaczyna się od cyfry ilosc.znakow // BŁĄD: zawiera kropkę
Język D rozróżnia małe i duże litery (ang. case sensitive) w identyfikatorach, tak więc identyfikator v jest inny niż V. Należy również zaznaczyć, iż identyfikatorów zaczynających się od podkreślenia nie powinno się używać w programach, ponieważ są one używane przez biblioteki oraz kompilator do specjalnych celów, co może powodować konflikty.
Przy wybieraniu identyfikatora (nazwy) staraj się aby była ona samowyjaśniająca się, tzn. odpowiadała temu czemu służy i nie wprowadzała w błąd. Dobrze aby nie była zbyt długa (lepiej opisać jej znaczenie w komentarzu), ani zbyt krótka (jako trudny do odszyfrowania skrót). Zwykle dobrymi nazwami są pojedyncze litery jako nazwy zmiennych (o ile nie używa się ich w dużej ilość w jednym miejscu), w szczególności są pewne konwencje co do pojedynczych liter. Dobre są również pojedyncze słowa. Przykłady
a, c, d // parametry x, y, z // szukana niewiadoma i, j, k // indeks pętli tekst // tekst wyświetl // funkcja wyświetlająca xgg1 // NIEDOBRZE: co to jest? f // NIEDOBRZE: funkcja, która nie wiadomo co robi, // chyba że to jakaś ogólna funkcja zapisz // jeśli zapisz jest funkcją, która wykonuje coś innego // niż zapisywanie, NIE JEST TO DOBRA nazwa
Część nazw jest zarezerwowana jako słowa kluczowa i nie można ich używać jako identyfikatorów. Słów kluczowych jest kilkadziesiąt i poznamy wszystkie w toku całego podręcznika, jednak juz tutaj podamy ich część (bez wyjaśnienia) ponieważ może Ci przyjść pomysł użycia ich jako identyfikatorów, a nie jest to dozwolone (o czym zapewne poinformowałby kompilator):
in, out, body, double, do, this, version, super, new, function, default, debug, alias, auto
Deklarowanie zmiennych Zmienne w języku D deklaruje się używając następującej składni:
typ nazwa_zmiennej;
jeśli chcemy zaś zadeklarować naraz więcej zmiennych tego samego typu można to zrobić wypisując zmienne po przecinku:
typ zmienna1, zmienna2, zmienna3;
Zmienne w języku D mogą być deklarowane praktycznie w dowolnym miejscu programu, jednak muszą się one pojawić przed użyciem (wyjątkiem są zmienne globalne).
Aby wyjaśnić lepiej mechanizm działania zmiennych skupimy się na typie int (od ang. integer - liczba całkowita), jest to typ liczb całkowitych, a zmienna zadeklarowana z takim typem może zmieścić dowolną liczbę w zakresie od ok. -2 mld. do +2 mld. Typ ten zajmuje 4 bajty (32 bity) pamięci. Za chwilę poznamy dokładnie wszystkie wbudowane typy oraz ich zastosowania.
int x;
Definiuje to zmienną o nazwie x oraz typie int. Zmienna ta zostanie zainicjalizowana liczbą 0 (jest to wartość stałej int.init). Możemy również zainicjalizować tą liczbą inną wartością, np. 100:
int x = 100;
albo kazać kompilatorowi jej nie inicjalizować:
int x = void; // UWAGA: zmienna x może wtedy zawierać śmieci i mieć przypadkową wartość
w języku D wartość którą inicjalizujemy może być pewnym wyrażeniem (np. wyrażeniem matematycznym), na przykład:
int x = 24*60*60; // prawidłowo zainicjalizuje się jako 86400
Inicjalizację można przeprowadzić używając dowolnych wyrażeń o ile jest to wykonywane w bloku funkcyjnym, na przykład:
int s = 6; int x = 2*s;
Inicializacja zmiennych globalnych jest też możliwa w podobny sposób, ale zwykle musi być wykonywalna na etapie kompilacji.
Jak już widzisz, zmiennych typu int używa się jak zmiennych w matematyce. Można na nich wykonywać podstawowe operacje matematyczne, oraz podstawiać wyniki tych operacji do innych (albo tych samych!) zmiennych. Na przykład, nasz pierwszy program używający zmiennych może wyglądać tak:
import std.stdio; void main() { int a = 6; // utworzenie zmiennej o nazwie a i wartości początkowej 6 int b = 7; // analogicznie o nazwie b i wartości 7 int c; // utworzenie zmiennej c i inicjalizacja przy pomocy 0 c = a+b; // przypisanie zmiennej c wartości będącej sumą zmiennej a i b writefln(c); // wyświetlenie wyniku
Przykład powyżej można napisać na kilka różnych sposobów. Wypiszemy tutaj kilka wariantów, aby oswoić się ze składnią.
import std.stdio; void main() { int a = 6, b = 7; // utworzenie dwóch zmiennych: a, b int c = a+b; // utworzenie zmiennej c z wartością początkową równą a+b writefln(c);
albo po prostu:
import std.stdio; void main() { int a = 6, b = 7; writefln(a+b); // wynik dodawania nie zostanie zapisany do zmiennej // tylko od razu przekazany funkcji writefln
Stałe i niezmienniki Stałe Stałe to zmienne, których nie możemy w sposób jawny modyfikować. Mimo paradoksalnej nazwy, przyjeło się je nadal określać jako zmienne, ponieważ zachowują się one praktycznie tak jak zmienne z punktu widzenia języka. Używanie stałych ma dwojaki cel: ustrzega nas przed ewentualnym błędem, który byśmy popełnili zmieniając zawartość takiej zmiennej oraz pozwala lepiej i łatwiej zoptymalizować kod.
Stałe deklaruje się dopisując modyfikator (atrybut zmiennej) const: const int n = 10;
możemy teraz używać zmiennej n jak każdej innej zmiennej, jednak nie możemy jej zmienić: writefln(5*n); // wypisz 50 n = 20; // BŁĄD: kompilator się na to nie zgodzi!
Nawet próba zmiana zmiennej na tą samą wartość jest błędem: const int n = 10; n = 10; // BŁĄD n = n; // też BŁĄD
Ważne jest, aby stałą zainicjalizować w momencie deklaracji, ponieważ bardzo podobna konstrukcja jest nie poprawna: const int n; // stwórz stałą n = 10; // przypisz jej wartość 10
Kompilator zaprotestuje w obu linijkach. W pierwszej ponieważ nie zainicjalizowaliśmy stałej, a w drugiej ponieważ zmieniamy stałą (która mogła bybyć równa 0, gdyby inicjalizować ją podobnie jak zwykłe zmienne int).
Przykładem stałych mogą być np. pi, e (podstawa logarytmów naturalnych), wielkość zbioru danych na którym operuje program, czy jakieś parametry ustalone przez użytkownika, które w czasie wykonania programu się nie zmieniają.
Nazwę typu możemy pominąć, jeśli wyrażenie inicjalizujące po prawej stronie znaku przypisania jest znanego typu: const n = 10; // równoważne const int n = 10; n zostanie stworzona jako typu int, ponieważ 10 ma typ int. Jest to tak zwane automatyczne wnioskowanie (ang. inference) typu. Więcej o tej cennej własności opowiemy na końcu tego rozdziału.
Stałe mogą być też inicjalizowane dynamicznie, co ma szczególnie zastosowanie w funkcjach (i metodach):
auto f(int a, int b) { const s = a + b; // s = 3; // BŁĄD. return s * s; }
Tutaj użyliśmy const jako tymczasowe miejsce do przechowania jakieś wartości w funkcji, której nie chcemy zmieniać do końca wywołania tej funkcji. Ułatwia to też często czytanie i analizowaniu kodu, ponieważ nawet przy długiej funkcji, wiemy od razu, że taka zmienna nie będzie zmieniała swojej wartości (nigdzie w funkcji nie ma instrukcji która by nadpisywała wartość tej funkcji).
Niezmienniki Niezmienniki są to dane, które nie mogą zostać w żaden sposób zmienione. Różnica pomiędzy stałymi a niezmiennikami jest taka, że stałe mogą zostać zmienione z innej referencji nieoznaczonej słowem const, a niezmienniki nie.
Do oznaczania danych jako niezmienniki służy słowo kluczowe immutable.
Domyślnie niezmiennikami są na przykład ciągi znaków. Ten fakt może z początku sprawić problem, ponieważ kompilacja poniższego kodu skończy się błędem:
char[] x = "tekst";
Kompilator poinformuje nas wtedy o niemożności konwersji typu immutable(char[]) do char[]. W takim przypadku należy użyć własności tablic dup, która zwróci zwykłe dane (nie immutable):
char[] x = "tekst".dup;
Inną opcją rozwiązania tego problemu jest użycie typu string zamiast char[].
string x = "tekst";
Dzięki temu jeśli będziemy potrzebowali stałej, której na 100% nikt nie zmieni bo informuje o czymś elementarnym i poprawność tych danych ma wpływ na działanie całego programu, np. wbudowany w program klucz do szyfrowania/deszyfrowania danych (to tylko przykład - rzadko dobre rozwiązanie) będziemy mogli użyć niezmiennika i nie martwić się o te dane. immutable char[] klucz_128bit = "0123456789abcdef"; Dodatkowym udogodnieniem jest to, że definiując niezmiennik typu char[] nie musimy dodawać .dup na końcu ciągu.
Zasięg i czas życia Zmienne mogą się znajdować poza funkcjami, wtedy nazywam je zmiennymi globalnymi (poprawniej zmienne o zasięgu bieżącego modułu). Są dostępne ze wszystkich funkcji. Na przykład
import std.stdio;
void func() { // tworzymy własną funkcję o nazwie func a = 5; // zmieniającą zmienną o nazwie a ustawiając ją na 5
int a = 6; // utworzenie zmiennej globalnej o nazwie a i wartości 6
void main() { // tu program rozpoczyna działanie writefln(a); // wyświetli 6 a = 7; // zmieniamy wartość writefln(a); // wyświetli 7 func(); // wywołujemy naszą funkcję (która modyfikuje a) writefln(a); // wyświetli 5
Należy zauważyć, iż w funkcji func użyliśmy zmiennej a zanim w kodzie źródłowym pojawiła się informacja o tej zmiennej (ang. forward reference). W D jest to dozwolone. Tak samo, mogli byśmy napisać funkcje func za funkcją main (na samym dole; patrz następny przykład), i użyć identyfikatora func w funkcji main. Jest to znaczący postęp w stosunku do języka C w którym przed użyciem wszystkie identyfikatory muszą być znane.
Zmienne które definiuje się na "prywatne" potrzeby funkcji nazywamy zmiennymi lokalnymi i nie są dostępne z innych funkcji. A w przypadku gdy istnieje zmienna globalna o takiej samej nazwie zostanie ona "zasłonięta" (ang. shadowing).
import std.stdio;
int a = 5; // zmienna globalnej
void main() { int a = 6; // zmienna lokalna (zasłania globalne a) writefln(a); // wyświetli 6 (a nie 5) func(); writefln(a); // wyświetli 6 (ponieważ func modyfikuje zmienną globalną, a nie lokalną) a = 8; writefln(a); // wyświetli 8 func2(); // wyświetli 11 writefln(.a); // wyświetli 11 (kropka służy do dostępu do zmiennych // globalnych w przypadku ich zasłonięcia)
void func() { a = 11; // modyfikacja zmiennej globalnej (bo jedynie takie a "zna")
void func2() { writefln(a); // wyświetli zmienną globalna
Fragment kodu źródłowego w którym zmienna jest dostępna nazywamy zasięgiem (ang. scope) zmiennej. I tak np. zmienna a zdefiniowana w funkcji ma zasięg ograniczony do funkcji main. Natomiast zasięg zmiennej globalnej rozciąga się na cały plik (moduł).
Zasięg zwykle jest zdefiniowany przez strukturę blokową - zmienna jest dostępna w bloku w którym została zadeklarowana oraz w blokach wewnętrznych. W blokach wewnętrznych można zasłaniać zmienne spoza funkcji w której zostały zadeklarowane (np. zmienne globalne):
import std.stdio;
int d = 1;
void main() { int a = 6; // zmienna lokalna int c = 7; // j.w.
{ // tworzymy nowy blok int b = 11; // nowa zmienna lokalna, w bloku wewnętrznym //int c = 12; // j.w. + zasłonięcie - BŁĄÐ: nie wolno int d = 13; // j.w., ale zasłaniamy zmienną globalną (spoza funkcji main) writefln(a, " ", b, " ", d); // wyświetli "6 11 13" a = 100; //c = 101; d = 102; } // koniec bloku. Tu zmienna b staje się już niedostępna (kończy się jej czas życia)
writefln(a); // wyświetli 100 writefln(c); // wyświetli 7 // (a nie 101!) writefln(d); // wyświetli 1 (a nie 102!)