reklama - zainteresowany?

C++. Kruczki i fortele w programowaniu - Helion

C++. Kruczki i fortele w programowaniu
Autor: Stephen C. Dewhurst
Tytuł oryginału: C++ Gotchas: Avoiding Common Problems in Coding and Design
Tłumaczenie: Tomasz Żmijewski
ISBN: 83-7361-346-3
stron: 272, Format: B5, okładka: miękka
Data wydania: 2003-12-18
Księgarnia: Helion

Cena książki: 29,90 zł

Dodaj do koszyka C++. Kruczki i fortele w programowaniu

Tagi: C++ - Programowanie

"C++. Kruczki i fortele w programowaniu" to pomoc dla zawodowych programistów pozwalająca uniknąć lub poprawić dziewięćdziesiąt dziewięć najczęściej popełnianych i najbardziej szkodliwych błędów projektowych i programowych w C++. Jest to też książka, dzięki której można poznać niektóre niestandardowe cechy języka C++ i techniki programistyczne.

W książce omówiono typowe błędy występujące niemalże we wszystkich programach utworzonych w C++. Każdy z nich został starannie opisany, przedstawiono również konsekwencje wynikające z ich pojawienia się w kodzie programu i szczegółowy opis sposobów na ich uniknięcie. "C++. Kruczki i fortele w programowaniu" to książka o tym, jak uniknąć największych zagrożeń związanych z programowaniem w C++. Gotowa i praktyczna wiedza dla programistów, która pozwoli im uzyskać status ekspertów.

Omówione błędy dotyczą:
  • Podstaw języka C++
  • Składni języka
  • Preprocesora
  • Konwersji
  • Inicjalizacji
  • Zarządzania pamięcią i zasobami
  • Polimorfizmu
  • Projektowania klas
  • Projektowania hierarchii

O autorze:
Stephen C. Dewhurst był jednym z pierwszych użytkowników języka C++ w laboratoriach Bell Labs. Ma ponad dwudziestoletnie doświadczenie w stosowaniu C++ do rozwiązywania problemów w takich dziedzinach, jak projektowanie kompilatorów, zabezpieczanie handlu elektronicznego czy telekomunikacja implementowana na bazie urządzeń wbudowanych [więcej...]

Dodaj do koszyka C++. Kruczki i fortele w programowaniu

Dodaj do koszyka C++. Kruczki i fortele w programowaniu

Spis treści

C++. Kruczki i fortele w programowaniu -- spis treści


Wstęp (9)

Podstawy (13)

  • Zagadnienie 1: nadmiar komentarzy (13)
  • Zagadnienie 2: magiczne liczby (16)
  • Zagadnienie 3: zmienne globalne (17)
  • Zagadnienie 4: nierozróżnianie przeciążenia od inicjalizacji domyślnej (19)
  • Zagadnienie 5: niezrozumienie referencji (21)
  • Zagadnienie 6: niezrozumienie deklaracji const (24)
  • Zagadnienie 7: nieznajomość podstaw języka (25)
  • Zagadnienie 8: nierozróżnianie dostępności i widoczności (29)
  • Zagadnienie 9: błędy językowe (32)
  • Zagadnienie 10: nieznajomość idiomów (34)
  • Zagadnienie 11: zbędna błyskotliwość (37)
  • Zagadnienie 12: dorosłe zachowania (39)

Składnia (41)

  • Zagadnienie 13: pomylenie inicjalizacji z użyciem tablicy (41)
  • Zagadnienie 14: nieokreślona kolejność wartościowania (42)
  • Zagadnienie 15: problemy z priorytetami (47)
  • Zagadnienie 16: przebojowa instrukcja for (49)
  • Zagadnienie 17: problemy największego kęsa (52)
  • Zagadnienie 18: zmiana kolejności elementów deklaracji (53)
  • Zagadnienie 19: nierozróżnianie funkcji i obiektu (55)
  • Zagadnienie 20: migracja kwalifikatorów typu (55)
  • Zagadnienie 21: samoinicjalizacja (56)
  • Zagadnienie 22: typy static i extern (58)
  • Zagadnienie 23: anomalia szukania funkcji operatora (58)
  • Zagadnienie 24: specyfika operatora -> (60)

Preprocesor (63)

  • Zagadnienie 25: literały w #define (63)
  • Zagadnienie 26: pseudofunkcje w #define (65)
  • Zagadnienie 27: nadużywanie #if (68)
  • Zagadnienie 28: efekty uboczne w asercjach (72)

Konwersje (75)

  • Zagadnienie 29: konwersja przez void * (75)
  • Zagadnienie 30: szatkowanie (78)
  • Zagadnienie 31: niezrozumienie konwersji wskaźnika na stałą (80)
  • Zagadnienie 32: niezrozumienie konwersji wskaźnika na wskaźnik na stałą (80)
  • Zagadnienie 33: niezrozumienie konwersji wskaźników wskaźników klas bazowych (84)
  • Zagadnienie 34: problemy ze wskaźnikami tablic wielowymiarowych (84)
  • Zagadnienie 35: niesprawdzone rzutowanie w dół (86)
  • Zagadnienie 36: nieprawidłowe użycie operatorów konwersji (87)
  • Zagadnienie 37: niezamierzona konwersja konstruktora (90)
  • Zagadnienie 38: rzutowanie w przypadku wielokrotnego dziedziczenia (93)
  • Zagadnienie 39: rzutowanie niepełnych typów (94)
  • Zagadnienie 40: rzutowanie w starym stylu (96)
  • Zagadnienie 41: rzutowanie statyczne (97)
  • Zagadnienie 42: inicjalizacja parametrów formalnych tymczasowymi wartościami (99)
  • Zagadnienie 43: czas życia wartości tymczasowych (102)
  • Zagadnienie 44: referencje i obiekty tymczasowe (104)
  • Zagadnienie 45: niejednoznaczność dynamic_cast (107)
  • Zagadnienie 46: niezrozumienie przeciwwariancji (110)

Inicjalizacja (115)

  • Zagadnienie 47: mylenie przypisania i inicjalizacji (115)
  • Zagadnienie 48: nieprawidłowy zasięg zmiennych (118)
  • Zagadnienie 49: niedocenianie operacji kopiowania w C++ (120)
  • Zagadnienie 50: bitowe kopiowanie obiektów (124)
  • Zagadnienie 51: myląca inicjalizacja i przypisania w konstruktorach (126)
  • Zagadnienie 52: zmienna kolejność pól na liście inicjalizacji (128)
  • Zagadnienie 53: inicjalizacja domyślna bazowej klasy wirtualnej (129)
  • Zagadnienie 54: inicjalizacja klasy bazowej konstruktora kopiującego (133)
  • Zagadnienie 55: kolejność inicjalizacji danych statycznych w programie (135)
  • Zagadnienie 56: inicjalizacja bezpośrednia a kopiowanie (137)
  • Zagadnienie 57: bezpośrednia inicjalizacja parametrów (140)
  • Zagadnienie 58: nieznajomość optymalizacji wartości zwracanych (142)
  • Zagadnienie 59: inicjalizacja pola statycznego w konstruktorze (145)

Zarządzanie pamięcią i zasobami (149)

  • Zagadnienie 60: nieodróżnianie alokacji danej typu nietablicowego i tablicy (149)
  • Zagadnienie 61: sprawdzanie alokacji pamięci (152)
  • Zagadnienie 62: zastąpienie globalnych new i delete (154)
  • Zagadnienie 63: mylenie zakresu i wywołanie metod new i delete (157)
  • Zagadnienie 64: wyrzucanie literałów łańcuchowych (158)
  • Zagadnienie 65: nieprawidłowe korzystanie z mechanizmu wyjątków (160)
  • Zagadnienie 66: nadużywanie adresów lokalnych (163)
  • Zagadnienie 67: błąd pozyskania zasobu bierze się z inicjalizacji (167)
  • Zagadnienie 68: nieprawidłowe użycie auto_ptr (171)

Polimorfizm (175)

  • Zagadnienie 69: kody typów (175)
  • Zagadnienie 70: niewirtualny destruktor klasy bazowej (179)
  • Zagadnienie 71: ukrywanie funkcji niewirtualnych (183)
  • Zagadnienie 72: zbyt elastyczne korzystanie z wzorca Template Method (186)
  • Zagadnienie 73: przeciążanie funkcji wirtualnych (187)
  • Zagadnienie 74: funkcje wirtualne z inicjalizacją parametrów domyślnych (188)
  • Zagadnienie 75: funkcje wirtualne w konstruktorach i destruktorach (190)
  • Zagadnienie 76: przypisanie wirtualne (192)
  • Zagadnienie 77: nierozróżnianie przeciążania, nadpisywania i ukrywania (195)
  • Zagadnienie 78: funkcje wirtualne i nadpisywanie (199)
  • Zagadnienie 79: dominacja (204)

Projekt klas (207)

  • Zagadnienie 80: interfejsy get/set (207)
  • Zagadnienie 81: pola stałe i referencje (210)
  • Zagadnienie 82: niezrozumienie metod const (212)
  • Zagadnienie 83: nierozróżnianie agregacji i przypadków użycia (216)
  • Zagadnienie 84: nieprawidłowe przeciążanie operatorów (220)
  • Zagadnienie 85: priorytety a przeciążanie (223)
  • Zagadnienie 86: metody przyjacielskie a operatory (224)
  • Zagadnienie 87: problemy z inkrementacją i dekrementacją (225)
  • Zagadnienie 88: niezrozumienie operacji kopiowania z szablonów (228)

Projekt hierarchii (231)

  • Zagadnienie 89: tablice obiektów (231)
  • Zagadnienie 90: nieprawidłowe używanie kontenerów (233)
  • Zagadnienie 91: niezrozumienie dostępu chronionego (236)
  • Zagadnienie 92: dziedziczenie publiczne metodą wielokrotnego wykorzystania kodu (239)
  • Zagadnienie 93: konkretne publiczne klasy bazowe (243)
  • Zagadnienie 94: użycie zdegenerowanych hierarchii (243)
  • Zagadnienie 95: nadużywanie dziedziczenia (244)
  • Zagadnienie 96: struktury kontrolne działające na podstawie typów (248)
  • Zagadnienie 97: kosmiczne hierarchie (250)
  • Zagadnienie 98: zadawanie obiektowi niedyskretnych pytań (253)
  • Zagadnienie 99: zapytania o możliwości (255)

Bibliografia (259)

Skorowidz (261)

Dodaj do koszyka C++. Kruczki i fortele w programowaniu

Code, Publish & WebDesing by CATALIST.com.pl



(c) 2005-2025 CATALIST agencja interaktywna, znaki firmowe należą do wydawnictwa Helion S.A.