W_potrzasku_jezyka_C_wpotc.pdf

(310 KB) Pobierz
IDZ DO
PRZYK£ADOWY ROZDZIA£
SPIS TRE CI
KATALOG KSI¥¯EK
KATALOG ONLINE
ZAMÓW DRUKOWANY KATALOG
W potrzasku
jêzyka C
Autor: Andrew Koenig
T³umaczenie: Przemys³aw Szeremiota
ISBN: 83-7361-727-2
Tytu³ orygina³u:
C Traps and Pitfalls
Format: B5, stron: 152
TWÓJ KOSZYK
DODAJ DO KOSZYKA
Ka¿dy, nawet najbardziej do wiadczony programista, pope³nia b³êdy podczas pracy.
Niektóre z nich wynikaj¹ z po piechu, inne — z u¿ycia niew³a ciwych konstrukcji,
operatorów lub typów. Wiêkszo æ z nich mo¿na wykryæ i usun¹æ po kilku minutach
uwa¿nej lektury kodu. Zdarzaj¹ siê jednak i takie b³êdy, których odnalezienie
i skorygowanie zajmuje kilka dni. B³êdy te s¹ z regu³y ³atwe do unikniêcia,
je li zrozumie siê przyczyny ich powstawania.
Ksi¹¿ka „W potrzasku C” zawiera omówienie najczê ciej spotykanych b³êdów
i przyczyn ich powstawania. Nie zawiera ogólników - jej atutem s¹ konkretne,
zaczerpniête z praktyki, przyk³ady. Ka¿dy programista prêdzej czy pó niej natknie siê
na jeden z prezentowanych w ksi¹¿ce b³êdów i, dziêki zawartym w niej wiadomo ciom,
bêdzie w stanie usun¹æ go i unikn¹æ w pó niejszej pracy.
• B³êdy leksykalne i sk³adniowe
• Przepe³nienie zakresu
• Problemy z konsolidacj¹
• W³a ciwe stosowanie funkcji bibliotecznych
• Makrodefinicje
• Przeno no æ kodu
Nie traæ czasu na usuwanie b³êdów — dowiedz siê co robiæ, ¿eby w ogóle nie
wystêpowa³y.
CENNIK I INFORMACJE
ZAMÓW INFORMACJE
O NOWO CIACH
ZAMÓW CENNIK
CZYTELNIA
FRAGMENTY KSI¥¯EK ONLINE
Wydawnictwo Helion
ul. Chopina 6
44-100 Gliwice
tel. (32)230-98-63
e-mail: helion@helion.pl
Spis treści
.
Wstęp ............................................................................................... 7
Wprowadzenie ................................................................................. 11
Rozdział 1. Pułapki leksykalne........................................................................... 15
1.1. Porównanie a przypisanie......................................................................................... 16
1.2. & i | to nie to samo co && i || ................................................................................... 17
1.3. Zachłanność analizatora leksykalnego...................................................................... 18
1.4. Literały stałych całkowitych..................................................................................... 19
1.5. Ciągi a znaki............................................................................................................. 20
Rozdział 2. Pułapki składniowe .......................................................................... 23
2.1. Deklaracje funkcji .................................................................................................... 23
2.2. Priorytety operatorów............................................................................................... 26
2.3. Uwaga na średniki!................................................................................................... 30
2.4. Instrukcja wyboru switch.......................................................................................... 32
2.5. Wywołania funkcji ................................................................................................... 33
2.6. Klauzula else w zagnie d onych instrukcjach if ...................................................... 34
Rozdział 3. Pułapki semantyczne ....................................................................... 37
3.1. Wskaźniki i tablice ................................................................................................... 37
3.2. Wskaźniki nie są tablicami ....................................................................................... 42
3.3. Deklaracje tablic w roli parametrów......................................................................... 43
3.4. Niebezpieczne synekdochy....................................................................................... 45
3.5. Wskaźniki puste a ciągi niepuste.............................................................................. 46
3.6. Zliczanie a asymetryczne granice zakresów ............................................................. 46
3.7. Kolejność obliczania w wyra eniu ........................................................................... 55
3.8. Operatory &&, || i !................................................................................................... 57
3.9. Przepełnienie zakresu liczby całkowitej ................................................................... 58
3.10. Zwracanie wartości przez funkcję main ................................................................... 59
Rozdział 4. Konsolidacja.................................................................................... 63
4.1. Czym jest konsolidator? ........................................................................................... 63
4.2. Deklaracje a definicje ............................................................................................... 65
4.3. Kolizje nazw i słowo static....................................................................................... 66
4.4. Argumenty, parametry i wartości funkcji ................................................................. 67
4.5. Kontrola typów obiektów zewnętrznych .................................................................. 72
4.6. Pliki nagłówkowe ..................................................................................................... 75
6
W potrzasku języka C
Rozdział 5. Funkcje biblioteczne ........................................................................ 77
5.1. Funkcja getchar zwraca wartość typu int.................................................................. 78
5.2. Aktualizacja pliku sekwencyjnego ........................................................................... 78
5.3. Buforowanie wyjścia i przydział pamięci................................................................. 80
5.4. Diagnostyka błędów funkcją errno........................................................................... 81
5.5. Funkcja signal .......................................................................................................... 82
Rozdział 6. Preprocesor ..................................................................................... 85
6.1. Odstępy w makrodefinicjach .................................................................................... 86
6.2. Makrodefinicje a funkcje.......................................................................................... 86
6.3. Makrodefinicje a instrukcje ...................................................................................... 90
6.4. Makrodefinicje a definicje typów ............................................................................. 91
Rozdział 7. Kwestie przenośności ...................................................................... 93
7.1. W obliczu zmian....................................................................................................... 94
7.2. Co z nazwami? ......................................................................................................... 95
7.3. Rozmiar liczby całkowitej ........................................................................................ 96
7.4. Czy znaki mają znaki?.............................................................................................. 97
7.5. Operatory przesunięć bitowych ................................................................................ 98
7.6. Zerowa komórka pamięci ......................................................................................... 99
7.7. Obcinanie przy dzieleniu........................................................................................ 100
7.8. Rozmiar liczby losowej .......................................................................................... 101
7.9. Zamiana wielkości liter .......................................................................................... 102
7.10. Najpierw zwalniać, potem przydzielać ponownie?................................................. 103
7.11. Przykładowe problemy nieprzenośności ................................................................ 104
Rozdział 8. Porady i odpowiedzi do ćwiczeń...................................................... 109
8.1. Porady .................................................................................................................... 110
8.2. Odpowiedzi do ćwiczeń ......................................................................................... 113
Dodatek A Funkcja printf i zmienne listy argumentów ...................................... 129
A.1. Rodzina funkcji printf............................................................................................ 129
A.1.1. Proste specyfikatory formatu........................................................................ 131
A.1.2. Modyfikatory................................................................................................ 135
A.1.3. Znaczniki...................................................................................................... 138
A.1.4. Zmienna precyzja i szerokość pola............................................................... 140
A.1.5. Neologizmy .................................................................................................. 141
A.1.6. Anachronizmy .............................................................................................. 141
A.2. Zmienne listy argumentów — varargs.h................................................................ 142
A.2.1. Implementacja varargs.h............................................................................... 146
A.3. Zmienne listy argumentów w wydaniu ANSI — stdarg.h ..................................... 147
Skorowidz...................................................................................... 149
Rozdział 1.
Pułapki leksykalne
Czytając zdanie, nie zastanawiamy się nad znaczeniem poszczególnych liter, tworzących
kolejne słowa. Litery same w sobie niosą bowiem niewiele treści; grupujemy je więc
w słowa i im przypisujemy znaczenie.
Podobnie jest z programami w języku C i innych językach programowania. Pojedyncze
znaki programu nie znaczą prawie nic, jeśli rozpatrywać je osobno; znaczenia nabierają
dopiero w otoczeniu innych znaków, czyli w pewnym kontekście. Dlatego w wierszu
kodu:
R U
oba wystąpienia znaku
znaczą zupełnie co innego. Mówiąc precyzyjniej, oba znaki wy-
stępują w ró nych elementach leksykalnych: pierwszy jest częścią symbolu
, drugi
częścią ciągu znaków. Dalej, znaczenie elementu leksykalnego
jest całkowicie ró ne
od znaczenia jego poszczególnych znaków.
Pojęcie
symbolu
czy te
elementu leksykalnego
odnosi się do jednostki programu, która
odgrywa w nim mniej więcej taką rolę jak słowo w zdaniu — element leksykalny ma
podobne znaczenie wszędzie, gdzie występuje. Identyczna sekwencja znaków mo e
w jednym kontekście nale eć do jednego elementu leksykalnego, a w innym — do
zupełnie innego. Mechanizm kompilatora, który jest odpowiedzialny za podział tekstu
programu na elementy leksykalne, nosi często nazwę
analizatora leksykalnego.
Rozwa my następującą instrukcję:
KH
Z
DKI DKI Z
Pierwszym elementem tej instrukcji jest słowo
KH
. Następnym jest znak otwierający
nawias, dalej mamy identyfikator
Z
, symbol relacji większości, identyfikator
DKI
itd.
W języku C pomiędzy elementy leksykalne mo emy wstawiać dowolną liczbę znaków
odstępów (spacji, tabulatorów i znaków nowego wiersza), więc instrukcję tę moglibyśmy
zapisać równie tak:
KH
Z
16
W potrzasku języka C
DKI
DKI
Z
W niniejszym rozdziale zajmiemy się szczegółowo niektórymi najczęściej popełnianymi
błędami wynikającymi z niezrozumienia znaczenia elementów leksykalnych i zale -
ności pomiędzy nimi a tworzącymi je znakami.
1.1. Porównanie a przypisanie
W większości języków programowania wywodzących się z języka Algol, na przykład
w Pascalu czy Adzie, operacja przypisania reprezentowana jest znakami
, a porówna-
nia — znakami
. W języku C przypisanie reprezentuje znak
, a porównanie — znaki
. Poniewa w programie częściej występują przypisania ni porównania, taka repre-
zentacja jest bardzo wygodna dla programisty, bo dla operacji częstszej stosuje krótszy
zapis. Co więcej, w języku C przypisanie jest operatorem, co umo liwia składanie
wielu operacji przypisania w jednym wyra eniu.
Wygoda ta jest jednak źródłem wielu błędów wynikających z omyłkowego zapisania
operatora przypisania w miejscu, gdzie powinien znajdować się operator porównania;
jak w poni szej instrukcji warunkowej, która powinna wykonywać instrukcję
DTGCM
,
kiedy
Z
jest równe
[
:
KH
Z [
DTGCM
W rzeczywistości instrukcja ta przypisuje do
Z
wartość
[
, a potem sprawdza, czy wyni-
kiem operacji przypisania jest wartość niezerowa. Następnym przykładem mo e być
pętla, która miała pomijać w pliku znaki odstępów (spacji, tabulacji i nowego wiersza):
YJKNG
E
^^ E >V ^^ E >P
E IGVE H
W pętli tej w pierwszym porównaniu znaku
E
zamiast
zapisano
. Poniewa operator
przypisania ma priorytet ni szy od operatora
^^
, „porównanie” w rzeczywistości po-
woduje przypisanie do
E
wartości wyra enia:
^^ E >V ^^ E >P
Poniewa wartość
jest ró na od zera, całe wyra enie ma wartość
niezale nie od
pierwotnej wartości
E
. Dlatego pętla spowoduje „przewinięcie” całego pliku. Co sta-
nie się po wyczerpaniu znaków pliku, zale y od tego, czy implementacja języka po-
zwala na kontynuowanie odczytu po osiągnięciu końca pliku. Jeśli tak, program wejdzie
w pętlę nieskończoną.

Plik z chomika:

Inne pliki z tego folderu:

Inne foldery tego chomika:

Zgłoś jeśli naruszono regulamin