Język C. Szkoła programowania. Wydanie V - Stephen Prata

Uwaga!

Sprzedaż tej ksiażki została zakończona - sprawdź nasze pozostałe pozycje.

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)
• 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)
  • 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)
  • 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)
• 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)

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)
• 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)
• 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)

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)
• 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)
  • 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)
• 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)
• 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)