Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00528 010303 11040438 na godz. na dobę w sumie
Język C. Szkoła programowania. Wydanie V - książka
Język C. Szkoła programowania. Wydanie V - książka
Autor: Liczba stron: 976
Wydawca: Helion Język publikacji: polski
ISBN: 83-246-0291-7 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> c - programowanie
Porównaj ceny (książka, ebook, audiobook).

Kompletne omówienie najnowszego standardu języka C

'Język C. Szkoła programowania. Wydanie V' jest uaktualnioną wersją bestsellerowej książki wydanej pod tym samym tytułem w roku 1999 nakładem wydawnictwa Robomatic. Podręcznik ten w czytelny sposób prezentuje kolejne tematy, ilustrując je przykładowymi programami. Każdy rozdział kończą pytania sprawdzające wraz z odpowiedziami oraz zadania programistyczne.

W książce znajdziemy pełny opis standardu (C99) języka C, w tym m.in. szczegółową charakterystykę:

Autor nie ogranicza się do opisu instrukcji języka C. Ujawnia także techniki efektywnego programowania oraz przedstawia wybrane algorytmy i struktury danych.

Potwierdzeniem jakości książki jest sukces, jaki odniosła w Stanach Zjednoczonych -- pięć wydań i ponad 400 tys. sprzedanych egzemplarzy. Na rynku amerykańskim zaliczana jest już do klasyki.

Znajdź podobne książki Ostatnio czytane w tej kategorii

Darmowy fragment publikacji:

IDZ DO IDZ DO PRZYK£ADOWY ROZDZIA£ PRZYK£ADOWY ROZDZIA£ SPIS TREœCI SPIS TREœCI KATALOG KSI¥¯EK KATALOG KSI¥¯EK KATALOG ONLINE KATALOG ONLINE ZAMÓW DRUKOWANY KATALOG ZAMÓW DRUKOWANY KATALOG TWÓJ KOSZYK TWÓJ KOSZYK DODAJ DO KOSZYKA DODAJ DO KOSZYKA CENNIK I INFORMACJE CENNIK I INFORMACJE ZAMÓW INFORMACJE ZAMÓW INFORMACJE O NOWOœCIACH O NOWOœCIACH ZAMÓW CENNIK ZAMÓW CENNIK CZYTELNIA CZYTELNIA FRAGMENTY KSI¥¯EK ONLINE FRAGMENTY KSI¥¯EK ONLINE Jêzyk C. Szko³a programowania. Wydanie V Autor: Stephen Prata T³umaczenie: Tomasz Szynalski, Grzegorz Joszcz ISBN: 83-246-0291-7 Tytu³ orygina³u: C Primer Plus (5th Edition) Format: B5, stron: 976 „Jêzyk C. Szko³a programowania. Wydanie V” jest uaktualnion¹ wersj¹ bestsellerowej ksi¹¿ki wydanej pod tym samym tytu³em w roku 1999 nak³adem wydawnictwa Robomatic. Podrêcznik ten w czytelny sposób prezentuje kolejne tematy, ilustruj¹c je przyk³adowymi programami. Ka¿dy rozdzia³ koñcz¹ pytania sprawdzaj¹ce wraz z odpowiedziami oraz zadania programistyczne. W ksi¹¿ce znajdziemy pe³ny opis standardu (C99) jêzyka C, w tym m.in. szczegó³ow¹ charakterystykê: (cid:129) rozszerzonych typów ca³kowitych i zbiorów znaków, (cid:129) tablic o zmiennej d³ugoœci (VLA), (cid:129) z³o¿onych litera³ów, (cid:129) rozszerzonych zbiorów znaków oraz typów logicznych, (cid:129) funkcji wplatanych (inline), (cid:129) inicjalizatorów oznaczonych struktur. Autor nie ogranicza siê do opisu instrukcji jêzyka C. Ujawnia tak¿e techniki efektywnego programowania oraz przedstawia wybrane algorytmy i struktury danych. Potwierdzeniem jakoœci ksi¹¿ki jest sukces, jaki odnios³a w Stanach Zjednoczonych — piêæ wydañ i ponad 400 tys. sprzedanych egzemplarzy. Na rynku amerykañskim zaliczana jest ju¿ do klasyki. Wydawnictwo Helion ul. Koœciuszki 1c 44-100 Gliwice tel. 032 230 98 63 e-mail: helion@helion.pl SPIS TREŚCI 5 SPIS TREŚCI Przedmowa ....................................................................................................................................... 19 O autorze .......................................................................................................................................... 21 Rozdział 1. Zaczynamy .................................................................................................................. 23 Skąd C? .................................................................................................................................. 23 Dlaczego C? .......................................................................................................................... 24 Cechy użytkowe ................................................................................................. 25 Efektywność ....................................................................................................... 25 Przenośność ........................................................................................................ 25 Moc i elastyczność ............................................................................................. 25 Ukierunkowanie na programistę ....................................................................... 26 Słabe strony ........................................................................................................ 26 Dokąd zmierza C? ............................................................................................................... 26 Co robią komputery? .......................................................................................................... 28 Języki wysokiego poziomu i kompilatory ....................................................................... 29 Korzystanie z C: siedem kroków ...................................................................................... 29 Krok 1: określenie celów programu ................................................................... 30 Krok 2: projektowanie programu ....................................................................... 30 Krok 3: pisanie kodu .......................................................................................... 31 Krok 4: kompilacja ............................................................................................. 31 Krok 5: uruchomienie programu ....................................................................... 32 Krok 6: testowanie i usuwanie błędów ............................................................. 32 Krok 7: „Pielęgnowanie” i modyfikacja programu ............................................ 33 Komentarz .......................................................................................................... 33 Mechanika programowania ............................................................................................... 33 Pliki kodu obiektowego, pliki wykonywalne i biblioteki ................................. 34 UNIX ................................................................................................................... 36 Linux ................................................................................................................... 38 Zintegrowane środowiska programistyczne (Windows) .................................. 38 Kompilatory DOS-owe dla komputerów IBM PC ............................................. 40 Język C a Macintosh ........................................................................................... 40 6 JĘZYK C. SZKOŁA PROGRAMOWANIA Standardy języka ................................................................................................................. 40 Standard ANSI/ISO C ......................................................................................... 41 Standard C99 ...................................................................................................... 42 Jak zorganizowano tę książkę ........................................................................................... 43 Metody zapisu ...................................................................................................................... 43 Czcionka ............................................................................................................. 43 Tekst na ekranie ................................................................................................. 43 Podsumowanie rozdziału .................................................................................................. 45 Pytania sprawdzające ......................................................................................................... 45 Ćwiczenie .............................................................................................................................. 45 Rozdział 2. Wstęp do C .................................................................................................................. 47 Prosty przykład języka C ................................................................................................... 47 Objaśnienie ........................................................................................................................... 48 Podejście 1: szybkie streszczenie ...................................................................... 48 Podejście 2: szczegóły ........................................................................................ 50 Budowa prostego programu .............................................................................................. 59 Jak uczynić Twój program czytelnym? ............................................................................ 60 Kolejny krok ......................................................................................................................... 60 Dokumentacja ..................................................................................................... 61 Wielokrotne deklaracje ...................................................................................... 61 Mnożenie ............................................................................................................ 61 Wyświetlanie wielu wartości ............................................................................. 62 Wiele funkcji ......................................................................................................................... 62 Usuwanie błędów ................................................................................................................ 64 Błędy składniowe ............................................................................................... 64 Błędy semantyczne ............................................................................................ 65 Stan programu .................................................................................................... 67 Słowa kluczowe ................................................................................................................... 67 Kluczowe zagadnienia ........................................................................................................ 68 Podsumowanie rozdziału .................................................................................................. 69 Pytania sprawdzające ......................................................................................................... 69 Ćwiczenia .............................................................................................................................. 70 Rozdział 3. Dane w C ..................................................................................................................... 73 Program przykładowy ........................................................................................................ 74 Co nowego? ......................................................................................................... 75 Zmienne i stałe ..................................................................................................................... 76 Słowa kluczowe typów danych ........................................................................................ 76 Typy całkowite a typy zmiennoprzecinkowe ................................................... 77 Liczba całkowita ................................................................................................. 78 Liczba zmiennoprzecinkowa ............................................................................. 79 Typy danych w C ................................................................................................................ 80 Typ int ................................................................................................................ 80 Inne typy całkowite ............................................................................................ 84 Korzystanie ze znaków: typ char ....................................................................... 89 SPIS TREŚCI 7 Typ _Bool ............................................................................................................ 95 Typy przenaszalne: inttypes.h ........................................................................... 96 Typy float, double i long double ....................................................................... 98 Typy zespolone i urojone ................................................................................. 103 Inne typy ........................................................................................................... 103 Rozmiary typów ............................................................................................... 105 Korzystanie z typów danych ........................................................................................... 107 Uwaga na argumenty ....................................................................................................... 107 Jeszcze jeden przykład ..................................................................................................... 109 Co się dzieje ...................................................................................................... 110 Potencjalny problem ........................................................................................ 111 Kluczowe zagadnienia ...................................................................................................... 111 Podsumowanie rozdziału ................................................................................................ 112 Pytania sprawdzające ....................................................................................................... 113 Ćwiczenia ............................................................................................................................ 115 Rozdział 4. Łańcuchy znakowe i formatowane wejście/wyjście ........................................... 117 Na początek... program .................................................................................................... 118 Łańcuchy znakowe: wprowadzenie .............................................................................. 119 Tablice typu char i znak zerowy ..................................................................... 119 Korzystanie z łańcuchów ................................................................................. 120 Funkcja strlen() ................................................................................................ 121 Stałe i preprocesor C ......................................................................................................... 123 Modyfikator const ............................................................................................ 127 Stałe standardowe ............................................................................................ 127 Poznać i wykorzystać printf() i scanf() ........................................................................... 129 Funkcja printf() ................................................................................................ 130 Korzystanie z printf() ....................................................................................... 130 Modyfikatory specyfikatorów konwersji dla printf() ...................................... 132 Znaczenie konwersji ........................................................................................ 138 Korzystanie z funkcji scanf() ........................................................................... 144 Modyfikator * w funkcjach printf() i scanf() ................................................... 150 Praktyczne wskazówki ..................................................................................................... 151 Kluczowe zagadnienia ...................................................................................................... 152 Podsumowanie rozdziału ................................................................................................ 153 Pytania sprawdzające ....................................................................................................... 154 Ćwiczenia ............................................................................................................................ 156 Rozdział 5. Operatory, wyrażenia i instrukcje ......................................................................... 159 Wstęp do pętli .................................................................................................................... 160 Podstawowe operatory ..................................................................................................... 162 Operator przypisania: = .................................................................................. 162 Operator dodawania: + .................................................................................... 164 Operator odejmowania: - ................................................................................. 165 Operatory znaku: - i + ..................................................................................... 165 8 JĘZYK C. SZKOŁA PROGRAMOWANIA Operator mnożenia: * ....................................................................................... 166 Operator dzielenia: / ......................................................................................... 168 Priorytet operatorów ........................................................................................ 169 Priorytet i kolejność obliczeń .......................................................................... 171 Niektóre inne operatory ................................................................................................... 172 Operator sizeof i typ size_t .............................................................................. 172 Operator modulo: ......................................................................................... 173 Operatory inkrementacji i dekrementacji: ++ i -- ......................................... 175 Dekrementacja -- .............................................................................................. 179 Priorytet ............................................................................................................ 180 Nie próbuj być zbyt sprytny ............................................................................ 181 Wyrażenia i instrukcje ...................................................................................................... 182 Wyrażenia ......................................................................................................... 182 Instrukcje .......................................................................................................... 183 Instrukcje złożone (bloki) ................................................................................ 186 Konwersje typów .............................................................................................................. 188 Operator rzutowania ........................................................................................ 190 Funkcje z argumentami .................................................................................................... 192 Przykładowy program ...................................................................................................... 194 Zagadnienia kluczowe ...................................................................................................... 195 Podsumowanie rozdziału ................................................................................................ 196 Pytania sprawdzające ....................................................................................................... 197 Ćwiczenia ............................................................................................................................ 200 Rozdział 6. Instrukcje sterujące C: Pętle .................................................................................... 203 Przykład .............................................................................................................................. 204 Komentarz ........................................................................................................ 205 Pętla odczytująca w stylu C ............................................................................. 207 Instrukcja while ................................................................................................................. 207 Zakończenie pętli while ................................................................................... 208 Kiedy kończy się pętla? .................................................................................... 208 while jako pętla z warunkiem wejścia ............................................................ 209 Wskazówki dotyczące składni ......................................................................... 210 Co jest większe: korzystanie z operatorów i wyrażeń relacyjnych ........................... 211 Czym jest prawda? ........................................................................................... 213 Co jeszcze jest prawdą? .................................................................................... 214 Problemy z prawdą .......................................................................................... 215 Nowy typ _Bool ................................................................................................ 218 Priorytet operatorów relacyjnych .................................................................... 219 Pętle nieokreślone i pętle liczące ..................................................................................... 221 Pętla for ............................................................................................................................... 222 Elastyczność pętli for ....................................................................................... 224 Inne operatory przypisania: +=, -=, *=, /=, = ....................................................... 228 Operator przecinkowy: , .................................................................................................. 229 Zenon z Elei kontra pętla for ........................................................................... 231 SPIS TREŚCI 9 Pętla z warunkiem wyjścia: do while ............................................................................. 233 Której pętli użyć? ............................................................................................................... 236 Pętle zagnieżdżone ........................................................................................................... 237 Omówienie ....................................................................................................... 238 Inny wariant ..................................................................................................... 238 Tablice .................................................................................................................................. 239 Współpraca tablicy i pętli for .......................................................................... 240 Przykład wykorzystujący pętlę i wartość zwracaną przez funkcję .......................... 242 Omówienie programu ...................................................................................... 245 Korzystanie z funkcji zwracających wartości ................................................. 246 Zagadnienia kluczowe ...................................................................................................... 246 Podsumowanie rozdziału ................................................................................................ 247 Pytania sprawdzające ....................................................................................................... 248 Ćwiczenia ............................................................................................................................ 252 Rozdział 7. Instrukcje sterujące C: Rozgałęzienia i skoki ....................................................... 257 Instrukcja if ......................................................................................................................... 258 Dodajemy else .................................................................................................................... 260 Kolejny przykład: funkcje getchar() i putchar() .............................................. 262 Rodzina funkcji znakowych ctype.h ............................................................... 264 Wybór spośród wielu możliwości: else if ....................................................... 266 Łączenie else z if .............................................................................................. 269 Więcej o zagnieżdżonych instrukcjach if ........................................................ 271 Bądźmy logiczni ................................................................................................................ 275 Zapis alternatywny: plik nagłówkowy iso646.h ............................................. 277 Priorytet ............................................................................................................ 277 Kolejność obliczeń ........................................................................................... 278 Zakresy ............................................................................................................. 279 Program liczący słowa ...................................................................................................... 280 Operator warunkowy: ?: .................................................................................................. 284 Dodatki do pętli: continue i break .................................................................................. 286 Instrukcja continue .......................................................................................... 286 Instrukcja break ................................................................................................ 289 Wybór spośród wielu możliwości: switch i break ........................................................ 291 Korzystanie z instrukcji switch ....................................................................... 293 Pobieranie tylko pierwszego znaku w wierszu ............................................... 294 Etykiety wielokrotne ........................................................................................ 295 Switch a if else ................................................................................................. 298 Instrukcja goto ................................................................................................................... 298 Unikanie goto ................................................................................................... 298 Zagadnienia kluczowe ...................................................................................................... 301 Podsumowanie rozdziału ................................................................................................ 302 Pytania sprawdzające ....................................................................................................... 303 Ćwiczenia ............................................................................................................................ 306 10 JĘZYK C. SZKOŁA PROGRAMOWANIA Rozdział 8. Znakowe wejście/wyjście i przekierowywanie ................................................... 309 Jednoznakowe we/wy: getchar() i putchar() ................................................................. 310 Bufory .................................................................................................................................. 311 Kończenie danych wprowadzanych z klawiatury ...................................................... 313 Pliki, strumienie i dane wprowadzane z klawiatury ...................................... 313 Koniec pliku ..................................................................................................... 314 Przekierowywanie a pliki ................................................................................................. 317 Przekierowywanie w systemach UNIX, Linux i DOS .................................... 318 Tworzenie przyjaźniejszego interfejsu użytkownika ................................................. 322 Współpraca z buforowanym wejściem ........................................................... 322 Łączenie wejścia liczbowego i znakowego ..................................................... 325 Sprawdzanie poprawności danych wejściowych ........................................... 328 Analiza programu ............................................................................................. 332 Strumienie wejściowe a liczby ........................................................................ 333 Menu .................................................................................................................................... 334 Zadania ............................................................................................................. 334 W kierunku sprawnego działania .................................................................... 335 Łączenie danych znakowych i numerycznych ............................................... 337 Zagadnienia kluczowe ...................................................................................................... 340 Podsumowanie rozdziału ................................................................................................ 340 Pytania sprawdzające ....................................................................................................... 341 Ćwiczenia ............................................................................................................................ 342 Rozdział 9. Funkcje ....................................................................................................................... 345 Przypomnienie ................................................................................................................... 345 Tworzenie i korzystanie z prostej funkcji ....................................................... 347 Analiza programu ............................................................................................. 347 Argumenty funkcji ........................................................................................... 350 Definiowanie funkcji pobierającej argument: argumenty formalne .............. 351 Prototyp funkcji pobierającej argumenty ........................................................ 352 Wywoływanie funkcji pobierającej argumenty: argumenty faktyczne .......... 353 Punkt widzenia czarnej skrzynki .................................................................... 354 Zwracanie wartości przy pomocy instrukcji return ....................................... 354 Typy funkcji ..................................................................................................... 357 Prototypy ANSI C .............................................................................................................. 358 Problem ............................................................................................................. 359 ANSI na ratunek! ............................................................................................. 360 Brak argumentów a argumenty nieokreślone ................................................. 361 Potęga prototypów ............................................................................................................ 362 Rekurencja .......................................................................................................................... 362 Rekurencja bez tajemnic .................................................................................. 363 Podstawy rekurencji ......................................................................................... 364 Rekurencja końcowa ........................................................................................ 365 Rekurencja i odwracanie kolejności działań ................................................... 367 Za i przeciw rekurencji .................................................................................... 369 SPIS TREŚCI 11 Kompilowanie programów zawierających więcej niż jedną funkcję ....................... 371 UNIX ................................................................................................................. 371 Linux ................................................................................................................. 371 DOS (kompilatory wiersza poleceń) ................................................................ 372 Kompilatory Windows i Macintosh ................................................................ 372 Korzystanie z plików nagłówkowych .............................................................. 372 Uzyskiwanie adresów: operator ................................................................................. 376 Modyfikacja zmiennych w funkcji wywołującej ......................................................... 377 Wskaźniki: pierwsze spojrzenie ...................................................................................... 379 Operator dereferencji: * ................................................................................... 380 Deklarowanie wskaźników .............................................................................. 381 Wykorzystanie wskaźników do komunikacji pomiędzy funkcjami .............. 382 Kluczowe zagadnienia ...................................................................................................... 386 Podsumowanie rozdziału ................................................................................................ 387 Pytania sprawdzające ....................................................................................................... 387 Ćwiczenia ............................................................................................................................ 388 Rozdział 10. Tablice i wskaźniki ................................................................................................. 391 Tablice .................................................................................................................................. 391 Inicjalizacja ......................................................................................................................... 392 Użycie const z tablicami .................................................................................. 393 Uwaga o klasach zmiennych ........................................................................... 394 Oznaczona inicjalizacja (C99) ......................................................................... 397 Przypisywanie wartości do tablic .................................................................... 398 Zakres tablic ..................................................................................................... 398 Określanie rozmiaru tablicy ............................................................................ 400 Tablice wielowymiarowe ................................................................................................. 401 Inicjalizacja tablicy dwuwymiarowej ............................................................................. 404 Więcej wymiarów ............................................................................................. 405 Wskaźniki do tablic ........................................................................................................... 405 Funkcje, tablice i wskaźniki ............................................................................................. 408 Korzystanie z argumentów wskaźnikowych ................................................... 411 Komentarz: wskaźniki i tablice ....................................................................... 414 Działania na wskaźnikach ................................................................................................ 414 Ochrona zawartości tablicy .............................................................................................. 419 Zastosowanie słowa kluczowego const w parametrach formalnych ............. 420 Więcej o const .................................................................................................. 421 Wskaźniki a tablice wielowymiarowe ............................................................................ 423 Wskaźniki do tablic wielowymiarowych ........................................................ 426 Zgodność wskaźników ..................................................................................... 428 Funkcje a tablice wielowymiarowe ................................................................. 429 Tablice o zmiennym rozmiarze (VLA, ang. variable — length array) ........... 433 Złożone literały ................................................................................................ 437 12 JĘZYK C. SZKOŁA PROGRAMOWANIA Zagadnienia kluczowe ...................................................................................................... 439 Podsumowanie rozdziału ................................................................................................ 440 Pytania sprawdzające ....................................................................................................... 441 Ćwiczenia ............................................................................................................................ 443 Rozdział 11. Łańcuchy znakowe i funkcje łańcuchowe ......................................................... 447 Reprezentacja łańcuchów i łańcuchowe wejście/wyjście .............................. 447 Definiowanie łańcuchów ................................................................................................. 449 Stałe łańcuchowe ............................................................................................. 449 Tablice łańcuchów i inicjalizacja .................................................................... 450 Tablica a wskaźnik ........................................................................................... 452 Tablice łańcuchów znakowych ....................................................................... 455 Wskaźniki a łańcuchy ...................................................................................... 456 Wczytywanie łańcuchów ................................................................................................. 458 Tworzenie miejsca ........................................................................................... 458 Funkcja gets() ................................................................................................... 459 Funkcja fgets() .................................................................................................. 461 Funkcja scanf() ................................................................................................. 462 Wyświetlanie łańcuchów ................................................................................................. 464 Funkcja puts() ................................................................................................... 464 Funkcja fputs() ................................................................................................. 465 Funkcja printf() ................................................................................................ 466 Zrób to sam ......................................................................................................................... 466 Funkcje łańcuchowe ......................................................................................................... 469 Funkcja strlen() ................................................................................................ 469 Funkcja strcat() ................................................................................................. 471 Funkcja strncat() ............................................................................................... 472 Funkcja strcmp() .............................................................................................. 473 Funkcje strcpy() i strncpy() .............................................................................. 478 Funkcja sprintf() ............................................................................................... 483 Inne funkcje łańcuchowe ................................................................................. 484 Przykład użycia: sortowanie łańcuchów ....................................................................... 486 Sortowanie wskaźników zamiast łańcuchów ................................................. 487 Algorytm sortowania przez selekcję ................................................................ 488 Łańcuchy a funkcje znakowe z rodziny ctype.h .......................................................... 489 Argumenty wiersza poleceń ............................................................................................ 491 Argumenty wiersza poleceń w środowiskach zintegrowanych ..................... 493 Argumenty linii poleceń w systemie Macintosh ............................................ 493 Konwersja łańcuchów do liczb ........................................................................................ 494 Zagadnienia kluczowe ...................................................................................................... 497 Podsumowanie rozdziału ................................................................................................ 497 Pytania sprawdzające ....................................................................................................... 498 Ćwiczenia ............................................................................................................................ 501 SPIS TREŚCI 13 Rozdział 12. Klasy zmiennej, łączność i zarządzanie pamięcią ............................................. 503 Klasy zmiennych ............................................................................................................... 503 Zasięg zmiennej ................................................................................................ 504 Łączność zmiennej ........................................................................................... 506 Czas trwania zmiennej ..................................................................................... 507 Zmienne automatyczne ................................................................................... 507 Zmienne rejestrowe .......................................................................................... 512 Zmienne statyczne o zasięgu blokowym ........................................................ 513 Zmienne statyczne o łączności zewnętrznej ................................................... 514 Zmienne statyczne o łączności wewnętrznej ................................................. 519 Programy wieloplikowe ................................................................................... 520 Specyfikatory klasy zmiennych ....................................................................... 521 Klasy zmiennych a funkcje .............................................................................................. 524 Którą klasę wybrać? ......................................................................................... 524 Funkcje pseudolosowe i zmienne statyczne ................................................................. 525 Rzut kostką ......................................................................................................................... 528 Przydział pamięci: funkcje malloc() i free() ................................................................... 532 Znaczenie funkcji free() ................................................................................... 536 Funkcja calloc() ................................................................................................ 537 Dynamiczny przydział pamięci a tablice o zmiennym rozmiarze ................. 538 Klasy zmiennych a dynamiczny przydział pamięci ....................................... 539 Kwalifikatory typu ANSI C .............................................................................................. 540 Kwalifikator typu const .................................................................................... 540 Kwalifikator typu volatile ................................................................................ 543 Kwalifikator typu restrict ................................................................................. 544 Stare słowa kluczowe w nowych miejscach ................................................... 545 Kluczowe zagadnienia ..................................................................................... 546 Podsumowanie rozdziału ................................................................................................ 547 Pytania sprawdzające ....................................................................................................... 548 Ćwiczenia ............................................................................................................................ 550 Rozdział 13. Obsługa plików ....................................................................................................... 553 Wymiana informacji z plikami ........................................................................................ 553 Czym jest plik? ................................................................................................. 554 Poziomy wejścia/wyjścia .................................................................................. 555 Pliki standardowe ............................................................................................. 556 Standardowe wejście/wyjście .......................................................................................... 556 Sprawdzanie argumentów wiersza poleceń .................................................... 557 Funkcja fopen() ................................................................................................ 558 Funkcje getc() i putc() ...................................................................................... 559 Znak końca pliku EOF (ang. end of file) ......................................................... 560 Funkcja fclose() ................................................................................................ 561 Wskaźniki do plików standardowych ............................................................. 562 14 JĘZYK C. SZKOŁA PROGRAMOWANIA Niewyszukany program kompresujący pliki ............................................................... 562 Plikowe wejście/wyjście: fprintf(), fscanf(), fgets() i fputs() ........................................ 564 Funkcje fprintf() i fscanf() ................................................................................ 564 Funkcje fgets()i fputs() ..................................................................................... 565 Przygody z dostępem swobodnym: fseek() i ftell() ..................................................... 568 Jak działają funkcje fseek() i ftell()? ................................................................. 569 Tryb binarny a tryb tekstowy .......................................................................... 571 Przenośność ...................................................................................................... 571 Funkcje fgetpos() i fsetpos() ............................................................................. 572 Za kulisami standardowego wejścia/wyjścia ................................................................ 573 Inne standardowe funkcje wejścia/wyjścia ................................................................... 574 Funkcja int ungetc(int c, FILE *fp) .................................................................. 574 Funkcja int fflush() ........................................................................................... 574 Funkcja int setvbuf() ........................................................................................ 575 Binarne wejście/wyjście: fread() i fwrite() ....................................................... 575 Funkcja size_t fwrite ........................................................................................ 577 Funkcja size_t fread(void *ptr, size_t size, size_t nmemb, FILE *fp) ............ 578 Funkcje int feof(FILE *fp) oraz int ferror(FILE *fp) ....................................... 578 Przykład ............................................................................................................ 578 Dostęp swobodny w binarnym wejściu/wyjściu ............................................ 581 Zagadnienia kluczowe ...................................................................................................... 583 Podsumowanie rozdziału ................................................................................................ 583 Pytania sprawdzające ....................................................................................................... 584 Ćwiczenia ............................................................................................................................ 586 Rozdział 14. Struktury i inne formy danych ............................................................................ 589 Przykładowy problem: tworzenie spisu książek .......................................................... 590 Deklaracja struktury .......................................................................................................... 591 Definiowanie zmiennej strukturalnej ............................................................................ 592 Inicjalizacja struktury ...................................................................................... 593 Uzyskiwanie dostępu do składników struktury .......................................................... 594 Inicjalizatory oznaczone struktur .................................................................... 595 Tablice struktur .................................................................................................................. 596 Deklarowanie tablicy struktur ......................................................................... 598 Wskazywanie składników tablicy struktur ..................................................... 599 Szczegóły programu ......................................................................................... 599 Struktury zagnieżdżone ................................................................................................... 600 Wskaźniki do struktur ...................................................................................................... 602 Deklaracja i inicjalizacja wskaźnika do struktury .......................................... 603 Dostęp do składników za pomocą wskaźnika ................................................. 604 Struktury a funkcje ............................................................................................................ 604 Przekazywanie składników struktur ............................................................... 605 Korzystanie z adresu struktury ........................................................................ 606 Przekazywanie struktury jako argumentu ...................................................... 607 Więcej o nowym, ulepszonym statusie struktury ........................................... 607 Struktury czy wskaźniki do struktur? ............................................................. 611 SPIS TREŚCI 15 Tablice znakowe lub wskaźniki do znaków w strukturze ............................. 612 Struktury, wskaźniki i funkcja malloc() .......................................................... 613 Literały złożone i struktury (C99) ................................................................... 615 Elastyczne składniki tablicowe (C99) ............................................................. 617 Funkcje korzystające z tablic struktur ............................................................ 619 Zapisywanie zawartości struktury w pliku ................................................................... 620 Omówienie programu ...................................................................................... 624 Struktury: co dalej? ........................................................................................................... 625 Unie: szybkie spojrzenie ................................................................................................... 625 Typy wyliczeniowe ........................................................................................................... 628 Stałe enum ........................................................................................................ 629 Wartości domyślne ........................................................................................... 630 Przypisywane wartości .................................................................................... 630 Użycie enum ..................................................................................................... 630 Współdzielona przestrzeń nazw ...................................................................... 632 typedef: szybkie spojrzenie ............................................................................................. 632 Udziwnione deklaracje ..................................................................................................... 635 Funkcje a wskaźniki .......................................................................................................... 637 Kluczowe zagadnienia ...................................................................................................... 644 Podsumowanie rozdziału ................................................................................................ 644 Pytania sprawdzające ....................................................................................................... 645 Ćwiczenia ............................................................................................................................ 648 Rozdział 15. Manipulowanie bitami .......................................................................................... 653 Liczby binarne, bity i bajty ............................................................................................... 654 Binarne liczby całkowite ................................................................................. 654 Liczby całkowite ze znakiem ........................................................................... 655 Binarne liczby zmiennoprzecinkowe .............................................................. 656 Inne systemy liczbowe ...................................................................................................... 657 System ósemkowy ............................................................................................ 657 System szesnastkowy ....................................................................................... 657 Operatory bitowe .............................................................................................................. 659 Bitowe operatory logiczne ............................................................................... 659 Zastosowanie: maski ........................................................................................ 660 Zastosowanie: włączanie bitów ....................................................................... 661 Zastosowanie: wyłączanie bitów ..................................................................... 662 Zastosowanie: odwracanie bitów .................................................................... 662 Zastosowanie: sprawdzenie wartości bitu ...................................................... 663 Bitowe operatory przesunięcia ........................................................................ 663 Przykład ............................................................................................................ 665 Kolejny przykład .............................................................................................. 666 Pola bitowe ......................................................................................................................... 668 Przykład ............................................................................................................ 670 Pola bitowe a operatory bitowe ....................................................................... 673 16 JĘZYK C. SZKOŁA PROGRAMOWANIA Kluczowe zagadnienia ...................................................................................................... 680 Podsumowanie rozdziału ................................................................................................ 680 Pytania sprawdzające ....................................................................................................... 681 Ćwiczenia ............................................................................................................................ 683 Rozdział 16. Preprocesor i biblioteka C ..................................................................................... 685 Pierwsze kroki w translacji programu ............................................................. 686 Stałe symboliczne: #define .............................................................................................. 687 Żetony ............................................................................................................... 691 Przedefiniowywanie stałych ............................................................................ 691 #define i argumenty ......................................................................................................... 692 Argumenty makr w łańcuchach ...................................................................... 695 Łącznik preprocesora: operator ## ................................................................. 696 Makra o zmiennej liczbie argumentów: ... i __VA_ARGS__ .......................... 697 Makro czy funkcja? ........................................................................................................... 698 Dołączanie plików: #include .......................................................................................... 699 Pliki nagłówkowe: przykład ............................................................................ 700 Zastosowania plików nagłówkowych ............................................................. 702 Inne dyrektywy ................................................................................................................. 704 Dyrektywa #undef ........................................................................................... 704 Zdefiniowany: z perspektywy preprocesora C ............................................... 705 Kompilacja warunkowa ................................................................................... 705 Makra predefiniowane ..................................................................................... 710 #line i #error ................................................................................................... 711 #pragma ........................................................................................................... 712 Funkcje wplatane (inline) ................................................................................ 713 Biblioteka języka C ............................................................................................................ 715 Uzyskiwanie dostępu do biblioteki C ............................................................. 716 Korzystanie z opisów funkcji ........................................................................... 716 Biblioteka funkcji matematycznych ............................................................................... 718 Biblioteka narzędzi ogólnego użytku ............................................................................. 720 Funkcje exit() i atexit() ..................................................................................... 721 Funkcja qsort() .................................................................................................. 723 Korzystanie z funkcji qsort() ............................................................................ 725 Definicja funkcji porownaj() ............................................................................ 726 Biblioteka assert.h .............................................................................................................. 728 Funkcje memcpy() i memmove() z biblioteki string.h ................................... 729 Zmienna liczba argumentów: stdarg.h .......................................................................... 731 Zagadnienie kluczowe ..................................................................................... 734 Podsumowanie rozdziału ................................................................................................ 734 Pytania sprawdzające ....................................................................................................... 735 Ćwiczenia ............................................................................................................................ 736 Rozdział 17. Zaawansowana reprezentacja danych ............................................................... 739 Poznajemy reprezentację danych ................................................................................... 740 Listy łączone ..................................................................................................... 743 Abstrakcyjne typy danych (ATD) .................................................................... 751 SPIS TREŚCI 17 Kolejki .................................................................................................................................. 767 Definicja kolejki jako abstrakcyjnego typu danych ........................................ 767 Symulowanie za pomocą kolejki ..................................................................... 778 Lista łączona czy tablica? ................................................................................. 784 Drzewa binarne ................................................................................................ 788 Co dalej? ........................................................................................................... 812 Zagadnienia kluczowe ..................................................................................... 813 Podsumowanie rozdziału ................................................................................................ 813 Pytania sprawdzające ....................................................................................................... 814 Ćwiczenia ......................................................................................................... 815 Dodatek A Odpowiedzi na pytania sprawdzające .................................................................. 817 Dodatek B Podsumowanie .......................................................................................................... 855 I. Lektura uzupełniająca.................................................................................................... 855 II. Operatory w języku C................................................................................................... 859 III. Podstawowe typy i klasy zmiennych........................................................................ 865 IV. Wyrażenia, instrukcje i przepływ sterowania w programie................................ 870 V. Standardowa biblioteka ANSI C oraz rozszerzenia standardu C99...................... 876 VI. Rozszerzone typy całkowite....................................................................................... 922 VII. Obsługa rozszerzonych zbiorów znaków............................................................... 926 VIII. Efektywniejsze obliczenia numeryczne w standardzie C99 .............................. 932 IX. Różnice między C a C++ ........................................................................................... 936 Skorowidz ...................................................................................................................................... 943 12 KLASY ZMIENNEJ, ŁĄCZNOŚĆ I ZARZĄDZANIE PAMIĘCIĄ W tym rozdziale poznasz: (cid:122) Słowa kluczowe: auto, extern, static, register, const, volatile, restrict (cid:122) Funkcje: rand(), srand(), time(), malloc(), calloc(), free() (cid:122) Sposób, w jaki język C pozwala decydować o zasięgu zmiennej, (czyli określić jej dostępność w poszczególnych miejscach w programie) i jej czasie trwania, (czyli jak długo będzie ona istnieć) (cid:122) Metody projektowania bardziej złożonych programów J edną z mocnych stron języka C jest to, że pozwala on na kon
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Język C. Szkoła programowania. Wydanie V
Autor:

Opinie na temat publikacji:


Inne popularne pozycje z tej kategorii:


Czytaj również:


Prowadzisz stronę lub blog? Wstaw link do fragmentu tej książki i współpracuj z Cyfroteką: