Czysty_kod_w_C_17_Oprogramowanie_latwe_w_utrzymaniu_czkc17.pdf

(1741 KB) Pobierz
Tytuł oryginału: Clean C++: Sustainable Software Development Patterns and Best Practices with C++ 17
Tłumaczenie: Tomasz Walczak
ISBN: 978-83-283-4340-5
Original edition copyright © 2017 by Stephan Roth.
All rights reserved.
Polish edition copyright © 2018 by HELION SA.
All rights reserved.
All rights reserved. No part of this book may be reproduced or transmitted in any form or by any means,
electronic or mechanical, including photocopying, recording or by any information storage retrieval system,
without permission from the Publisher.
Wszelkie prawa zastrzeżone. Nieautoryzowane rozpowszechnianie całości lub fragmentu niniejszej
publikacji w jakiejkolwiek postaci jest zabronione. Wykonywanie kopii metodą kserograficzną,
fotograficzną, a także kopiowanie książki na nośniku filmowym, magnetycznym lub innym powoduje
naruszenie praw autorskich niniejszej publikacji.
Wszystkie znaki występujące w tekście są zastrzeżonymi znakami firmowymi bądź towarowymi ich
właścicieli.
Autor oraz Wydawnictwo HELION dołożyli wszelkich starań, by zawarte w tej książce informacje były
kompletne i rzetelne. Nie biorą jednak żadnej odpowiedzialności ani za ich wykorzystanie, ani za związane
z tym ewentualne naruszenie praw patentowych lub autorskich. Autor oraz Wydawnictwo HELION nie
ponoszą również żadnej odpowiedzialności za ewentualne szkody wynikłe z wykorzystania informacji
zawartych w książce.
Wydawnictwo HELION
ul. Kościuszki 1c, 44-100 GLIWICE
tel. 32 231 22 19, 32 230 98 63
e-mail:
helion@helion.pl
WWW:
http://helion.pl
(księgarnia internetowa, katalog książek)
Pliki z przykładami omawianymi w książce można znaleźć pod adresem:
ftp://ftp.helion.pl/przyklady/czkc17.zip
Drogi Czytelniku!
Jeżeli chcesz ocenić tę książkę, zajrzyj pod adres
http://helion.pl/user/opinie/czkc17
Możesz tam wpisać swoje uwagi, spostrzeżenia, recenzję.
Printed in Poland.
•
Kup książkę
•
Poleć książkę
•
Oceń książkę
•
Księgarnia internetowa
•
Lubię to! » Nasza społeczność
Spis tre ci
O autorze .................................................................................................................9
O recenzencie technicznym ....................................................................................11
Podzi kowania ......................................................................................................13
Rozdzia 1
Wprowadzenie ......................................................................................................15
Entropia oprogramowania ..................................................................................................................16
Czysty kod .............................................................................................................................................17
Dlaczego C++? ......................................................................................................................................18
C++11 — początek nowej ery .............................................................................................................18
Dla kogo przeznaczona jest ta książka? .............................................................................................19
Konwencje stosowane w tej książce ...................................................................................................19
Ramki ..............................................................................................................................................20
Uwagi, wskazówki i ostrzeżenia ..................................................................................................20
Przykładowy kod ...........................................................................................................................20
Witryna książki i repozytorium z kodem źródłowym ....................................................................21
Diagramy UML-a .................................................................................................................................21
Rozdzia 2
Tworzenie siatki bezpiecze stwa ..........................................................................23
Konieczność przeprowadzania testów ..............................................................................................23
Wprowadzenie do testów ....................................................................................................................25
Testy jednostkowe ................................................................................................................................26
A co z kontrolą jakości? .......................................................................................................................28
Reguły tworzenia dobrych testów jednostkowych ..........................................................................29
Jakość kodu testów ........................................................................................................................29
Nazwy testów jednostkowych ......................................................................................................29
Niezależność testów jednostkowych ...........................................................................................31
Jedna asercja na test ......................................................................................................................31
Niezależne inicjowanie środowisk testów jednostkowych ......................................................32
Pomijanie testów getterów i setterów .........................................................................................32
Pomijanie testów kodu innych programistów ..........................................................................32
Pomijanie testów zewnętrznych systemów ...............................................................................33
A co zrobić z bazą danych? ..........................................................................................................33
Kup książkę
Poleć książkę
CZYSTY KOD W C++17. OPROGRAMOWANIE ATWE W UTRZYMANIU
Nie łącz kodu testów z kodem produkcyjnym ..........................................................................33
Testy muszą działać szybko .........................................................................................................36
Zaślepki ...........................................................................................................................................36
Rozdzia 3
Post puj zgodnie z zasadami ................................................................................39
Czym są zasady? ...................................................................................................................................39
Zachowaj prostotę, głupku (KISS) .....................................................................................................40
Nie będziesz tego potrzebować (YAGNI) .........................................................................................40
Nie powtarzaj się (DRY) ......................................................................................................................41
Ukrywanie informacji ..........................................................................................................................41
Wysoka spójność ..................................................................................................................................44
Luźne powiązanie .................................................................................................................................46
Nie przesadzaj z optymalizacją ...........................................................................................................49
Zasada minimalizowania zaskoczenia ...............................................................................................50
Reguła harcerza .....................................................................................................................................50
Rozdzia 4
Podstawy czystego C++ ......................................................................................53
Dobre nazwy .........................................................................................................................................54
Nazwy powinny być oczywiste ....................................................................................................55
Stosuj nazwy z dziedziny ..............................................................................................................56
Dobieraj nazwy na odpowiednim poziomie abstrakcji ...........................................................57
Unikaj nadmiarowości, gdy wymyślasz nazwę .........................................................................58
Unikaj zagadkowych skrótów ......................................................................................................58
Unikaj notacji węgierskiej i przedrostków .................................................................................59
Unikaj używania tej samej nazwy do różnych celów ...............................................................60
Komentarze ...........................................................................................................................................60
Niech kod opowiada historię .......................................................................................................60
Nie komentuj oczywistych rzeczy ...............................................................................................61
Nie dezaktywuj kodu za pomocą komentarzy ..........................................................................61
Nie pisz komentarzy blokowych .................................................................................................62
Rzadkie scenariusze, w których komentarze są przydatne ......................................................64
Funkcje ...................................................................................................................................................67
Jedna rzecz — nie więcej! .............................................................................................................70
Twórz małe funkcje .......................................................................................................................70
Nazwy funkcji ................................................................................................................................71
Stosuj nazwy opisujące intencje ..................................................................................................72
Argumenty i zwracane wartości ..................................................................................................72
Liczba argumentów .......................................................................................................................73
Projekty C++ w dawnym stylu specyficznym dla C ........................................................................82
Przedkładaj łańcuchy znaków i strumienie z C++
nad dawne łańcuchy char* w stylu języka C ...........................................................................82
Unikaj instrukcji printf(), sprintf(), gets() itd. ..........................................................................84
Przedkładaj kontenery z biblioteki standardowej nad proste tablice w stylu języka C .......87
Używanie rzutowania z języka C++ zamiast dawnego rzutowania w stylu języka C ..........89
Unikaj makr ...................................................................................................................................90
Rozdzia 5
Zaawansowane aspekty wspó czesnego C++ .....................................................93
Zarządzanie zasobami ..........................................................................................................................93
Idiom RAII .....................................................................................................................................95
6
Kup książkę
Poleć książkę
SPIS TRE CI
Inteligentne wskaźniki ..................................................................................................................95
Unikanie bezpośrednich wywołań new i delete ......................................................................100
Zarządzanie niezależnymi zasobami ........................................................................................101
Warto się czasem gdzieś przenieść ..................................................................................................102
Czym jest semantyka przenoszenia? .........................................................................................102
Czym są l-wartości i r-wartości? ...............................................................................................103
Referencje do r-wartości .............................................................................................................104
Nie wymuszaj wszędzie semantyki przenoszenia ...................................................................106
Reguła zera ...................................................................................................................................106
Kompilator to Twój współpracownik .............................................................................................110
Automatyczna dedukcja typów .................................................................................................110
Obliczenia na etapie kompilacji ................................................................................................113
Szablony zmiennych ...................................................................................................................115
Nie dopuszczaj do niezdefiniowanych skutków ............................................................................116
Programowanie z użyciem typów semantycznych ........................................................................117
Poznaj używane biblioteki .................................................................................................................123
Korzystaj z pliku nagłówkowego <algorithm> .......................................................................123
Korzystaj z biblioteki Boost .......................................................................................................128
Inne biblioteki, które powinieneś znać ....................................................................................129
Prawidłowa obsługa wyjątków i błędów .........................................................................................130
Lepiej zapobiegać niż leczyć .......................................................................................................130
Wyjątek jest wyjątkiem — dosłownie .......................................................................................134
Jeśli nie możesz przywrócić stanu, szybko zamknij program ...............................................135
Definiuj specyficzne typy wyjątków .........................................................................................135
Zgłaszanie przez wartość i przechwytywanie za pomocą stałej referencji ..........................137
Zwracaj uwagę na właściwą kolejność klauzul catch .............................................................137
Rozdzia 6
Podej cie obiektowe ........................................................................................... 139
Myślenie obiektowe ............................................................................................................................140
Abstrakcja — klucz do opanowania złożoności .............................................................................141
Zasady poprawnego projektowania klas .........................................................................................141
Twórz niewielkie klasy ................................................................................................................141
Zasada jednej odpowiedzialności ..............................................................................................142
Zasada otwarte – zamknięte ......................................................................................................143
Zasada podstawiania Liskov ......................................................................................................144
Zasada podziału interfejsu .........................................................................................................154
Zasada zależności acyklicznych .................................................................................................156
Zasada odwracania zależności ...................................................................................................158
Nie rozmawiaj z nieznajomymi (prawo Demeter) .................................................................162
Unikaj „anemicznych” klas ........................................................................................................166
Mów zamiast pytać ......................................................................................................................167
Unikaj statycznych składowych klasy ......................................................................................169
Rozdzia 7
Programowanie funkcyjne ................................................................................... 171
Czym jest programowanie funkcyjne? ............................................................................................172
Czym jest funkcja? .......................................................................................................................173
Funkcje czyste i „nieczyste” .......................................................................................................174
7
Kup książkę
Poleć książkę

Plik z chomika:

Inne pliki z tego folderu:

Inne foldery tego chomika:

Zgłoś jeśli naruszono regulamin