Programowanie w języku C. FAQ

1. IDZ DO PRZYK£ADOWY ROZDZIA£ SPIS TRE CI Programowanie w jêzyku C. FAQ KATALOG KSI¥¯EK Autor: Steve Summit KATALOG ONLINE T³umaczenie: Przemys³aw Kowalczyk ISBN: 83-7361-094-4 ZAMÓW DRUKOWANY KATALOG Tytu³ orygina³u: C Programming FAQs Format: B5, stron: 400 TWÓJ KOSZYK DODAJ DO KOSZYKA Przys³owie „kto pyta, nie b³¹dzi” nie zawiera ca³ej prawdy. Nie wystarczy pytaæ, trzeba jeszcze znajdowaæ odpowiedzi. Ksi¹¿ka „Programowanie w jêzyku C. FAQ” to zbiór kilkuset odpowiedzi na najczê ciej zadawane pytania na temat tego jêzyka CENNIK I INFORMACJE programowania. Z pewno ci¹ czê æ z przedstawionych tu pytañ ju¿ pojawi³a siê w Twojej praktyce programistycznej (pamiêtasz, ile czasu straci³e poszukuj¹c ZAMÓW INFORMACJE odpowiedzi?). Inne problemy dopiero siê pojawi¹ i je li na Twojej pó³ce bêdzie ta O NOWO CIACH ksi¹¿ka, szybko znajdziesz w niej zwiêz³e, ale wyczerpuj¹ce rozwi¹zanie czêsto wzbogacone przyk³adem kodu ród³owego. ZAMÓW CENNIK Chocia¿ ksi¹¿ka ¿adn¹ miar¹ nie powinna byæ traktowana jako podrêcznik, z którego mo¿na nauczyæ siê programowania w C, z pewno ci¹ przyda siê ka¿dej osobie u¿ywaj¹cej tego jêzyka w codziennej praktyce. Autor porusza wiele przydatnych CZYTELNIA zagadnieñ obejmuj¹cych szeroki zestaw tematów. Omówiono miêdzy innymi: FRAGMENTY KSI¥¯EK ONLINE • Deklaracje • Struktury i unie • Puste wska niki • Wyra¿enia • Makroprocesor • Alokacjê pamiêci • Ró¿nice miêdzy standardami C • Standardow¹ bibliotekê wej cia-wyj cia • Kwestie zwi¹zane z systemami operacyjnymi Wydawnictwo Helion ul. Chopina 6 44-100 Gliwice tel. (32)230-98-63 e-mail: helion@helion.pl

2. Spis treści Pytania.............................................................................................. 9 Przedmowa...................................................................................... 37 Wprowadzenie ................................................................................. 41 Jak korzystać z tej ksią ki? ......................................................................................41 Format pytań..........................................................................................................43 Przykłady kodu ......................................................................................................43 Organizacja ksią ki .................................................................................................44 Rozdział 1. Deklaracje i inicjalizacja................................................................... 47 Podstawowe typy....................................................................................................47 Deklaracje wskaźników ...........................................................................................50 Styl deklaracji.........................................................................................................51 Klasy pamięci.........................................................................................................54 Definicje typów ......................................................................................................55 Kwalifikator const ..................................................................................................59 Zło one deklaracje ..................................................................................................59 Rozmiary tablic ......................................................................................................62 Problemy z deklaracjami .........................................................................................64 Przestrzeń nazw......................................................................................................65 Inicjalizacja............................................................................................................69 Rozdział 2. Struktury, unie i typy wyliczeniowe................................................... 73 Deklaracje struktur..................................................................................................73 Działania na strukturach ..........................................................................................78 Wyrównywanie pól struktur.....................................................................................80 Dostęp do pól struktur.............................................................................................82 Ró ne pytania na temat struktur ...............................................................................83 Unie ......................................................................................................................84 Typy wyliczeniowe .................................................................................................85 Pola bitowe ............................................................................................................86 Rozdział 3. Wyrażenia........................................................................................ 89 Kolejność obliczania ...............................................................................................89 Inne pytania na temat wyra eń.................................................................................96 Reguły zachowywania........................................................................................... 100

3. 6 Programowanie w języku C. FAQ Rozdział 4. Wskaźniki...................................................................................... 103 Podstawy ............................................................................................................. 103 Działania na wskaźnikach...................................................................................... 105 Wskaźniki jako parametry funkcji .......................................................................... 106 Ró ne zastosowania wskaźników ........................................................................... 110 Rozdział 5. Wskaźniki puste ............................................................................ 113 Wskaźniki puste i literały wskaźnika pustego .......................................................... 113 Makrodefinicja NULL........................................................................................... 116 Retrospektywa...................................................................................................... 121 Co mo na znaleźć pod adresem 0? ......................................................................... 124 Rozdział 6. Tablice i wskaźniki......................................................................... 127 Podstawowe związki między tablicami i wskaźnikami.............................................. 128 Tablicom nie mo na przypisywać wartości.............................................................. 131 Retrospektywa...................................................................................................... 132 Wskaźniki do tablic............................................................................................... 134 Dynamiczne tworzenie tablic ................................................................................. 136 Funkcje a tablice wielowymiarowe ......................................................................... 140 Rozmiary tablic .................................................................................................... 143 Rozdział 7. Przydzielanie pamięci ..................................................................... 145 Podstawowe problemy z przydzielaniem pamięci..................................................... 145 Wywoływanie funkcji malloc................................................................................. 149 Problemy z funkcją malloc..................................................................................... 152 Zwalnianie pamięci ............................................................................................... 155 Rozmiar przydzielonych bloków ............................................................................ 158 Inne funkcje przydzielające pamięć ........................................................................ 159 Rozdział 8. Znaki i napisy................................................................................ 165 Rozdział 9. Wyrażenia i zmienne logiczne ......................................................... 171 Rozdział 10. Preprocesor języka C ..................................................................... 175 Makrodefinicje ..................................................................................................... 175 Pliki nagłówkowe ................................................................................................. 180 Kompilacja warunkowa......................................................................................... 183 Zaawansowane przetwarzanie ................................................................................ 186 Makrodefinicje ze zmienną liczbą argumentów........................................................ 189 Rozdział 11. Standard ANSI/ISO języka C .......................................................... 193 Standard .............................................................................................................. 193 Prototypy funkcji .................................................................................................. 195 Kwalifikator const ................................................................................................ 198 Funkcja main........................................................................................................ 200 Właściwości preprocesora ..................................................................................... 203 Inne sprawy związane ze Standardem ANSI............................................................ 205 Stare lub niezgodne ze Standardem kompilatory ...................................................... 208 Kwestie zgodności ................................................................................................ 211 Rozdział 12. Standardowa biblioteka wejścia-wyjścia ......................................... 215 Podstawy obsługi wejścia-wyjścia .......................................................................... 216 Formaty dla funkcji printf ...................................................................................... 218 Formaty dla funkcji scanf ...................................................................................... 222 Problemy z funkcją scanf ...................................................................................... 224 Inne funkcje z biblioteki wejścia-wyjścia ................................................................ 228

4. Spis treści 7 Otwieranie plików i operacje na nich ...................................................................... 232 Przekierowywanie strumieni stdin i stdout............................................................... 235 Obsługa wejścia-wyjścia w trybie binarnym ............................................................ 237 Rozdział 13. Funkcje biblioteczne ...................................................................... 241 Funkcje operujące na napisach ............................................................................... 241 Sortowanie ........................................................................................................... 247 Data i czas ........................................................................................................... 251 Liczby losowe ...................................................................................................... 254 Inne funkcje biblioteczne....................................................................................... 261 Rozdział 14. Liczby zmiennoprzecinkowe............................................................ 265 Rozdział 15. Listy argumentów o zmiennej długości............................................ 273 Wywoływanie funkcji o zmiennej liczbie argumentów ............................................. 274 Implementacja funkcji o zmiennej liczbie argumentów............................................. 275 Pobieranie argumentów z listy................................................................................ 280 Trudniejsze problemy............................................................................................ 283 Rozdział 16. Dziwne problemy............................................................................ 287 Rozdział 17. Styl ............................................................................................... 293 Rozdział 18. Narzędzia i zasoby.......................................................................... 299 Narzędzia............................................................................................................. 299 Program lint ......................................................................................................... 301 Zasoby................................................................................................................. 303 Rozdział 19. Kwestie zależne od systemu operacyjnego...................................... 309 Klawiatura i ekran................................................................................................. 310 Inne operacje wejścia-wyjścia ................................................................................ 316 Pliki i katalogi ...................................................................................................... 318 Bezpośredni dostęp do pamięci .............................................................................. 324 Polecenia systemowe ............................................................................................ 326 Środowisko procesu .............................................................................................. 329 Inne operacje zale ne od systemu........................................................................... 330 Retrospektywa...................................................................................................... 333 Rozdział 20. Różności........................................................................................ 335 Przydatne techniki................................................................................................. 336 Bity i bajty ........................................................................................................... 343 Wydajność ........................................................................................................... 348 Instrukcja switch................................................................................................... 352 Ró ne kwestie językowe ....................................................................................... 354 Inne języki ........................................................................................................... 358 Algorytmy............................................................................................................ 359 Inne..................................................................................................................... 364 Słownik ......................................................................................... 369 Bibliografia .................................................................................... 379 Skorowidz ..................................................................................... 383

5. Rozdział 6. Tablice i wskaźniki Siła języka C wynika między innymi z ujednoliconego traktowania tablic i wskaźni- ków. Bardzo łatwo jest za pomocą wskaźników operować na tablicach czy symulo- wać tablice tworzone dynamicznie. Tak zwana odpowiedniość wskaźników i tablic jest tak du a, e niektórzy programiści zapominają o zasadniczych ró nicach, myśląc, e są one identyczne, albo zakładając nieistniejące między nimi podobieństwa. Podstawą „odpowiedniości” tablic i wskaźników w języku C jest fakt, e odwołania do tablic „degenerują się” do wskaźników do pierwszego elementu tablicy, co opisuje pytanie 6.3. Z tego powodu tablice są „obywatelami drugiej kategorii” w C — nigdy nie posługujesz się tablicami jako całymi obiektami (na przykład aby skopiować je albo przekazać do funkcji). Kiedy u yjesz nazwy tablicy, w wyra eniu pojawi się wskaźnik zamiast całej tablicy. Nawet operator indeksowania tablic =? w rzeczywi- stości operuje na wskaźniku. Wyra enie C=K? jest równowa ne wyra eniu wskaźni- kowemu

6. C K. Du a część tego rozdziału (szczególnie pytania „retrospektywne” 6.8 – 6.10) mo e wydawać się powtarzaniem wcią tych samych wiadomości. Wielu programistów ma jednak spore kłopoty ze zrozumieniem związków i ró nic między wskaźnikami i tablicami, w tym rozdziale staram się wyjaśnić je najlepiej, jak tylko potrafię. Je eli nudzą Cię takie powtórki, mo esz przeskoczyć do następnego rozdziału. Je eli jednak masz kłopoty z tablicami lub wskaźnikami, przeczytaj uwa nie odpowiedzi, a po- szczególne części układanki na pewno „wskoczą na swoje miejsca”.

7. 128 Programowanie w języku C. FAQ Podstawowe związki między tablicami i wskaźnikami 6.1 Pytanie: W jednym z plików źródłowych mam definicję EJCT C=?, a w innym de- klarację GZVGTP EJCT

8. C. Dlaczego to nie działa? Odpowiedź: Zmienna zadeklarowana przy u yciu GZVGTP EJCT

9. C nie jest typu tabli- cowego, nie pasuje więc do rzeczywistej definicji. Typ „wskaźnik do typu 6” nie jest tym samym, co typ „tablica elementów typu 6”. U yj deklaracji GZVGTP EJCT C=?. Referencje: ANSI §3.5.4.2 ISO §6.5.4.2 CTP §3.3, §4.5 6.2 Pytanie: Ale przecie słyszałem, e EJCT C=? i EJCT

10. C to to samo. Czy to prawda? Odpowiedź: Nie, to nie jest prawda (to, co słyszałeś, odnosiło się do parametrów formalnych funkcji, zobacz pytanie 6.4). Tablice nie są wskaźnikami, chocia są blisko z nimi związane (zobacz pytanie 6.3) i korzysta się z nich podobnie (zobacz pytania 4.1, 6.8, 6.10 i 6.14). Deklaracja tablicy EJCT C=? powoduje przydzielenie miejsca na sześć znaków i po- wiązanie go z nazwą C. Innymi słowy, C stanowi adres obszaru pamięci, w którym zmieści się sześć znaków. Z drugiej strony, deklaracja wskaźnika EJCT

11. R powoduje przydzielenie miejsca na wskaźnik i powiązanie go z nazwą R. Wskaźnik ten mo e wskazywać praktycznie gdziekolwiek: na pojedynczą zmienną typu EJCT, na ciągłą tablicę elementów typu EJCT albo nigdzie 1 (zobacz te pytania 1.30 i 5.1). Jak zwykle w takich sytuacjach, obrazek wart jest tysiąca słów. Deklaracje: EJCT C=? JGNNQ EJCT

12. R YQTNF powodują utworzenie i zainicjalizowanie struktur danych, które mo na zobrazować następująco: 1 Nie nale y jednak interpretować pojęć „gdziekolwiek” i „nigdzie” zbyt szeroko. Aby wskaźnik miał poprawną wartość, musi wskazywać na prawidłowo przydzielony obszar pamięci (zobacz pytania 7.1, 7.2 i 7.3). Aby wskazywać „nigdzie”, musi być wskaźnikiem pustym (zobacz pytanie 5.1).

13. Rozdział 6. ♦ Tablice i wskaźniki 129 Nale y pamiętać, e wyra enie Z=? tłumaczone jest przez kompilator odmiennie, w zale ności od tego, czy Z to wskaźnik, czy tablica. W zasięgu widoczności powy - szych deklaracji wyra enie C=? powoduje wygenerowanie następującego kodu: „weź adres tablicy C, dodaj do niego 3 i pobierz znak stamtąd”. Z kolei wyra enie R=? tłu- maczone jest jako: „weź adres wskaźnika R, pobierz jego wartość, dodaj do niej 3 i pobierz znak stamtąd”. Innymi słowy, wyra enie C=? odnosi się do znaku odległego o 3 miejsca od początku obiektu o nazwie C, natomiast R=? to znak odległy o 3 miejsca od obiektu wskazywanego przez R. W naszym przykładzie zarówno C=?, jak i R=? odnoszą się do litery N , ale nie są to te same litery i ich adresy obliczane są inaczej. Referencje: KR2 §5.5 CTP §4.5 6.3 Pytanie: Co w takim razie oznacza „odpowiedniość wskaźników i tablic” w C? Odpowiedź: Wiele nieporozumień dotyczących tablic i wskaźników w języku C bierze się właśnie z niewłaściwego rozumienia tego pojęcia. „Odpowiedniość” nie oznacza, e są one identyczne, ani nawet, e mogą być u ywane wymiennie. Definicję owej „odpowiedniości” mo na przedstawić następująco: referencja do obiektu o typie „tablica elementów typu 6”, „degeneruje się” w wyra eniach (z trzema wyjątkami) do wskaźnika do pierwszego elementu tablicy. Jest on typu „wskaźnik do typu 6” (Wspo- mniane wyjątki to: kiedy nazwa tablicy jest argumentem operatora UKGQH, operatora albo jest literałem napisowym w inicjalizatorze tablicy znaków 2. Zobacz pytania 6.23, 6.12 i 1.32, odpowiednio). Z takiej definicji wynika, e zastosowanie operatora =? do tablic i wskaźników nie ró - ni się tak bardzo 3, mimo e są to odmienne obiekty. Je eli C to tablica, a R to wskaź- nik, wyra enie w postaci C=K? powoduje, e odwołanie do tablicy zamieniane jest niejawnie na wskaźnik do pierwszego elementu, zgodnie z powy szą regułą. Dalsze operacje są identyczne jak w przypadku indeksowania wskaźnika w wyra eniu R=K? (chocia obliczenie ró ni się operacjami odczytu pamięci, jak wyjaśniłem w pytaniu 6.2). Je eli przypiszesz do wskaźnika adres tablicy: R C to wyra enia R=? i C=? będą się odnosić do tego samego elementu. 2 Za „literał napisowy w inicjalizatorze tablicy znaków” uwa amy tak e literały inicjalizujące tablice znaków YEJCTAV. 3 Mówiąc ściśle, operator =? zawsze jest stosowany do wskaźników, zobacz pytanie 6.10, punkt 2.

14. 130 Programowanie w języku C. FAQ Dzięki temu właśnie wskaźniki mo na tak łatwo stosować do operacji na tablicach, u ywać ich zamiast tablic jako argumentów funkcji (zobacz pytanie 6.4) czy symulo- wać tablice dynamiczne (zobacz pytanie 6.14). Zobacz te pytania 6.8 i 6.10. Referencje: KR1 §5.3 KR2 §5.3 ANSI §3.2.2.1, §3.3.2.1, §3.3.6 ISO §6.2.2.1, §6.3.2.1, §6.3.6 HS §5.4.1 6.4 Pytanie: Je eli więc tablice i wskaźniki ró nią się tak bardzo, dlaczego mo na u ywać ich wymiennie jako parametrów formalnych funkcji? Odpowiedź: Dla wygody. Poniewa w wyra eniach tablice stają się wskaźnikami, do funkcji przekazywane są zawsze wskaźniki, a nigdy tablice. Mo esz „udawać”, e funkcja oczekuje jako parametru tablicy i podkreślić to w kodzie źródłowym, deklarując funkcję jako: H EJCT C=? ] _ Jednak taka deklaracja, zinterpretowana dosłownie, nie ma zastosowania, gdy funkcja i tak otrzyma wskaźnik, więc dla kompilatora równowa na jest z deklaracją: H EJCT

15. C ] _ Nie ma nic niewłaściwego w mówieniu, e funkcja otrzymuje jako parametr tablicę, je eli jest on wewnątrz funkcji traktowany jako tablica. Wymienne stosowanie tablic i wskaźników dopuszczalne jest jedynie w deklaracjach parametrów formalnych funkcji i w adnym innym przypadku. Je eli podmiana tablicy na wskaźnik w deklaracji funkcji przeszkadza Ci, deklaruj parametry jako wskaźniki. Wiele osób uwa a, e zamieszanie, jakie powodują takie deklaracje, znacznie przewa- a nad korzyściami z faktu, e parametr „wygląda”, jakby był tablicą (Zauwa rów- nie , e taka konwersja zachodzi tylko raz; parametr typu EJCT C=?=? jest nieprawi- dłowy. Zobacz pytania 6.18 i 6.19). Zobacz te pytanie 6.21. Referencje: KR1 §5.3, §A10.1 KR2 §5.3, §A8.6.3, §A10.1 ANSI §3.5.4.3, §3.7.1, §3.9.6 ISO §6.5.4.3, §6.7.1, §6.9.6 HS §9.3 CTP §3.3 Ritchie, The Development of the C Language

16. Rozdział 6. ♦ Tablice i wskaźniki 131 Tablicom nie można przypisywać wartości Je eli tablica pojawia się po prawej stronie operatora przypisania, kopiowany jest wskaźnik do pierwszego elementu, a nie cała tablica. Co więcej, tablica nie mo e się pojawić po lewej stronie operatora przypisania (między innymi dlatego, e i tak nie mo na jej przypisać całej tablicy, jak wynika z poprzedniego zdania). 6.5 Pytanie: Czemu tablicom nie mo na przypisywać wartości? Poni szy kod nie działa: GZVGTP EJCT

17. IGVRCUU EJCT UVT=? UVT IGVRCUU 9RTQYCF JCU Q Odpowiedź: Tablice są „obywatelami drugiej kategorii” w języku C. Nie mo na im, między innymi, przypisywać wartości (zobacz te pytanie 6.7). Kiedy chcesz skopio- wać elementy z jednej tablicy do drugiej, musisz to wyrazić jawnie. W przypadku na- pisów, pamiętanych jako EJCT=?, odpowiednia jest najczęściej funkcja UVTER[: UVTER[ UVT IGVRCUU 9RTQYCF JCU Q Je eli chcesz operować na tablicach bez kopiowania ich zawartości, mo esz u ywać wskaźników — wtedy wystarczy zwykłe przypisanie. Zobacz te pytania 4.1 i 8.2. Referencje: ANSI §3.2.2.1 ISO §6.2.2.1 HS §7.9.1 6.6 Pytanie: Je eli nie mogę przypisywać wartości tablicom, w jaki sposób działa ten kod? KPV H EJCT UVT=? ] KH UVT=? UVT RWUV[ _ Odpowiedź: W tym przypadku UVT jest parametrem funkcji. Jego deklaracja jest „podmieniana” przez kompilator, jak opisałem to w pytaniu 6.4. Innymi słowy, UVT jest wskaźnikiem (typu EJCT

18. ), mo na więc mu przypisać wartość.

19. 132 Programowanie w języku C. FAQ 6.7 Pytanie: W jaki sposób tablica mo e być l-wartością, je eli nie mo na do niej przy- pisać? Odpowiedź: Termin l-wartość nie oznacza w rzeczywistości „czegoś, czemu mo na przypisać wartość”. Lepszą definicją byłoby „coś, co posiada adres w pamięci”4. Stan- dard ANSI/ISO języka C definiuje równie pojęcie „modyfikowalnej l-wartości”. Ta- blica nią nie jest. Zobacz te pytanie 6.5. Referencje: ANSI §3.2.2.1 ISO §6.2.2.1 Rationale §3.2.2.1 HS §7.1 Retrospektywa Poniewa związki między tablicami i wskaźnikami powodują tyle nieporozumień, kil- ka następnych pytań dotyczy właśnie przyczyn tych nieporozumień. 6.8 Pytanie: Jaka jest praktyczna ró nica między tablicami i wskaźnikami? Odpowiedź: Tablica jest pojedynczym, przydzielonym wcześniej ciągłym obszarem pamięci, zawierającym elementy tego samego typu. Posiada stały rozmiar i poło enie. Wskaźnik to odniesienie do dowolnego elementu (określonego typu) gdziekolwiek. Wskaźnikowi nale y przypisać adres przydzielonego w jakiś sposób obszaru pamięci, ale mo na jego wartość modyfikować (a obszarowi pamięci, je eli został przydzielony dynamicznie, mo na zmienić rozmiar). Wskaźnik mo e wskazywać na elementy tablicy i mo na go u yć (wraz z funkcją OCNNQE) do symulowania dynamicznych tablic. Wskaźniki są jednak znacznie bardziej ogólną strukturą danych (zobacz równie pytanie 4.1). Z powodu tak zwanej „odpowiedniości wskaźników i tablic” (zobacz pytanie 6.3) mo e się wydawać, e tablic i wskaźników mo na u ywać wymiennie. Wskaźnik do obszaru pamięci przydzielonego przez funkcję OCNNQE jest często traktowany jako tablica (mo e być nawet argumentem operatora =?). Zobacz pytania 6.14 i 6.16 (Pa- miętaj o zachowaniu ostro ności przy u yciu operatora UKGQH, zobacz pytanie 7.28). Zobacz te pytania 1.32, 6.10 i 20.14. 4 Pierwotna definicja l-wartości rzeczywiście mówiła o lewej stronie operatora przypisania.

20. Rozdział 6. ♦ Tablice i wskaźniki 133 6.9 Pytanie: Ktoś wyjaśnił mi, e tablice to w rzeczywistości stałe wskaźniki. Czy to prawda? Odpowiedź: To zbyt uproszczone wyjaśnienie. Nazwa tablicy jest „stałą” w tym sen- sie, e nie mo na jej przypisać wartości. Jednak tablica to nie wskaźnik, co powinna wyjaśnić odpowiedź na pytanie 6.2. Zobacz te pytania 6.3, 6.8 i 6.10. 6.10 Pytanie: Ciągle nie do końca rozumiem. Czy wskaźnik jest rodzajem tablicy, czy mo e tablica jest rodzajem wskaźnika? Odpowiedź: Tablica nie jest wskaźnikiem, a wskaźnik nie jest tablicą. Referencja do tablicy (czyli u ycie nazwy tablicy w kontekście wyra enia) jest zamieniana na wskaźnik (zobacz pytania 6.2 i 6.3). Są przynajmniej trzy prawidłowe interpretacje tej sytuacji: 1. Wskaźniki mogą symulować tablice (ale to nie jedyne ich zastosowanie, zobacz pytanie 4.1). 2. W języku C w zasadzie nie ma tablic z prawdziwego zdarzenia (są „obywatelami drugiej kategorii”). Nawet operator =? jest w rzeczywistości operatorem działającym na wskaźniku. 3. Na wy szym poziomie abstrakcji wskaźnik do ciągłego obszaru pamięci mo e być uwa any za tablicę (chocia są te inne zastosowania wskaźników). Z drugiej strony, nie nale y myśleć w ten sposób: 4. „Są dokładnie takie same” (nieprawda, zobacz pytanie 6.2). 5. „Tablice to stałe wskaźniki” (nieprawda, zobacz pytanie 6.9). Zobacz te pytanie 6.8. 6.11 Pytanie: Spotkałem się z „dowcipnym” kodem, zawierającym wyra enie = CDEFGH ?. Dlaczego jest ono poprawne? Odpowiedź: Mo e to zabrzmi niewiarygodnie, ale indeksowanie tablic jest działa- niem przemiennym 5 w języku C. Ten ciekawy fakt wynika ze wskaźnikowej definicji 5 Przemienność dotyczy tylko argumentów operatora =?. Wyra enie C=K?=L? jest w oczywisty sposób ró ne od wyra enia C=L?=K?.

21. 134 Programowanie w języku C. FAQ operatora =?. Wyra enie C=G? jest równowa ne

22. C G dla dowolnych dwóch wyra eń C i G, je eli tylko jedno z nich jest wyra eniem wskaźnikowym, a drugie całko- witym. „Dowód” przemienności mógłby wyglądać tak: C=G? jest z definicji równowa ne:

23. C G jest równowa ne na mocy przemienności dodawania:

24. G C jest z definicji równowa ne: G=C?. Nieoczekiwana przemienność operatora =? traktowana jest zazwyczaj w tekstach o ję- zyku C jako powód do dumy, chocia nie ma sensownych zastosowań poza Konkur- sami Zaciemnionego Kodu w C (zobacz pytanie 20.36). Poniewa napisy w języku C są tablicami elementów typu EJCT, wyra enie CDEF GH =? jest całkowicie poprawne. Jego wartością jest litera H . Mo esz uwa ać to za skróconą postać wyra enia: EJCT

25. VORRVT CDEFGH VORRVT=? W pytaniu 20.10 znajdziesz bardziej realistyczny przykład. Referencje: Rationale §3.3.2.1 HS §5.4.1, §7.4.1 Wskaźniki do tablic Poniewa tablice zwykle zamieniane są na wskaźniki, szczególnie łatwo o nieporozumienia, kiedy operujemy na wskaźnikach do całych tablic (zamiast, jak zwykle, do ich pierwszych elementów). 6.12 Pytanie: Je eli odwołania do tablic przekształcane są na wskaźniki, jaka jest ró - nica między CTTC[ i CTTC[ (przy zało eniu, e CTTC[ to jakaś tablica)? Odpowiedź: Wyra enia te ró nią się typem. Standard języka C stanowi, e wyra enie CTTC[ jest typu „wskaźnik do tablicy ele- mentów typu 6” i zwraca wskaźnik do całej tablicy (wcześniejsze kompilatory gene- ralnie ignorowały operator w takim kontekście, czasem tylko zgłaszając ostrze enie). We wszystkich kompilatorach języka C odwołanie do nazwy tablicy (bez operatora ) zwraca wskaźnik, typu „wskaźnik do typu 6”, do pierwszego elementu tablicy.

26. Rozdział 6. ♦ Tablice i wskaźniki 135 W przypadku tablicy jednowymiarowej, jak na przykład: KPV C=? odwołanie do C jest typu „wskaźnik do typu KPV”, a C — „wskaźnik do tablicy 10 elementów typu KPV”. W przypadku tablic dwuwymiarowych: KPV CTTC[=04195?=0%1.7/05? odwołanie do CTTC[ jest typu „wskaźnik do tablicy 0%1.7/05 elementów typu KPV”, natomiast CTTC[ — „wskaźnik do tablicy 04195 tablic o 0%1.7/05 elementów typu KPV”. Zobacz te pytania 6.3, 6.13 i 6.18. Referencje: ANSI §3.2.2.1, §3.3.3.2 ISO §6.2.2.1, §6.3.3.2 Rationale §3.3.3.2 HS §7.5.6 6.13 Pytanie: Jak zadeklarować wskaźnik do tablicy? Odpowiedź: Zastanów się, czy rzeczywiście go potrzebujesz. Kiedy ktoś mówi o wskaź- niku do tablicy, ma zazwyczaj na myśli wskaźnik do jej pierwszego elementu. Zamiast wskaźnika do tablicy czasem lepiej u yć wskaźnika do jednego z elementów tablicy. Tablice elementów typu 6 stają się w wyra eniach wskaźnikami do typu 6 (zobacz pytanie 6.3), co jest bardzo wygodne. Indeksowanie albo zwiększanie po- wstałego tak wskaźnika pozwala na dostęp do elementów tablicy. Rzeczywiste wskaź- niki do tablic, kiedy są indeksowane lub zwiększane, „przechodzą” przez całe tablice i są przydatne tylko, gdy operujemy na tablicach tablic6 (zobacz pytanie 6.18). Je eli naprawdę potrzebujesz wskaźnika do całej tablicy, zadeklaruj go na przykład tak: KPV

27. CR=0?, gdzie 0 to rozmiar tablicy (zobacz te pytanie 1.21). Je eli rozmiar tablicy jest nieznany, 0 mo na teoretycznie pominąć, ale zadeklarowany w ten sposób „wskaźnik do tablicy nieznanego rozmiaru” jest bezu yteczny. Poni sze przykłady pokazują ró nice między zwykłymi wskaźnikami a wskaźnikami do tablic. Przy zało eniu, e obowiązują deklaracje: KPV C=? ] _ KPV C=?=? ]] _ ] __ KPV

28. KR

29. YUMC PKM FQ V[RW KPV

30. KPV

31. CR=?

32. YUMC PKM FQ VCDNKE[ GNGOGPVÎY V[RW KPV

33. mo emy u yć wskaźnika do typu KPV, KR, aby operować na jednowymiarowej tablicy C: 6 Rozumowanie to dotyczy oczywiście równie tablic trój- i więcejwymiarowych.

34. 136 Programowanie w języku C. FAQ KR C RTKPVH F

35. KR KR RTKPVH FP

36. KR Ten fragment kodu wydrukuje: Jednak próba u ycia wskaźnika do tablicy, CR, na C: CR C RTKPVH F

38. CR CR

39. .'

40. RTKPVH FP

42. CR

43. CEJQYCPKG PKGFGHKPKQYCPG

44. spowodowałaby wypisanie 0 i zachowanie niezdefiniowane (od wypisania przypad- kowej wartości do błędu w czasie wykonania) w momencie drugiego wywołania funkcji RTKPVH. Wskaźnik do tablicy mo e się przydać, kiedy operujemy na tablicy tablic, na przykład C: CR C RTKPVH F FP

45. CR=?

46. CR=? CR

47. RTGEJQFKO[ FQ PCUVúRPGL RQFVCDNKE[

48. RTKPVH F FP

49. CR=?

50. CR=? Ten fragment kodu drukuje: Zobacz te pytanie 6.12. Referencje: ANSI §3.2.2.1 ISO §6.2.2.1 Dynamiczne tworzenie tablic Bliski związek tablic i wskaźników ułatwia symulowanie tablic o rozmiarze określo- nym w czasie działania programu za pomocą wskaźników do dynamicznie przydzielonych obszarów pamięci. 6.14 Pytanie: Jak określić rozmiar tablicy w czasie działania programu? Jak uniknąć tablic o z góry ustalonym rozmiarze? Odpowiedź: Odpowiedniość tablic i wskaźników (zobacz pytanie 6.3) pozwala „sy- mulować” tablice dynamiczne za pomocą wskaźnika do obszaru pamięci, dostarczo- nego przez funkcję OCNNQE. Po wykonaniu:

51. Rozdział 6. ♦ Tablice i wskaźniki 137 KPENWFG UVFNKDJ KPV

52. F[PCTTC[ KPV

53. OCNNQE

54. UKGQH KPV (i je eli wywołanie funkcji OCNNQE się powiedzie) mo esz odwoływać się do F[PCT TC[=K? (dla K od 0 do 9) tak, jakby F[PCTTC[ była zwykłą, statycznie utworzoną tablicą (KPV C=?). Zobacz równie pytania 6.16, 7.28 i 7.29. 6.15 Pytanie: Jak zadeklarować lokalną tablicę o rozmiarze równym tablicy przeka- zanej jako parametr? Odpowiedź: W języku C nie mo na tego zrobić. Rozmiary tablic muszą być znane w czasie kompilacji (Kompilator GNU C dopuszcza mo liwość deklarowania tablic o zmiennym rozmiarze jako rozszerzenie; znalazło się ono równie w standardzie C99). Mo esz u yć funkcji OCNNQE, aby stworzyć „tablicę dynamiczną”, ale pamię- taj o zwolnieniu jej funkcją HTGG . Zobacz te pytania 6.14, 6.16, 6.19, 7.22 i mo e równie 7.32. Referencje: ANSI §3.4, §3.5.4.2 ISO §6.4, §6.5.4.2 6.16 Pytanie: Jak dynamicznie przydzielić pamięć dla tablicy wielowymiarowej? Odpowiedź: W większości przypadków najlepiej stworzyć tablicę7 wskaźników do wskaźników, a następnie ka demu ze wskaźników przypisać adres dynamicznie przydzielonego „wiersza”. Oto przykład dla tablicy dwuwymiarowej: KPENWFG UVFNKDJ KPV

56. CTTC[ KPV

58. OCNNQE PTQYU

59. UKGQH KPV

60. HQT K K PTQYU K CTTC[=K? KPV

61. OCNNQE PEQNWOPU

62. UKGQH KPV W rzeczywistym kodzie nale ałoby oczywiście sprawdzić wszystkie wartości zwró- cone przez funkcję OCNNQE. Je eli nie zamierzasz zmieniać długości wierszy, a za to chciałbyś, aby przydzielony tablicy obszar pamięci był ciągły, wystarczy odrobina arytmetyki na wskaźnikach: KPV

64. CTTC[ KPV

66. OCNNQE PTQYU

67. UKGQH KPV

68. CTTC[=? KPV

69. OCNNQE PTQYU

70. PEQNWOPU

71. UKGQH KPV HQT K K PTQYU K CTTC[=K? CTTC[=? K

72. PEQNWOPU 7 Mówiąc ściśle, nie są to tablice, ale raczej obiekty u ywane jak tablice, zobacz pytanie 6.14.

73. 138 Programowanie w języku C. FAQ W obu przypadkach (to znaczy tablic CTTC[ i CTTC[) tablice dynamiczne mo na in- deksować za pomocą normalnych operatorów: CTTC[Z=K?=L? (dla K 04195 i L 0%1.7/05). Poni szy rysunek przedstawia schematycznie „układ” wierszy w tablicach CTTC[ i CTTC[. Je eli dwa odwołania do pamięci w tym schemacie są z jakichś powodów nie do przy- jęcia8, mo esz zasymulować tablicę dwuwymiarową dynamicznie stworzoną tablicą jednowymiarową: KPV

74. CTTC[ KPV

75. OCNNQE PTQYU

76. PEQNWOPU

77. UKGQH KPV Jednak w takim przypadku obliczanie indeksów musisz wykonywać własnoręcznie. Aby odwołać się do elementu o współrzędnych K,L, nale ałoby u yć wyra enia CT 9 TC[=K

78. PEQNWOPU L? . Takiej tablicy nie mo na jednak przekazać do funkcji, któ- ra akceptuje tablicę wielowymiarową. Zobacz te pytanie 6.19. Mo esz te u yć wskaźników do tablic: KPV

79. CTTC[=0%1.7/05? KPV

80. =0%1.7/05?OCNNQE PTQYU

81. UKGQH

82. CTTC[ 8 Zauwa jednak, e dwukrotne odwołanie do tablicy nie musi być wcale mniej efektywne ni jawne mno enie indeksów. 9 Jawne obliczanie indeksu mo na ukryć w makrodefinicji, na przykład: FGHKPG #TTC[CEEGU C K L C= K

83. PEQNWOPU L?. Jednak wywołanie takiej makrodefinicji, z nawiasami i przecinkami, nie kojarzyłoby się z normalną składnią dostępu do tablic. Makrodefinicja musiałaby mieć równie dostęp do jednego z wymiarów tablicy.

84. Rozdział 6. ♦ Tablice i wskaźniki 139 albo nawet: KPV

85. CTTC[=04195?=0%1.7/05? KPV

86. =04195?=0%1.7/05?OCNNQE UKGQH

87. CTTC[ Jednak składnia odwołania do elementów wskazywanych tablic robi się coraz bardziej skomplikowana (w przypadku CTTC[ trzeba pisać

88. CTTC[=K?=L?). Najwy ej jeden wymiar tablicy mo na określić w czasie działania programu. U ywając tych technik, nie mo na oczywiście zapomnieć o zwolnieniu przydzielonej pamięci, kiedy nie jest ju potrzebna. W przypadku tablic CTTC[ i CTTC[ wymaga to kilku kroków (zobacz te pytanie 7.23): HQT K K PTQYU K HTGG XQKF

89. CTTC[=K? HTGG XQKF

90. CTTC[ HTGG XQKF

91. CTTC[=? HTGG XQKF

92. CTTC[ Nie mo esz te mieszać tablic przydzielonych dynamicznie ze zwykłymi, utworzo- nymi statycznie (zobacz pytanie 6.20, a tak e 6.18). Powy sze techniki mo na oczywiście rozszerzyć na trzy i więcej wymiarów. Oto „trój- wymiarowa” wersja pierwszego sposobu: KPV

95. CF KPV

98. OCNNQE ZFKO

99. UKGQH KPV

101. HQT K K ZFKO K ] CF=K? KPV

103. OCNNQE [FKO

104. UKGQH KPV

105. HQT L L [FKO L CF=K?=L? KPV

106. OCNNQE FKO

107. UKGQH KPV _ Zobacz te pytanie 20.2. 6.17 Pytanie: Wpadłem na fajny pomysł — je eli napiszę: KPV TGCNCTTC[=? KPV

108. CTTC[ TGCNCTTC[= ? mogę traktować tablicę CTTC[ tak, jakby jej indeksy zaczynały się od 1. Czy to poprawne? Odpowiedź: Chocia taka technika mo e wydawać się atrakcyjna (była nawet u ywana w starszych wydaniach ksią ki Numerical Recipes in C), nie jest zgodna ze Stan- dardem języka C. Arytmetyka wskaźników zdefiniowana jest tylko, je eli wartość wskaźnika pozostaje w obrębie tego samego przydzielonego bloku pamięci albo umownego „końcowego” elementu tu za nim. W przeciwnym wypadku zachowanie programu jest niezdefiniowane, nawet je eli nie następuje dereferencja wskaźnika. Kod w pytaniu oblicza wskaźnik do obszaru przed początkiem tablicy TGCNCTTC[.

109. 140 Programowanie w języku C. FAQ W momencie odejmowania offsetu mo e wystąpić błąd wygenerowania nieprawidło- wego adresu (na przykład gdyby obliczenie adresu spowodowało „zawinięcie” wokół początku segmentu pamięci). Referencje: KR2 §5.3, §5.4, §A7.7 ANSI §3.3.6 ISO §6.3.6 Rationale §3.2.2.3 Funkcje a tablice wielowymiarowe Trudno jest przekazywać tablice wielowymiarowe do funkcji z zachowaniem pełnej ogólności. Podmiana parametrów tablicowych na wskaźniki (zobacz pytanie 6.4) oznacza, e funkcja, która akceptuje zwykłe tablice, mo e równie przyjmować tablice o dowolnej długości, co jest wygodne. Jednak podmiana dotyczy tylko najbardziej „zewnętrznej” tablicy, pozostałe wymiary nie mogą być zmienne. Problem ten wynika z faktu, e w języku C wymiary tablic muszą być zawsze znane w czasie kompilacji. Nie mo na ich określić, przekazując na przykład dodatkowy parametr. 6.18 Pytanie: Mój kompilator zgłasza błędy, kiedy przekazuję tablicę dwuwymiarową do funkcji przyjmującej wskaźnik do wskaźnika. Dlaczego? Odpowiedź: Zasada (zobacz pytanie 6.3), na mocy której tablice „degenerują” się do wskaźników, nie działa rekurencyjnie. Tablica dwuwymiarowa (czyli w języku C tablica tablic) staje się wskaźnikiem do tablicy, nie wskaźnikiem do wskaźnika. Wskaź- niki do tablic powodują du o nieporozumień, dlatego nale y ich u ywać ostro nie. Zobacz pytanie 6.13 (nieporozumienia wzmaga fakt, e istnieją kompilatory, w tym stare wersje REE i oparte na nich wersje programu NKPV, które niepoprawnie pozwalają przypisywać wielowymiarowe tablice do wskaźników na wskaźniki). Je eli przekazujesz dwuwymiarową tablicę do funkcji: KPV CTTC[=04195?=0%1.7/05? H CTTC[ jej deklaracja musi mieć postać: H KPV C=?=0%1.7/05? ] _ albo: H KPV

110. CR=0%1.7/05?

111. CR VQ YUMC PKM PC VCDNKEú

112. ] _

113. Rozdział 6. ♦ Tablice i wskaźniki 141 W przypadku pierwszej deklaracji kompilator wykonuje podmianę typu parametru z „tablicy tablic” na „wskaźnik do tablicy” (zobacz pytania 6.3 i 6.4). W drugiej deklaracji jawnie określamy typ jako wskaźnik do tablicy. Poniewa wywoływana funkcja nie przydziela pamięci dla tablicy, nie musi znać jej obu wymiarów — liczba wierszy, 04195, mo e zostać pominięta w deklaracji. „Kształt” tablicy jest jednak wcią wa ny, więc wymiar 0%1.7/05 (i wszystkie kolejne w przypadku tablic wielowymiarowych) musi zostać wyspecyfikowany. Je eli deklaracja funkcji wskazuje, e oczekuje ona wskaźnika do wskaźnika, naj- prawdopodobniej nie mo na przekazać jej tablicy dwuwymiarowej bezpośrednio. Mo- e być wtedy potrzebny pomocniczy wskaźnik: GZVGTP I KPV

115. KRR KPV

116. KR CTTC[=?=? I KR

117. $;ç /1 ' .'

118. Taki sposób wywołania jest jednak mylący i prawie na pewno nieprawidłowy. Tabli- ca została „spłaszczona” — straciliśmy informację o jej szerokości. Zobacz te pytania 6.12 i 6.15. Referencje: KR1 §5.10 KR2 §5.9 HS §5.4.3 6.19 Pytanie: Jak tworzyć funkcje, które przyjmują tablice dwuwymiarowe, je eli nie znam ich „szerokości” w czasie kompilacji? Odpowiedź: To nie jest łatwe. Jednym ze sposobów jest przekazanie wskaźnika do elementu o indeksach =?=? wraz z obydwoma wymiarami i „ręczne” obliczanie in- deksów: H KPV

119. CT[R KPV PTQYU KPV PEQNWOPU ] CT[R=K

120. PEQNWOPU L?

121. QFYQ CPKG FQ GNGOGPVW CTTC[=K?=L?

122. _ Aby jawnie obliczyć indeks elementu, potrzebujemy wartości PEQNWOPU („szerokości” ka dego wiersza), nie PTQYU (liczby wierszy). Łatwo się tu pomylić. Funkcji tej mo na przekazać tablicę CTTC[ z pytania 6.18 w następujący sposób: H CTTC[=?=? 04195 0%1.7/05 Trzeba jednak zauwa yć, e program, w którym indeksy w tablicy wielowymiarowej obliczane są „ręcznie”, nie jest ściśle zgodny ze Standardem ANSI języka C. Zgodnie z oficjalną interpretacją, dostęp do elementu CTTC[=?=?=Z? jest niezdefiniowany, je eli Z 0%1.7/05.

123. 142 Programowanie w języku C. FAQ Kompilator GNU C pozwala definiować lokalne tablice o rozmiarach ustalonych przez argumenty funkcji, mo liwość ta pojawiła się te w Standardzie C99. Je eli chcesz stworzyć funkcję, która przyjmować będzie tablice wielowymiarowe o ró nych rozmiarach, jednym z rozwiązań jest dynamiczne symulowanie takich tablic, jak w pytaniu 6.16. Zobacz te pytania 6.15, 6.18 i 6.20. Referencje: ANSI §3.3.6 ISO §6.3.6 6.20 Pytanie: Jak korzystać jednocześnie z wielowymiarowych tablic przydzielanych statycznie i dynamicznie przy przekazywaniu ich do funkcji? Odpowiedź: Nie ma jednej, uniwersalnej metody. Mając deklaracje: KPV CTTC[=04195?=0%1.7/05? KPV

125. CTTC[

126. MC F[ YKGTU QUQDPQ

127. KPV

129. CTTC[

130. EKæI [ QDUCT RCOKúEK

131. KPV

132. CTTC[

133. VCDNKEC UR CUEQPC

134. KPV

135. CTTC[=0%1.7/05? KPV

136. CTTC[=04195?=0%1.7/05? gdzie wskaźniki są zainicjalizowane tak, jak w pytaniu 6.16, i funkcje, zadeklarowane jako: H KPV C=?=0%1.7/05? KPV PTQYU KPV PEQNWOPU H KPV

137. CT[R KPV PTQYU KPV PEQNWOPU H KPV

139. RR KPV PTQYU KPV PEQNWOPU gdzie funkcja H akceptuje „zwykłą” tablicę dwuwymiarową, funkcja H — „spłasz- czoną” tablicę dwuwymiarową, a funkcja H — tablicę symulowaną przez wskaźnik do wskaźnika (zobacz pytania 6.18 i 6.19), poni sze wywołania funkcji działają zgodnie z oczekiwaniami: H CTTC[ 04195 0%1.7/05 H CTTC[ PTQYU 0%1.7/05 H

140. CTTC[ 04195 0%1.7/05 H CTTC[=?=? 04195 0%1.7/05 H

141. CTTC[ 04195 0%1.7/05 H

142. CTTC[ PTQYU PEQNWOPU H CTTC[ PTQYU PEQNWOPU H

143. CTTC[ PTQYU 0%1.7/05 H

145. CTTC[ 04195 0%1.7/05 H CTTC[ PTQYU PEQNWOPU H CTTC[ PTQYU PEQNWOPU

146. Rozdział 6. ♦ Tablice i wskaźniki 143 Poni sze dwa wywołania powinny działać prawidłowo na większości systemów, ale wymagają „podejrzanych” rzutowań i działają tylko, je eli dynamiczna wartość PEQ NWOPU równa jest statycznej 0%1.7/05: H KPV

147. =0%1.7/05?

148. CTTC[ PTQYU PEQNWOPU H KPV

149. =0%1.7/05?CTTC[ PTQYU PEQNWOPU Z wy ej wymienionych tylko funkcja H mo e przyjmować tablice statyczne i przy- dzielone dynamicznie, chocia nie będzie działać dla tradycyjnej implementacji CTTC[, czyli „ka dy wiersz osobno”. Pamiętaj jednak, e przekazywanie CTTC[=?=? (albo

150. CTTC[) do funkcji H nie jest ściśle zgodne ze Standardem — zobacz pytanie 6.19. Je eli rozumiesz, dlaczego wszystkie wy ej wymienione sposoby przekazywania tablic wielowymiarowych do funkcji działają oraz dlaczego kombinacje, których tu nie przed- stawiono, nie działają, mo esz uznać, e bardzo dobrze rozumiesz tablice i wskaźniki w języku C. Zamiast jednak zaprzątać sobie głowę tymi wszystkimi trudnymi regułami, mo esz zastosować du o prostsze rozwiązanie: wszystkie tablice wielowymiarowe twórz dynamicznie, jak w pytaniu 6.16. Je eli nie będzie statycznych tablic wielowymiarowych — wszystkie będą przydzielane jak CTTC[ lub CTTC[ w pytaniu 6.16 — wtedy wszystkie funkcje mogą mieć deklaracje podobne do H. Rozmiary tablic Operator UKGQH zwraca rozmiar tablicy, ale tylko wtedy, gdy jest on znany, a odniesienie do tablicy nie zredukowało się do wskaźnika. 6.21 Pytanie: Dlaczego operator UKGQH nie zwraca poprawnego rozmiaru tablicy, która jest parametrem funkcji? Moja testowa funkcja wypisuje 4, zamiast 10: H EJCT C=? ] KPV K UKGQH C RTKPVH FP K _ Odpowiedź: Kompilator podmienia typ parametru z tablicy na wskaźnik (w tym przypadku EJCT

151. , zobacz pytanie 6.4). Operator UKGQH zwraca w tym wypadku rozmiar wskaźnika. Zobacz te pytania 1.24 i 7.28. Referencje: HS §7.5.2

152. 144 Programowanie w języku C. FAQ 6.22 Pytanie: Jak kod w pliku, w którym tablica zadeklarowana jest jako GZVGTP (jest zdefiniowana i jej rozmiar jest określony w innym pliku), mo e określić jej wiel- kość? Operator UKGQH nie działa na niej. Odpowiedź: Zobacz pytanie 1.24. 6.23 Pytanie: Jak mogę określić liczbę elementów tablicy, je eli operator UKGQH zwraca rozmiar w bajtach? Odpowiedź: Po prostu podziel rozmiar całej tablicy przez rozmiar jednego elementu: KPV CTTC[=? ] _ KPV PCTTC[ UKGQH CTTC[ UKGQH CTTC[=? Referencje: ANSI §3.3.3.4 ISO §6.3.3.4

Programowanie w języku C. FAQ

More Related Content

What's hot (20)

Viewers also liked (13)

Similar to Programowanie w języku C. FAQ (20)

More from Wydawnictwo Helion (20)

Programowanie w języku C. FAQ