Deklaracje i definicje.

Na początek, jak obiecałem, opiszę konwencje notacyjne stosowane przeze mnie w dalszych objaśnieniach dotyczących zapisu kodu programu. Myślę jednak, że nie warto pomijać tego podczas czytania tego opisu, gdyż w trakcie objaśniania sposobu zapisu kodu "przemycać" będę także informacje ważne dla języka.

Fragmenty kodu, które stanowią część języka, na przykład słowa kluczowe i symbole zostały napisane

taką czcionką

Kiedy w kodzie trzeba użyć jakiejś nazwy nie stanowiącej części języka, tylko będącej identyfikatorem np. funkcji lub innego obiektu, wtedy nazwa taka napisana jest

<w_ten_sposób>

Jeśli w kodzie programu jest fragment, który można pominąć (czyli fragment tzw. opcjonalny), to w moim zapisie będzie on ujęty w nawiasy kwadratowe napisane czcionką niepogrubioną

[ i ]

[ i ]

<typ> <nazwa_zmiennej> [ [ <rozmiar_tablicy> ] ] ;

int liczba;

int liczby[10];

Jeśli w zapisie użyty zostanie samotnie stojący w linijce wielokropek

...

<typ> <deklarator_zmiennej> [ , <deklarator_zmiennej> ... ] ;

Każda deklaracja (pojedyncza lub wielokrotna) koniecznie MUSI być zakończona średnikiem (znakiem ";"), podobnie jak każda instrukcja programu. Kompilator po nim "poznaje" koniec takiej deklaracji lub instrukcji czytając i tłumacząc tekst programu. Nie napotkawszy na niego, następną w programie deklarację lub instrukcję "rozpozna" jako kontynuację poprzedniej, co z pewnością spowoduje błąd kompilacji. Na innej podstronie przeczytać można o stosowanych umownych stylach pisania kodu programu.

Teraz słów parę o identyfikatorach. Nazwy zmiennych, funkcji, struktur i klas, typów, wyliczeń i stałych wyliczanych są identyfikatorami i podlegają pewnym zasadom, aby kompilator mógł je odróżnić np. od stałych. Aby tak było identyfikator musi zaczynać się od litery lub znaku podkreślenia ("_"). Pozostałe znaki muszą być literami, cyframi lub znakami podkreślenia. Kompilator odróżnia od siebie wielkości liter, więc np. AB, to nie to samo co Ab. Maksymalna długość identyfikatorów jest dowolna, ale różne kompilatory odróżniają je od siebie po pierwszych znakach - w najprostszych z nich może to być 7, w innych 31, a jeszcze w innych 255 pierwszych znaków. Przyjęło się używać w identyfikatorach małych liter lub też pisać je z wielkiej litery i pozostałe litery małe. Samych dużych liter zwyczajowo używa się do definiowania stałych kompilatora. Oto przykłady:

#define STALA_KOMPILATORA 10
int Zmienna_Calkowita;
char tablica20znakow[20];

char 20liter[20];

Omówiłem zmienne proste i tablicowe. Teraz pora na struktury. Deklaruje się je pisząc słowo kluczowe struct na początku. Struktura to zestaw tzw. pól czyli zmiennych składowych o dowolnych typach. Po zadeklarowaniu taki obiekt zajmuje w pamięci tyle miejsca, ile razem w sumie zajmują jego składowe. Zapis deklaracji:

struct [ <nazwa_struktury> ]
{
    <deklaracja_składowej> ;
    ...
} [ <deklarator_zmiennej> [ , <deklarator_zmiennej> ... ] ] ;

struct
{
    int wiek;
    char *imie, *nazwisko;
} szef, pracownik, *wsk;

struct student
{
    int id;
    char oceny[20];
};

struct student dziennik[30];

Jeszcze raz o deklaracjach i definicjach. Deklaracja, to określenie typu lub innych atrybutów jeszcze nie zdefiniowanego obiektu. Definicja zaś, to już określenie obiektu tego typu lub o takich atrybutach, czyli przydzielenie nań pamięci. Jeśli na int potrzeba 2 bajtów, a na char 1 bajtu, to przykładowy obiekt dziennik zajmuje (20*1+2)*30=660 bajtów.

Ogólna zasada jest taka, że jeśli podamy tylko nazwę struktury (patrz też typy wyliczeniowe, na poprzedniej stronie: enum kolory) i nie podamy żadnych zmiennych przy takiej deklaracji, to nic nie jest definiowane - na nic nie jest przydzielana pamięć. Podanie jakichś zmiennych lub innych deklaratorów definiuje je (przydziela im pamięć). W przypadku wyliczenia można zdefiniować zmienną typu wyliczeniowego, np.:

enum
{
    trojkat = 1,
    kolo,
    kwadrat
} figura;

Nie można deklarować anonimowych typów wyliczeniowych, struktur i klas bez definiowania obiektów. Wyjątkiem są tylko unie; o uniach zaraz napiszę. Po prostu w kodzie musi być przynajmniej kompletna deklaracja nawet jeśli nie towarzyszy jej definicja. Deklaracja bez nazwy może być tylko definicją, inaczej nie stanowi poprawnej deklaracji. Poniższy zapis:

struct
{
    int wiek;
    char *imie, *nazwisko;
};

Unie są dość rzadko wykorzystywaną odmianą struktur. Różnią się od nich tym, że w strukturach kolejne składowe zajmują kolejne miejsca w pamięci, a w uniach wszystkie składowe zajmują w niej to samo miejsce. Zatem wielkość zajętości pamięci całego obiektu unii wynosi tyle, ile największa wielkość zajętości pamięci spośród wszystkich składowych. Przykładowo:

union dane
{
    char znaki[3];
    int liczba;
} unia;

Przypisując dane do pól i odczytując je z nich w przypadku unii, trzeba być bardzo ostrożnym, bo wpisując dane do jednej składowej "zamazujemy" je w pozostałych składowych.

O anonimowych uniach opowiem przy okazji omiawiania odwoływania się do danych zawartych w zmiennych lub wskazywanych przez wskaźniki w wyrażeniach.

Teraz wrócę na chwilę do deklaracji. Pojedyncza deklaracja może być dość skomplikowana, kiedy chcemy użyć skomplikowanego typu danych. W deklaratorze zmiennej (jak wspomniałem wcześniej) można użyć znaku gwiazdki ("*"), aby określić, że zmienna jest wskaźnikiem. Można też użyć nawiasów kwadratowych ("[", "]"), aby określić, że zmienna jest tablicą. Co napisać, jeśli chcemy użyć tablicy wskaźników? A co, jeśli chcemy użyć wskaźnika na tablicę? Przy okazji wyrażeń podam tzw. priorytety operatorów i wtedy okaże się, że wśród operatorów [] i * większy priorytet mają nawiasy kwadratowe. Jeśli chcemy to zmienić, używamy nawiasów okrągłych ("(" i ")").
Oto przykłady:
int *tablica[10]; - tablica dziesięciu wskaźników na dane typu int;
int (*wsk)[10]; - wskaźnik na dziesięcioelementową tablicę o elementach typu int.
A teraz uwaga:
int *(*ptr)[10]; - wskaźnik na tablicę dziesięciu wskaźników na dane typu int.

Co jednak zrobić, gdy chcemy takiego wymyślnego typu danych użyć w miejscu, gdzie deklaracja nie jest dopuszczalna? A czy można zaoszczędzić sobie pisania definiując wiele zmiennych wciąż tego samego typu? Z pomocą przychodzi deklaracja typu oznaczana słowem kluczowym typedef. Można jej użyć, gdy chcemy jakiemuś typowi danych nadać nazwę; wówczas nazwą taką możemy posłużyć się w dalszych deklaracjach czy definicjach. Na przykład:

typedef int *wsknaint;
typedef char napis[100];

wsknaint iptr;
napis komunikat;

wsknaint iptr1;
int *iptr2;

Powinienem coś też napisać o wskaźnikach nie określających typu wskazywanej danej. Czasem potrzeba wskazać na jakiś obszar pamięci nie wiedząc lub nie chcąc podawać typu danych wskazywanych, gdy jest on nieistotny. Wówczas można zdefiniować np. taki wskaźnik:

void *wskaznik;

Oczywiście nie ma sensu i dla kompilatora jest błędną taka deklaracja:

void zmienna;

Definiując (nie tylko deklarując) jakąś zmienną czy inny obiekt, możemy go zainicjować. Jeśli tego nie zrobimy, różnie bywa: czasem zmienna ma tzw. wartość nieokreśloną czyli śmieci - przypadkową zawartość, która była w pamięci przed przydzieleniem jej obiektowi, a czasem kompilator wypełnia obszar pamięci na ten obiekt zerami. Inicjalizacja (nie mów "inicjacja" - to nieporawnie) powoduje, że zaraz po definicji obiekt ma określoną w programie wartość. W programie, zaraz po deklaracji definiującej dany obiekt piszemy znak "=", a po nim tzw. inicjalizer; w przypadku zmiennej prostej może to być wartość, jaką ma być zainicjowana ta zmienna, a w przypadku tablic i struktur w nawiasach klamrowych ("{" i "}") podajemy oddzielone przecinkami wartości inicjujące elementy tablicy albo pola składowe struktur. Unii nie wolno inicjować. Jeśli chodzi o obiekty danej klasy, do inicjalizacji można też użyć konstruktora tej klasy.

<definicja> = <inicjalizer> ;

<definicja> = { <inicjalizer> [ , <inicjalizer> ... ] };

<definicja> = <konstruktor> ( [ <argumenty> ] );

Ogólnie mówiąc, jako wartość inicjującą można podać dowolne wyrażenie którego wartość można obliczyć już na etapie kompilacji - tzw. wyrażenie stałe. Dla wskaźnika może to być stała NULL albo adres innej zmiennej typu zgodnego ze wskazywanym przez wskaźnik. Wartości inicjujących agregat (czyli tablicę lub strukturę) może być mniej niż potrzeba, wtedy pozostałe zostaną zainicjowane zerami. Podam tutaj parę przykładów:

int liczba = 1 + 2;
char znaki[10] = {'a', 'b', 'c', 5 + 0x30};
char linia[80] = "Press any key...";
int *wsklicz = &liczba;
void *wsk = NULL;

Na koniec rzecz o tzw. atrybutach używanych w deklaracjach. Jednym z nich jest atrybut stałości const. Umieszczenie go w deklaracji określa, że definiowany obiekt nie będzie się zmieniał (np. zmienna nie będzie zmieniała swej zawartości). W przypadku wskaźników można określić albo, że wskaźnik nie będzie zmieniał swego wskazania, albo, że wskazywana przezeń dana nie będzie się zmieniać, albo to i to jednocześnie.
Przykłady:

const int stala = 10;
char zmienna;
char * const zwsk = &zmienna;
const char *tekst = "ABCD";
const char * const twsk = "XYZ";

stala=10;

Jasne jest, że nie ma sensu deklaracja zmiennej const bez inicjalizacji:

const int ilosc;

Deklaracje klas wyglądają bardzo podobnie jak deklaracje struktur. Mają nawet podobną reprezentację swoich danych składowych w pamięci, jak struktury. Są jednak pewne szczegóły, które zostaną omówione osobno.