STRUKTURY w C - wyjaśnijmy sobie dokładnie podstawy

Witam,

Jest sobie środek nocy, 1:48 a mnie naszło na napisanie mini poradnika na temat struktur w języku C, jak zwykle w aspekcie programowania mikrokontrolerów. Co było natchnieniem do tego poradnika? Szczególnie jeden z ostatnich maili jaki otrzymałem w tej sprawie, a tak na prawdę wyrażał on w skrócie wiele innych podobnych pytań docierających do mnie drogą mailową, przez Skype czy forum. Te wszystkie pytania wiążą się właśnie z niezrozumieniem podstaw definiowania i deklarowania struktur, dlatego mam nadzieję, że po tym co napiszę, opiszę - sporo się wyjaśni.

Zacytuję wręcz to pytanie z maila:

"W Twojej książce "Mikrokontrolery AVR Język C Podstawy programowania" deklarujesz struktury tak:

struct {
        uint8_t zmienna1;
        uint8_t zmienna2;
        ....;
} silnik;

Natomiast wszędzie w internecie spotkałem się z nieco innym zapisem:

struct silnik {
        uint8_t zmienna1;
        uint8_t zmienna2;
        ....;
} ;

Czym to sie różni?"

W odpowiedzi na tego maila napisałem co następuje ;)

To zależy jak i do czego potrzebujesz użyć struktur, bo obie zaprezentowane przez ciebie formy są poprawne ale wbrew pozorom nie oznaczają tego samego. Wyobraźmy sobie taki przykładowy zapis:

struct IMIONA {
        uint8_t ala;
        uint8_t ola;
} ;

jest to typowa (uwaga!) DEKLARACJA struktury ale jeszcze nie definicja, i teraz jeśli chcemy przygotować zmienną na podstawie takiej deklaracji to należy napisać tak:

struct IMIONA imiona;

Zobacz musisz użyć słówka "struct" przed nazwą struktury, dzięki temu popełniliśmy już teraz DEFINICJĘ, zmiennej "imiona", co spowodowało zarezerwowanie ( w tym przypadku ) pamięci RAM.

ale można dokładnie to samo uzyskać również tak:

struct IMIONA {
        uint8_t ala;
        uint8_t ola;
} imiona;

bo teraz "imiona" na końcu struktury, przed średnikiem to już DEFINICJA zmiennej typu strukturalnego "IMIONA". Jak widzisz - dwa ostatnie zapisy różnią się literalnie ale oznaczają to samo. Lubimy sobie jednak upraszczać życie, i w przypadku powyżej także moglibyśmy uprościć ten zapis do takiej formy, spójrz:

struct {
        uint8_t ala;
        uint8_t ola;
} imiona1, imiona2;

Czyli stworzyliśmy powyżej strukturę tzw "anonimową" bez nazwy, ale od razu przed kończącym średnikiem  podajemy nazwę albo jak widzisz nazwy (może ich być kilka) zmiennych, które chcemy utworzyć (uwaga!) od razu ZDEFINIOWAĆ, czyli zarezerwować także pamięć RAM. Myślę że to ważne wyjaśnienia ale...

... ale ja praktycznie bardzo rzadko korzystam z takich form posługiwania się strukturami, dlatego że często je wykorzystuję a nierzadko okazuje się, że w trakcie pisania kodu, potrzeba mi nagle wiele różnych zmiennych strukturalnych ... dlatego stosuję dostępne w języku C narzędzie jakim jest "typedef". Służy ono do tworzenia własnych typów zmiennych. A w przypadku struktur znakomicie ułatwia pracę z nimi i wprowadza sporo logiki oraz możliwości powtarzalności w kodzie. Stosując typedef, korzystam tylko z tzw nazwy skróconej struktury, czyli tej po zamkniętym nawiasie klamrowym, przed średnikiem. Ale najpierw zobaczmy jak to wygląda podstawowa wersja nowego typu strukturalnego, żeby wszystko było jasne:

typedef struct IMIONA {
        uint8_t ala;
        uint8_t ola;
} ;

Definiując nowy typ (a nie jest to równoznaczne z DEFINICJĄ zmiennej), nie musimy podawać nazwy po zamkniętym nawiasie klamrowym, chociaż moglibyśmy (ale o ty za chwilę), tyle że taka nazwa nie byłaby nadal DEFINICJĄ zmiennej, ponieważ definiujemy tutaj tylko nowy typ danych. No dobrze to jak teraz powołać do życia nową zmienną typu strukturalnego "IMIONA" ? Niestety w takim przypadku znowu musimy użyć słówka "struct" i wyjdzie na to samo o czym była mowa w pierwszym przykładzie, spójrz:

struct IMIONA imiona;

Bez tego słówka "struct" nie da rady w tak przygotowanej nowej definicji typu i tu nie widać przewagi o jakiej wspominam ;) Ale dla mnie byłoby, że tak powiem, uciążliwe ciągłe posługiwanie się tym słówkiem "struct", dlatego dobrze, że stwórcy C wymyślili możliwość wskazania tzw "NAZWY SKRÓCONEJ", dla nowo powoływanego do życia typu, z użyciem "typedef". Dlatego zobacz mogę to zrobić tak:

typedef struct IMIONA {
        uint8_t ala;
        uint8_t ola;
} TIMIONA;

Widzisz? dodałem za nawiasem klamrowym skróconą nazwę "TIMIONA", nie musi ona być różna od jawnej nazwy struktury, w tym przypadku "IMIONA". I teraz UWAGA! .... (najlepsze nadchodzi) ;) ... Zobacz jak teraz może wyglądać w kodzie programu DEFINICJA nowej zmiennej tego typu:

TIMIONA imiona;

Nie musiałem użyć słówka "struct", mniej pisania ;) ... i jak dla mnie przejrzyście. Ale skoro można tak, to już pewnie się domyślasz, że tak jak na początku mówiłem, można pozbyć się także pełnej nazwy tej struktury "IMIONA" czyli będzie anonimowa ? NIE, będziemy się posługiwać nazwą skróconą. Kolejne uproszczenie może zatem wyglądać tak:

typedef struct {
        uint8_t ala;
        uint8_t ola;
} TIMIONA;

i dalej tak samo DEFINICJA np, kilku nowych zmiennych:

TIMIONA imiona1, imiona2, imiona3;

Przyznasz chyba że to DUŻO wygodniejsze w pisaniu?

Wszystko dobrze, ale czy to oznacza, że możemy zapomnieć raz na zawsze o korzystaniu także z pełnej nazwy struktury, gdy definiujemy nowy typ za pomocą "typedef" ?

NIE, specjalnie podawałem od podstaw jaką drogą się tworzy to wszystko i ew skraca, żebyś wiedział w pewnych specyficznych przypadkach, jak tego użyć. Proszę bardzo najlepiej omówić to na żywym przykładzie dla lepszego zrozumienia. Wyobraź więc sobie, że chcemy tym razem powołać nowy typ strukturalny za pomocą "typedef" ale chcielibyśmy w ramach tej struktury umieścić wskaźnik, dokładnie takiego samego typu strukturalnego. Załóżmy że zaczynamy tworzyć nie mając pełnej wiedzy takiego potworka:

typedef struct {
        uint8_t ala;
        uint8_t ola;
        TIMIONA * zbior_imion; // -- tu próbujemy dać typ
} TIMIONA;

Ale jest wielki problem, ponieważ kompilator przy kompilacji od początku pliku linia po linii, napotyka nasz wskaźnik i niestety :( przykro mi ale nie zna jeszcze nazwy TIMIONA, ponieważ ona pojawi się dopiero w kolejnej linii, więc wywali BŁĄD KOMPILACJI, i koniec. No to wydaje się, że wpadliśmy w pułapkę ? Nie, na szczęście przypomina nam się fakt, że możemy jeszcze posłużyć się pełną nazwą struktury, definiując nowy typ, o tak:

typedef struct IMIONA {
        uint8_t ala;
        uint8_t ola;
        struct IMIONA * zbior_imion; // posługujemy się teraz typem z nazwy pełnej
} TIMIONA;

Jak widzisz, szczęśliwie udało nam się wybrnąć z wydawać by się mogło patowej sytuacji. Dla określenia typu wskaźnika, nadaliśmy poza nazwą skróconą "TIMIONA" także pełną nazwę "IMIONA", dzięki której również można powołać nową zmienną ale pamiętając o słówku "struct". Udało się - BINGO! ;)

Innym przykładem tego zagadnienia może być rozwiązanie zagadki z mojego poradnika o grze SNAKE na LCD - oglądałeś ten poradnik ? jak nie to obejrzyj:

http://mirekk36.blogspot.com/2012/12/wskazniki-struktury-callbacki-jazda-bez.html

Tam chcąc z kolei wyjaśnić dobrze posługiwanie się pustym typem "void" wyjaśnić różne meandry jego zastosowania, i przy okazji pokazałem jeszcze kolejną możliwość obejścia tego kłopotu, o którym mowa wyżej, a można byłoby to zrobić mniej więcej tak, w naszych przykładach:

typedef struct {
        uint8_t ala;
        uint8_t ola;
        void* zbior_imion; // -- użyliśmy pustego typu wskaźnikowego void*
} TIMIONA;

Dzięki czemu później, gdybyśmy w kodzie chcieli podstawić jakąś zmienną pod ten wskaźnik, np kolejną zmienną imiona:


TIMIONA imiona1, imiona2;

imiona1.zbior_imion = &imiona2;

I od tego momentu, wskaźnik "zbior_imion" byłby już nie typu "void" a typu TIMIONA. Zapamiętaj! jeśli się jednak da zrobić coś bez rzutowania na typ wskaźnikowy "void*" to zawsze wybierz tę pierwszą opcję, a rzutowania na typ "void*" staraj się unikać i zostawiać na najtrudniejsze do jawnego rzutowania przypadki.

To tyle. Dla jednych pewnie będzie to tylko tyle ale dla innych aż tyle. Ja jestem zdania, że warto sobie tak podsumować podstawową wiedzę o strukturach, bo brak tej wiedzy skutkuje później nie tylko ogromnymi problemami podczas pisania kodu z ich użyciem ale co gorsze, zniechęca w ogóle do wykorzystywania struktur na co dzień ;) .... gdy tymczasem są to PRZEPIĘKNE mechanizmy w języku C, szczególnie w połączeniu z uniami, wskaźnikami i tablicami.

Na koniec małe uzupełnienie, odpowiedzmy sobie na dwa pytania:

1. czy nazwę struktury lub nazwę skróconą trzeba pisać dużymi literami?

Oczywiście, że nie, jednak dla mnie jest to o wiele bardziej przejrzysty sposób

2. dlaczego do skróconej nazwy podczas definicji nowego typu, dodaję literkę T na początku?

Po to aby w kodzie szybko ocenić wzrokiem później, że chodzi o nowo powołany przeze mnie TYP

są to więc jak widzisz czysto praktyczne zasady ;)

Jeśli będziesz miał(-a) jeszcze jakieś pytania do tego co tu opisałem - to śmiało pisz, pytaj w tym artykule ;)

Na koniec - gorąco polecam uzupełnienie do tego poradnika w postaci mini kursu pod tym linkiem na naszym forum:

KLIKNIJ TUTAJ - link do forum.atnel.pl

;)