» » » Język C. Kompendium wiedzy. Wydanie IV
Język C. Kompendium wiedzy. Wydanie IV
Super promocja

Język C. Kompendium wiedzy. Wydanie IV

Dostępność: Dostępny

Czas wysyłki: 24 godziny

Koszt wysyłki: od 12,00 zł Dostępne formy wysyłki dla oglądanego produktu:Przesyłka pocztowa Kurier48 - 12,00 zł
Kurier GLS - 18,50 zł
Odbiór osobisty - 0,00 zł

Stan magazynowy:

Cena internetowa: 72,00 zł

Cena poprzednia: 79,00 zł

Cena katalogowa: 79,01 zł

Oszczędzasz: 7,01 zł

Ilość: szt.
Dodaj do koszyka

dodaj do schowka

  • Opis produktu
  • Recenzje produktu (0)

 

„Zdecydowanie najlepsza książka dla każdego, kto chce nauczyć się programować w C. Jest to doskonały podręcznik, świetnie napisany i bogaty w przykłady...  Z tej książki uczyłem się języka C — jest naprawdę doskonała.”

— Vinit S. Carpenter, Learn C/C++ Today

Kompletny przewodnik po języku C!

Język programowania C stworzył Dennis Ritchie. Opracował go w laboratoriach AT&T Bell na początku lat 70. XX wieku. Musiała jednak upłynąć jeszcze niemal dekada, by język ten zyskał popularność i powszechne uznanie — dopiero w 1990 roku opublikowano pierwszą oficjalną wersję standardu ANSI C. Później przez długi czas był to język dominujący na rynku i do tej pory nie ma sobie równych w wielu dziedzinach programowania.

Kolejne wydanie kultowej książki o języku C zostało zaktualizowane i poprawione. Znajdziesz tu informacje na temat najnowszych dodatków, wprowadzonych w standardzie ANSI C11, a także sprawdzone, konkretne wiadomości na temat składni języka i najlepszych praktyk tworzenia programów z wykorzystaniem potencjału C. Pętle, instrukcje warunkowe, struktury, wskaźniki, operacje bitowe oraz polecenia preprocesora to klasyczne zagadnienia — bez ich znajomości żaden programista nie może sobie poradzić. Jeżeli szukasz kompletnego podręcznika zawierającego najbardziej aktualne informacje na temat języka C, trzymasz w rękach idealną książkę!

Dzięki tej książce:
  • napiszesz, skompilujesz i uruchomisz swój pierwszy program
  • poznasz typy danych oraz ich cechy charakterystyczne
  • opanujesz składnię oraz typowe konstrukcje języka C
  • zaznajomisz się z tablicami oraz strukturami
  • poskromisz wskaźniki oraz ulepszysz zarządzanie pamięcią
  • opanujesz język C

Wykorzystaj potencjał języka C!



Stephen G. Kochan — autor i współautor klasycznych książek o programowaniu oraz o systemie Unix. Były konsultant ds. oprogramowania w AT&T Bell Laboratories. Do jego obowiązków należało m.in. przygotowywanie i prowadzenie kursów z systemu Unix oraz języka C. Jest autorytetem w swojej specjalizacji.

Spis treści:

 

O autorze (13)

Wprowadzenie (15)

Rozdział 1. Podstawy (19)

  • Programowanie (19)
  • Języki wysokiego poziomu (20)
  • Systemy operacyjne (20)
  • Kompilowanie programów (21)
  • Zintegrowane środowiska programistyczne (23)
  • Interpretery (24)

Rozdział 2. Kompilujemy i uruchamiamy pierwszy program (25)

  • Kompilujemy nasz program (26)
  • Uruchamianie programu (26)
  • Analiza naszego pierwszego programu (27)
  • Wyświetlanie wartości zmiennych (29)
  • Komentarze (31)
  • Ćwiczenia (32)

Rozdział 3. Zmienne, typy danych i wyrażenia arytmetyczne (35)

  • Typy danych i stałe (35)
    • Podstawowy typ danych int (36)
    • Typ zmiennoprzecinkowy float (37)
    • Rozszerzony typ double (37)
    • Pojedyncze znaki, typ char (38)
    • Logiczny typ danych, _Bool (38)
    • Określniki typu: long, long long, short, unsigned i signed (40)
  • Użycie zmiennych (42)
  • Wyrażenia arytmetyczne (44)
    • Arytmetyka liczb całkowitych i jednoargumentowy operator minus (46)
  • Łączenie działań z przypisaniem (51)
  • Typy _Complex i _Imaginary (52)
  • Ćwiczenia (53)

Rozdział 4. Pętle w programach (55)

  • Liczby trójkątne (55)
  • Instrukcja for (56)
    • Operatory porównania (58)
    • Wyrównywanie wyników (62)
    • Dane wejściowe dla programu (62)
    • Zagnieżdżone pętle for (64)
    • Odmiany pętli for (66)
  • Instrukcja while (67)
  • Instrukcja do (71)
    • Instrukcja break (72)
    • Instrukcja continue (72)
  • Ćwiczenia (73)

Rozdział 5. Podejmowanie decyzji (75)

  • Instrukcja if (75)
    • Konstrukcja if-else (79)
    • Złożone warunki porównania (81)
    • Zagnieżdżone instrukcje if (83)
    • Konstrukcja else if (85)
  • Instrukcja switch (91)
  • Zmienne logiczne (94)
  • Operator wyboru (98)
  • Ćwiczenia (99)

Rozdział 6. Tablice (101)

  • Definiowanie tablicy (102)
    • Użycie tablic jako liczników (106)
    • Generowanie ciągu Fibonacciego (108)
    • Zastosowanie tablic do generowania liczb pierwszych (109)
  • Inicjalizowanie tablic (111)
  • Tablice znakowe (112)
    • Użycie tablic do zamiany podstawy liczb (113)
    • Kwalifikator const (115)
  • Tablice wielowymiarowe (117)
  • Tablice o zmiennej wielkości (119)
  • Ćwiczenia (121)

Rozdział 7. Funkcje (123)

  • Definiowanie funkcji (123)
  • Parametry i zmienne lokalne (126)
    • Deklaracja prototypu funkcji (127)
    • Automatyczne zmienne lokalne (128)
  • Zwracanie wyników funkcji (129)
  • Nic, tylko wywoływanie i wywoływanie... (133)
    • Deklarowanie zwracanych typów, typy argumentów (136)
    • Sprawdzanie parametrów funkcji (138)
  • Programowanie z góry na dół (139)
  • Funkcje i tablice (140)
    • Operatory przypisania (143)
    • Sortowanie tablic (145)
    • Tablice wielowymiarowe (147)
  • Zmienne globalne (152)
  • Zmienne automatyczne i statyczne (155)
  • Funkcje rekurencyjne (158)
  • Ćwiczenia (160)

Rozdział 8. Struktury (163)

  • Podstawowe wiadomości o strukturach (163)
  • Struktura na daty (164)
    • Użycie struktur w wyrażeniach (166)
  • Funkcje i struktury (168)
    • Struktura na czas (173)
  • Inicjalizowanie struktur (176)
    • Literały złożone (177)
  • Tablice struktur (178)
  • Struktury zawierające inne struktury (181)
  • Struktury zawierające tablice (182)
  • Wersje struktur (185)
  • Ćwiczenia (186)

Rozdział 9. Łańcuchy znakowe (189)

  • Rozszerzenie wiadomości o łańcuchach (189)
  • Tablice znaków (190)
  • Łańcuchy znakowe zmiennej długości (192)
    • Inicjalizowanie i pokazywanie tablic znakowych (194)
    • Porównywanie dwóch łańcuchów znakowych (197)
    • Wprowadzanie łańcuchów znakowych (199)
    • Wczytanie pojedynczego znaku (201)
    • Łańcuch pusty (205)
  • Cytowanie znaków (208)
  • Jeszcze o stałych łańcuchach (210)
  • Łańcuchy znakowe, struktury i tablice (211)
    • Lepsza metoda szukania (214)
  • Operacje na znakach (218)
  • Ćwiczenia (221)

Rozdział 10. Wskaźniki (225)

  • Wskaźniki i przekierowania (225)
  • Definiowanie zmiennej wskaźnikowej (226)
  • Wskaźniki w wyrażeniach (229)
  • Wskaźniki i struktury (230)
    • Struktury zawierające wskaźniki (233)
    • Listy powiązane (234)
  • Słowo kluczowe const a wskaźniki (241)
  • Wskaźniki i funkcje (243)
  • Wskaźniki i tablice (247)
    • Parę słów o optymalizacji programu (251)
    • To tablica czy wskaźnik? (251)
    • Wskaźniki na łańcuchy znakowe (253)
    • Stałe łańcuchy znakowe a wskaźniki (254)
    • Jeszcze raz o inkrementacji i dekrementacji (256)
  • Operacje na wskaźnikach (258)
  • Wskaźniki na funkcje (260)
  • Wskaźniki a adresy w pamięci (261)
  • Ćwiczenia (262)

Rozdział 11. Operacje bitowe (265)

  • Podstawowe wiadomości o bitach (265)
  • Operatory bitowe (266)
    • Bitowy operator AND (267)
    • Bitowy operator OR (269)
    • Bitowy operator OR wyłączającego (270)
    • Operator negacji bitowej (271)
    • Operator przesunięcia w lewo (273)
    • Operator przesunięcia w prawo (273)
    • Funkcja przesuwająca (274)
    • Rotowanie bitów (275)
  • Pola bitowe (278)
  • Ćwiczenia (281)

Rozdział 12. Preprocesor (283)

  • Dyrektywa #define (283)
    • Rozszerzalność programu (287)
    • Przenośność programu (288)
    • Bardziej złożone definicje (289)
    • Operator # (294)
    • Operator ## (295)
  • Dyrektywa #include (296)
    • Systemowe pliki włączane (298)
  • Kompilacja warunkowa (298)
    • Dyrektywy #ifdef, #endif, #else i #ifndef (298)
    • Dyrektywy preprocesora #if i #elif (300)
    • Dyrektywa #undef (301)
  • Ćwiczenia (302)

Rozdział 13. Jeszcze o typach danych - wyliczenia, definicje typów oraz konwersje typów (303)

  • Wyliczeniowe typy danych (303)
  • Instrukcja typedef (306)
  • Konwersje typów danych (309)
    • Znak wartości (310)
    • Konwersja parametrów (311)
  • Ćwiczenia (312)

Rozdział 14. Praca z większymi programami (313)

  • Dzielenie programu na wiele plików (313)
    • Kompilowanie wielu plików z wiersza poleceń (314)
  • Komunikacja między modułami (316)
    • Zmienne zewnętrzne (316)
    • Static a extern: porównanie zmiennych i funkcji (319)
    • Wykorzystanie plików nagłówkowych (320)
  • Inne narzędzia służące do pracy z dużymi programami (322)
    • Narzędzie make (322)
    • Narzędzie cvs (324)
    • Narzędzia systemu Unix (324)

Rozdział 15. Operacje wejścia i wyjścia w języku C (327)

  • Wejście i wyjście znakowe: funkcje getchar i putchar (328)
  • Formatowanie wejścia i wyjścia: funkcje printf i scanf (328)
    • Funkcja printf (328)
    • Funkcja scanf (335)
  • Operacje wejścia i wyjścia na plikach (339)
    • Przekierowanie wejścia-wyjścia do pliku (339)
    • Koniec pliku (342)
  • Funkcje specjalne do obsługi plików (343)
    • Funkcja fopen (343)
    • Funkcje getc i putc (345)
    • Funkcja fclose (345)
    • Funkcja feof (347)
    • Funkcje fprintf i fscanf (347)
    • Funkcje fgets i fputs (348)
    • Wskaźniki stdin, stdout i stderr (348)
    • Funkcja exit (349)
    • Zmiana nazw i usuwanie plików (350)
  • Ćwiczenia (351)

Rozdział 16. Rozmaitości, techniki zaawansowane (353)

  • Pozostałe instrukcje języka (353)
    • Instrukcja goto (353)
    • Instrukcja pusta (354)
  • Użycie unii (355)
  • Przecinek jako operator (357)
  • Kwalifikatory typu (358)
    • Kwalifikator register (358)
    • Kwalifikator volatile (359)
    • Kwalifikator restrict (359)
  • Parametry wiersza poleceń (360)
  • Dynamiczna alokacja pamięci (363)
    • Funkcje calloc i malloc (364)
    • Operator sizeof (364)
    • Funkcja free (367)
  • Ćwiczenia (368)

Rozdział 17. Usuwanie błędów z programów (369)

  • Usuwanie błędów za pomocą preprocesora (369)
  • Usuwanie błędów przy użyciu programu gdb (375)
    • Użycie zmiennych (377)
    • Pokazywanie plików źródłowych (379)
    • Kontrola nad wykonywaniem programu (379)
    • Uzyskiwanie śladu stosu (383)
    • Wywoływanie funkcji, ustawianie tablic i zmiennych (384)
    • Uzyskiwanie informacji o poleceniach gdb (384)
    • Na koniec (386)

Rozdział 18. Programowanie obiektowe (389)

  • Czym zatem jest obiekt? (389)
  • Instancje i metody (390)
  • Program w C do obsługi ułamków (392)
  • Klasa Objective-C obsługująca ułamki (392)
  • Klasa C++ obsługująca ułamki (397)
  • Klasa C# obsługująca ułamki (399)

Dodatek A. Język C w skrócie (403)

  • 1.0. Dwuznaki i identyfikatory (403)
  • 2.0. Komentarze (404)
  • 3.0. Stałe (405)
  • 4.0. Typy danych i deklaracje (408)
  • 5.0. Wyrażenia (417)
  • 6.0. Klasy zmiennych i zakres (430)
  • 7.0. Funkcje (432)
  • 8.0. Instrukcje (434)
  • 9.0. Preprocesor (438)

Dodatek B. Standardowa biblioteka C (445)

  • Standardowe pliki nagłówkowe (445)
  • Funkcje obsługujące łańcuchy znakowe (448)
  • Obsługa pamięci (450)
  • Funkcje obsługi znaków (451)
  • Funkcje wejścia i wyjścia (452)
  • Funkcje formatujące dane w pamięci (457)
  • Konwersja łańcucha na liczbę (458)
  • Dynamiczna alokacja pamięci (459)
  • Funkcje matematyczne (460)
    • Arytmetyka zespolona (466)
  • Funkcje ogólnego przeznaczenia (468)

Dodatek C. Kompilator gcc (471)

  • Ogólna postać polecenia (471)
  • Opcje wiersza poleceń (471)

Dodatek D. Typowe błędy (475)

Dodatek E. Zasoby (481)

  • Język programowania C (481)
  • Kompilatory C i zintegrowane środowiska programistyczne (482)
  • Różne (483)

Skorowidz (485)

Nikt jeszcze nie napisał recenzji do tego produktu. Bądź pierwszy i napisz recenzję.

Napisz recenzję

Pozostałe produkty z kategorii