Darmowy fragment publikacji:
Tytuł oryginału: C Programming Absolute Beginner s Guide, Third Edition
Tłumaczenie: Łukasz Piwko
ISBN: 978-83-283-1641-6
Authorized translation from the English language edition, entitled: C PROGRAMMING ABSOLUTE
BEGINNER S GUIDE, Third Edition; ISBN 0789751984; by Greg Perry; and by Dean Miller,
published by Pearson Education, Inc, publishing as QUE Publishing.
Copyright © by 2014 by Pearson Education, Inc.
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 Pearson Education Inc.
Polish language edition published by HELION S.A. Copyright © 2015.
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)
Drogi Czytelniku!
Jeżeli chcesz ocenić tę książkę, zajrzyj pod adres
http://helion.pl/user/opinie/jcprpo
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(cid:258)ci
Wprowadzenie ...........................................................................................................11
Adresaci książki ................................................................................................................ 12
Co wyróżnia tę książkę na tle konkurencji ................................................................... 12
Elementy wizualne ........................................................................................................... 12
Co ciekawego można zrobić przy użyciu języka C? .................................................... 13
Co dalej? ............................................................................................................................ 13
Cz(cid:218)(cid:258)(cid:202) I. Podstawy
1 Na czym polega programowanie w j(cid:218)zyku C i czemu powinno Ci(cid:218) to obchodzi(cid:202) ....15
Co to jest program ........................................................................................................... 16
Co jest potrzebne do pisania programów w języku C ................................................ 17
Proces programowania ................................................................................................... 20
Posługiwanie się językiem C ........................................................................................... 20
2
Pierwszy program w j(cid:218)zyku C .............................................................................23
Prosty przykład kodu ...................................................................................................... 24
Funkcja main() ................................................................................................................. 26
Rodzaje danych ................................................................................................................ 27
Znaki w języku C ....................................................................................................... 27
Liczby w języku C ...................................................................................................... 28
Jeszcze jeden przykład w ramach podsumowania ....................................................... 30
3 Do czego to s(cid:239)u(cid:285)y? Obja(cid:258)nianie kodu za pomoc(cid:200) komentarzy .............................33
Dodawanie komentarzy do kodu .................................................................................. 34
Definiowanie komentarzy .............................................................................................. 35
Białe znaki ......................................................................................................................... 36
Inny rodzaj komentarzy .................................................................................................. 37
4
(cid:165)wiatowa premiera — wysy(cid:239)anie wyników dzia(cid:239)ania programu na ekran .........39
Funkcja printf() ................................................................................................................ 40
Format funkcji printf() ............................................................................................. 40
Poleć książkęKup książkę 4
J(cid:125)ZYK C. PROGRAMOWANIE DLA POCZ(cid:107)TKUJ(cid:107)CYCH
Drukowanie łańcuchów .................................................................................................. 41
Cytowanie znaków ........................................................................................................... 41
Znaczniki konwersji ........................................................................................................ 43
Przykład podsumowujący ............................................................................................... 45
5
Zmienne ..............................................................................................................47
Rodzaje zmiennych .......................................................................................................... 48
Nadawanie zmiennym nazw .......................................................................................... 49
Definiowanie zmiennych ................................................................................................ 50
Zapisywanie danych w zmiennych ................................................................................ 51
6 Dodawanie s(cid:239)ów do programu ............................................................................55
Znak końca łańcucha ....................................................................................................... 56
Długość łańcucha ............................................................................................................. 57
Tablice znaków — listy znaków ..................................................................................... 57
Inicjowanie łańcuchów ................................................................................................... 59
7 Dyrektywy #include i #define ............................................................................63
Dołączanie plików ............................................................................................................ 64
Miejsce dyrektywy #include ........................................................................................... 66
Definiowanie stałych ....................................................................................................... 66
Tworzenie pliku nagłówkowego i programu ............................................................... 67
8
Interakcja z u(cid:285)ytkownikiem .................................................................................71
Funkcja scanf() ................................................................................................................. 72
Odbieranie danych za pomocą funkcji scanf() ............................................................ 72
Problemy z funkcją scanf() ............................................................................................. 74
Cz(cid:218)(cid:258)(cid:202) II. Wyra(cid:285)enia i operatory j(cid:218)zyka C
9 Obliczenia matematyczne ....................................................................................77
Podstawowe działania arytmetyczne ............................................................................. 78
Kolejność wykonywania operatorów ............................................................................ 80
Łamanie zasad za pomocą nawiasów ............................................................................ 82
Operator przypisania ....................................................................................................... 82
Poleć książkęKup książkę
SPIS TRE(cid:165)CI
5
10 Modyfikowanie warto(cid:258)ci zmiennych za pomoc(cid:200) instrukcji przypisania ...............85
Złożony operator przypisania ........................................................................................ 86
Uważaj na kolejność ........................................................................................................ 89
Rzutowanie typów ........................................................................................................... 89
11 Na rozstajach dróg — wybieranie (cid:258)cie(cid:285)ki na podstawie warunków ...................91
Testowanie danych .......................................................................................................... 92
Instrukcja if ....................................................................................................................... 93
W przeciwnym razie..., czyli instrukcja else ................................................................. 95
12 Wspieranie procesu decyzyjnego za pomoc(cid:200) operatorów logicznych .................99
Operatory logiczne ........................................................................................................ 100
Unikanie negacji ............................................................................................................ 103
Kolejność wykonywania operatorów logicznych ...................................................... 105
13
Jeszcze kilka operatorów do u(cid:285)ytku w programach ..........................................109
Żegnaj, konstrukcjo if...else, i witaj, operatorze warunkowy ................................... 110
Operatory zmiany wartości o jeden ++ i -- ................................................................ 112
Operator sizeof() ............................................................................................................ 114
Cz(cid:218)(cid:258)(cid:202) III. Konstrukcje steruj(cid:200)ce
14 Oszcz(cid:218)dzanie czasu i energii dzi(cid:218)ki u(cid:285)yciu p(cid:218)tli ................................................117
Pętla while ....................................................................................................................... 118
Przykład użycia instrukcji while .................................................................................. 119
Sposób użycia instrukcji do...while ............................................................................. 120
15
16
Inne rodzaje p(cid:218)tli ..............................................................................................123
Pętla for ........................................................................................................................... 124
Praca z pętlą for .............................................................................................................. 125
Jak wyrwa(cid:202) si(cid:218) z zakl(cid:218)tego kr(cid:218)gu .....................................................................131
Przerywanie pętli ............................................................................................................ 132
Kontynuacja wykonywania .......................................................................................... 134
Poleć książkęKup książkę 6
17
18
19
J(cid:125)ZYK C. PROGRAMOWANIE DLA POCZ(cid:107)TKUJ(cid:107)CYCH
Instrukcja switch i klauzula case .......................................................................137
Instrukcja switch ............................................................................................................ 138
Instrukcje break i switch ............................................................................................... 140
Kwestie wydajności ........................................................................................................ 141
Inne sposoby zwracania i pobierania danych ....................................................147
Funkcje putchar() i getchar() ....................................................................................... 148
Rozwiązanie problemu ze znakiem nowego wiersza ................................................ 150
Przyspieszanie programu za pomocą funkcji getch() ............................................... 151
Jak optymalnie wykorzysta(cid:202) (cid:239)a(cid:241)cuchy ...............................................................153
Funkcje do testowania znaków .................................................................................... 154
Mała czy duża ................................................................................................................. 154
Funkcje do zmiany wielkości liter ............................................................................... 157
Funkcje łańcuchowe ...................................................................................................... 157
20 Matematyka zaawansowana (ale dla komputera) .............................................161
Funkcje matematyczne .................................................................................................. 162
Inne rodzaje konwersji .................................................................................................. 163
Trygonometria i inne skomplikowane zagadnienia .................................................. 164
Liczby losowe .................................................................................................................. 166
Cz(cid:218)(cid:258)(cid:202) IV. Zapisywanie i przechowywanie danych
21
22
Tablice ...............................................................................................................171
Powtórzenie wiadomości o tablicach .......................................................................... 172
Wstawianie wartości do tablic ...................................................................................... 174
Przeszukiwanie tablic ........................................................................................177
Wstawianie wartości do tablic ...................................................................................... 178
Techniki przeszukiwania tablic .................................................................................... 178
23 Alfabetyczne uk(cid:239)adanie i porz(cid:200)dkowanie ..........................................................185
Wielkie porządki ............................................................................................................ 186
Szybkie metody wyszukiwania ..................................................................................... 190
Poleć książkęKup książkę
24
25
SPIS TRE(cid:165)CI
7
Rozwi(cid:200)zanie zagadki wska(cid:283)ników .....................................................................195
Adresy pamięci ............................................................................................................... 196
Definiowanie zmiennych wskaźnikowych ................................................................. 196
Operator dereferencji * ................................................................................................. 198
Tablice i wska(cid:283)niki ............................................................................................203
Nazwy tablic są wskaźnikami ....................................................................................... 204
Przeglądanie listy ........................................................................................................... 205
Znaki i wskaźniki ........................................................................................................... 205
Uwaga na długość łańcucha ......................................................................................... 206
Tablice wskaźników ....................................................................................................... 208
26 Optymalizacja wykorzystania pami(cid:218)ci ...............................................................213
Czym jest sterta .............................................................................................................. 214
Do czego służy sterta ..................................................................................................... 215
Alokacja pamięci na stercie .......................................................................................... 216
Postępowanie w przypadku, gdy na stercie brakuje miejsca ................................... 218
Zwalnianie pamięci na stercie ...................................................................................... 219
Alokowanie wielu obszarów na stercie ....................................................................... 219
27
Zapisywanie informacji w strukturach ...............................................................225
Definiowanie struktury ................................................................................................. 226
Zapisywanie danych w zmiennych strukturalnych ................................................... 229
Cz(cid:218)(cid:258)(cid:202) V. Pliki i funkcje
28
29
Zapisywanie plików sekwencyjnych na komputerze .........................................233
Pliki na dysku ................................................................................................................. 234
Otwieranie pliku ............................................................................................................ 234
Korzystanie z plików sekwencyjnych .......................................................................... 236
Zapisywanie plików o dost(cid:218)pie swobodnym na dysku .....................................241
Swobodne otwieranie plików ....................................................................................... 242
Poruszanie się po pliku ................................................................................................. 243
Poleć książkęKup książkę 8
J(cid:125)ZYK C. PROGRAMOWANIE DLA POCZ(cid:107)TKUJ(cid:107)CYCH
30 Organizacja struktury programu za pomoc(cid:200) funkcji ..........................................249
Budowa programu na bazie funkcji ............................................................................ 250
Zmienne globalne czy lokalne ...................................................................................... 252
31
32
Przekazywanie zmiennych do funkcji ................................................................257
Przekazywanie argumentów ......................................................................................... 258
Metody przekazywania argumentów .......................................................................... 258
Przekazywanie argumentów przez wartość ......................................................... 259
Przekazywanie przez adres ..................................................................................... 261
Zwracanie danych przez funkcje ........................................................................267
Zwracanie wartości ........................................................................................................ 268
Zwrotny typ danych ...................................................................................................... 270
Ostatni krok — prototyp .............................................................................................. 271
Podsumowanie ............................................................................................................... 272
Dodatki
A
Tabela znaków ASCII .........................................................................................275
B Gra w pokera dobieranego ...............................................................................281
Skorowidz .........................................................................................................289
Poleć książkęKup książkę W T Y M R O Z D Z I A L E
(cid:120) Wpisanie pierwszego programu do edytora.
(cid:120) Sposób użycia funkcji main().
(cid:120) Rodzaje danych.
2
PIERWSZY PROGRAM W J(cid:125)ZYKU C
W tym rozdziale zobaczysz pierwszy program w języku C! Ale na razie nie próbuj
zrozumieć każdego znaku w przedstawianym kodzie źródłowym. Rozluźnij się i postaraj
się tylko oswoić z wyglądem i stylem kodu. Wkrótce zaczniesz rozpoznawać poszczególne
elementy programów w języku C.
Poleć książkęKup książkę 24
J(cid:125)ZYK C. PROGRAMOWANIE DLA POCZ(cid:107)TKUJ(cid:107)CYCH
Prosty przyk(cid:239)ad kodu
W tym podrozdziale przedstawiamy krótki, ale kompletny program w języku C oraz
opisujemy inny program, który w całości znajduje się w dodatku B. Oba te programy
mają pewne cechy wspólne. Oto pierwszy z nich:
/* Drukuje napis na ekranie */
#include stdio.h
main()
{
system( chcp 65001 );
printf( Niewielki krok dla kodera. Gigantyczny skok dla );
printf( programistów!\n );
return 0;
}
Uruchom swoje środowisko programistyczne i wpisz do niego powyższy program. Proste,
prawda? Pewnie już używałeś swojego nowego kompilatora. Przy pierwszym uruchomieniu
Code::Blocks na ekranie pojawia się podpowiedź dnia. Później może się do czegoś przyda,
a na razie zamknij ją, klikając przycisk Close (zamknij).
Aby utworzyć program, otwórz menu File (plik) i kliknij pozycję New (nowy). Z listy opcji
w wyświetlonym podmenu wybierz Empty File (pusty plik), by utworzyć nowy pusty plik
źródłowy, w którym możesz wpisać swój program.
Gdy wpiszesz kod do edytora, musisz go skompilować. W tym celu kliknij znajdującą się
na pasku narzędzi małą żółtą ikonę przedstawiającą koło zębate. Jeśli przy wpisywaniu nie
popełniłeś żadnego błędu, możesz uruchomić ten program, klikając zieloną strzałkę w prawo
znajdującą się obok koła zębatego. (Następna ikona w tym rzędzie, przedstawiająca koło zębate
i strzałkę, reprezentuje opcję kompilacji i uruchamiania programu jednocześnie, co pozwala
na zmniejszenie liczby kliknięć, jakie musisz wykonać, aby uruchomić program).
Po skompilowaniu i uruchomieniu programu na ekranie powinno pojawić się okno
widoczne na rysunku 2.1.
UWAGA Wydrukowanie tego krótkiego napisu w konsoli wymagało
sporo pracy! Ale tak naprawdę tylko dwie linijki z powyższego programu
rzeczywiście wykonują pracę związaną z tworzeniem danych wyjściowych
— te zaczynające się od słowa printf. Pozostały kod służy tylko do
przeprowadzenia pewnych rutynowych czynności, które wykonuje się
we wszystkich programach w języku C.
Jeśli chcesz zobaczyć dłuższy program, zajrzyj do dodatku B. Choć wydrukowana w nim
gra w pokera obejmuje kilka stron, znajdują się w niej takie same podstawowe elementy
jak w tym krótszym programie.
Przyjrzyj się obu opisanym programom i zwróć uwagę na łączące je podobieństwa. Pierwsze,
co może Ci się rzucić w oczy, to klamry ({}), nawiasy (()) i ukośniki (\). Kod źródłowy
należy wpisywać do edytora bardzo starannie, ponieważ kompilator języka C jest bardzo
drobiazgowy. Nie możesz na przykład wpisać nawiasu prostokątnego ([) w miejscu,
w którym powinna być klamra.
Poleć książkęKup książkę ROZDZIA(cid:146) 2. (cid:132) PIERWSZY PROGRAM W J(cid:125)ZYKU C
25
RYSUNEK 2.1.
Wynik działania pierwszego programu
OSTRZE(cid:191)ENIE Szczególną ostrożność zachowaj też przy kopiowaniu
kodu do edytora z procesora tekstu. Przedstawiony program napisałem
w Wordzie (w ramach tej książki), a potem skopiowałem go do Code::Blocks.
Ale podczas kompilacji okazało się, że kod zawiera błędy, ponieważ Word
zmienił cudzysłowy w linijkach z instrukcją printf (zamiast prostych wstawił
zagięte), przez co kompilator ich nie rozpoznał. Gdy usunąłem te cudzysłowy
i wpisałem je jeszcze raz już bezpośrednio w edytorze, kompilacja przebiegła
pomyślnie. Jeśli więc w Twoim kodzie pojawią się jakieś błędy, sprawdź,
czy nie mają przypadkiem związku z cudzysłowami.
Kompilator C nie jest wybredny pod każdym względem. Na przykład większość odstępów,
jakie są obecne w programach, ma zwiększać czytelność kodu dla ludzi, ale nie dla
kompilatora. Pisząc program, dodawaj puste wiersze i wcinaj sekcje kodu, aby poprawić
jego wygląd i ułatwić sobie znajdowanie w nim wybranych części.
WSKAZÓWKA Do wcinania kodu lepiej jest używać tabulatorów niż
spacji. W większości edytorów języka C da się ustawić szerokość tabulatora
(liczbę spacji). Niektóre linijki kodu C są dość długie, dobrym pomysłem
jest więc ustawienie tabulatora na trzy spacje. To daje dobre efekty i nie
powoduje nadmiernego wydłużania linijek.
Wszystkie polecenia i funkcje standardowe w języku C pisze się małymi literami. (O tym,
czym jest funkcja, dowiesz się w następnym podrozdziale). Wielkich liter używa się tylko
w wierszach z dyrektywą #define i w napisanych do wydrukowania na ekranie.
Poleć książkęKup książkę 26
J(cid:125)ZYK C. PROGRAMOWANIE DLA POCZ(cid:107)TKUJ(cid:107)CYCH
Funkcja main()
Najważniejszą częścią programu w języku C jest funkcja main(). Oba opisane wcześniej
programy zawierają funkcję main(). Wprawdzie w tej chwili nie ma to wielkiego znaczenia,
ale warto zaznaczyć, że main() to funkcja, a nie polecenie. Funkcja to procedura wykonująca
pewne zadanie. Niektóre funkcje są standardowo dostępne w języku C, a inne programista
tworzy samodzielnie. Programy w języku C składają się z jednej lub większej liczby funkcji,
ale każdy program musi zawierać przynajmniej funkcję main(). Od poleceń funkcje różnią
się nawiasem za nazwą. Poniżej znajdują się przykłady funkcji:
main() calcIt() printf() strlen()
A to są przykładowe polecenia:
return while int if float
W innych książkach o programowaniu w języku C, podręcznikach i na stronach
internetowych za nazwami funkcji może nie być nawiasów. Na przykład autor może pisać
o funkcji printf, a nie printf(). Szybko nauczysz się rozpoznawać nazwy funkcji, dlatego
nie musisz się tym przejmować. Z drugiej strony większość autorów stara się jak
najwyraźniej rozróżniać funkcje i inne konstrukcje, najczęściej więc dodają te nawiasy.
OSTRZE(cid:191)ENIE W nazwie jednej z przedstawionych na liście funkcji,
calcIt(), znajduje się wielka litera, mimo że wcześniej napisaliśmy, że
tak nie powinno się zdarzyć. Jeśli nazwa składa się z kilku słów, np.
wydrukujTenRaport(), to zazwyczaj każde słowo oprócz pierwszego pisze
się wielką literą w celu zwiększenia czytelności kodu. (W nazwach funkcji
nie może być spacji). Podsumowując, nie używaj wielkich liter zawsze,
tylko od czasu do czasu.
Funkcja main() i wszystkie standardowe funkcje języka C muszą być zapisywane małymi
literami. Wielkich liter można używać w nazwach własnych funkcji, ale większość
programistów i tak nie korzysta z tej możliwości.
Podobnie jak strona główna stanowi miejsce, od którego zaczyna się przeglądanie witryny
internetowej, tak funkcja main() jest początkiem wykonywania każdego programu. Jest tak
nawet wtedy, gdy przed nią znajdują się jeszcze jakieś inne funkcje. W związku z tym dla
czytelności najlepiej jest, aby funkcja ta znajdowała się na początku programu. Programy
opisane w kilku następnych rozdziałach zawierają tylko jedną funkcję — main(). Gdy
zdobędziesz trochę praktyki, dowiesz się, dlaczego dobrze jest dodawać funkcje za funkcją
main().W rozdziale 30. natomiast nauczysz się pisać własne funkcje.
Za napisem main() zawsze znajduje się otwarcie klamry ({) wyznaczające początek treści
funkcji oraz zamknięcie (}) wyznaczające jej koniec. Między tymi znakami mogą znajdować
się inne pary klamer. Jeszcze raz spójrz na program w dodatku B. Jego pierwsza funkcja to
main(), a wewnątrz niej znajdują się inne z własnymi klamrami.
Poleć książkęKup książkę ROZDZIA(cid:146) 2. (cid:132) PIERWSZY PROGRAM W J(cid:125)ZYKU C
27
UWAGA W prawie każdym programie C potrzebna jest instrukcja
#include stdio.h , która pomaga w drukowaniu i pobieraniu danych.
Na razie zapamiętaj tylko, aby wstawiać ją zawsze gdzieś przed funkcją
main(). Zastosowanie dyrektywy #include i jej znaczenie w programach
dokładnie poznasz w rozdziale 7.
Rodzaje danych
Programy C wykorzystują do działania dane składające się z liczb, znaków i słów oraz
przetwarzają je w przydatne informacje. Choć istnieje wiele różnych rodzajów danych,
poniższe trzy są używane najczęściej w typowych programach w języku C:
(cid:122) znaki,
(cid:122)
(cid:122)
liczby całkowite,
liczby zmiennoprzecinkowe (w uproszczeniu zwane też rzeczywistymi).
WSKAZÓWKA Może z przerażeniem zastanawiasz się, ile matematyki
będziesz musiał się nauczyć. Pewnie nie spodziewałeś się takiego obrotu
rzeczy. Ale możesz się uspokoić, ponieważ do programowania w języku C
nie potrzeba znajomości matematyki. Nie musisz nawet wiedzieć, ile to jest
dwa plus dwa. Trzeba jednak rozróżniać typy danych, aby móc bez problemu
zdecydować, który w razie potrzeby zastosować.
Znaki w j(cid:218)zyku C
Znak w języku C to każdy pojedynczy znak, jaki komputer może reprezentować. Twój
komputer zna 256 znaków zapisanych w tzw. tabeli ASCII (dodatek A). Wszystko,
co komputer może reprezentować, może być znakiem. Na przykład wszystkie poniższe
elementy są znakami:
A a 4 Q ! + = ]
UWAGA Organizacja American National Standards Institute (ANSI),
która stworzyła standard ANSI C, jest też autorem kodu karty ASCII.
WSKAZÓWKA Nawet spacja jest znakiem. Kompilator C rejestruje
wszystkie litery, cyfry i inne znaki, w tym również wszelkie odstępy, takie
jak spacje.
Jak widać, każda litera, cyfra i spacja to w języku C jakiś znak. Oczywiście 4 wygląda jak
liczba i czasami pełni taką właśnie funkcję, ale oprócz tego jest też znakiem. Jeśli zaznaczysz,
że 4 jest znakiem, nie możesz używać jej w działaniach matematycznych. To samo dotyczy
symboli specjalnych. Plus (+) jest znakiem, ale może też być używany jako operator dodawania.
(I znów matematyka wraca jak bumerang)!
Poleć książkęKup książkę 28
J(cid:125)ZYK C. PROGRAMOWANIE DLA POCZ(cid:107)TKUJ(cid:107)CYCH
Dane znakowe w języku C umieszcza się między apostrofami ( ), przez niektórych
zwanymi pojedynczym cudzysłowem. Pozwala to odróżnić znaki od innych rodzajów
danych, takich jak liczby i symbole matematyczne. Poniżej znajduje się kilka przykładów
danych znakowych języka C:
A a 4 -
Z kolei w następnym przykładzie nie ma danych znakowych, ponieważ nie użyto
apostrofów:
A a 4 -
WSKAZÓWKA Poniższe przykłady nie są prawidłowymi znakami,
ponieważ w apostrofach można umieszczać tylko pojedyncze znaki,
nie ich ciągi.
J(cid:218)zyk C jest fajny.
J(cid:218)zyk C jest trudny.
Powinienem teraz (cid:285)eglowa(cid:202)!
Pierwszy opisany w tym rozdziale program zawiera też znak \n . Na pierwszy rzut oka
widać, że \n to nie pojedynczy znak, ale jest to jedna z kilku dwuznakowych kombinacji
interpretowanych przez kompilator C jako pojedyncze znaki. Dokładniejsze wyjaśnienie
tego znajduje się dalej.
Jeśli chcesz użyć więcej niż jednego znaku (nie licząc opisanego powyżej przypadku
specjalnych kombinacji dwuznakowych), użyj prostego cudzysłowu podwójnego ( ).
Ciąg znaków nazywa się łańcuchem. Oto przykład prawidłowego łańcucha w języku C:
Fajnie jest uczy(cid:202) si(cid:218) j(cid:218)zyka C.
UWAGA Na razie wystarczy wiedzieć tylko tyle o znakach i łańcuchach
znaków. W rozdziałach 4. – 6. nauczysz się ich używać w programach.
Kiedy będziesz już potrafił zapisywać znaki w zmiennych, dostrzeżesz też,
dlaczego apostrofy i cudzysłowy podwójne są takie ważne.
Liczby w j(cid:218)zyku C
Choć pewnie nigdy do tej pory się nad tym nie zastanawiałeś, liczby mogą mieć różne
rozmiary i formy. Programista musi mieć możliwość zapisywania liczb w programie bez
względu na to, jak wyglądają. Służą do tego zmienne typów liczbowych. Zanim przejdziemy
do zmiennych, zrobimy krótkie przypomnienie wiadomości o rodzajach liczb.
Liczby całkowite to takie, które nie mają części ułamkowej. W związku z tym każda
liczba bez przecinka, a w programie bez kropki, to liczba całkowita. Oto kilka przykładów
takich liczb:
10 54 0 –121 –68 752
Poleć książkęKup książkę ROZDZIA(cid:146) 2. (cid:132) PIERWSZY PROGRAM W J(cid:125)ZYKU C
29
OSTRZE(cid:191)ENIE Liczba całkowita nie powinna zaczynać się zerem
(chyba że jest po prostu zerem), ponieważ wówczas kompilator może ją
potraktować jako liczbę szesnastkową lub ósemkową. Liczby szesnastkowe
i ósemkowe (nazywane też liczbami o podstawie szesnaście i osiem) to
zwykłe liczby, tylko przedstawione w dziwaczny sposób. Na przykład 053
to liczba ósemkowa, a 0x45 to liczba szesnastkowa. Jeśli nie wiesz, o co
chodzi, to zapamiętaj tylko, że jeśli będziesz stawiać zero na początku liczb,
może Cię spotkać nieszczęście.
Liczby z kropką dziesiętną to liczby zmiennoprzecinkowe. Poniżej znajduje się kilka
przykładów:
547.43 0.0 0.44384 9.1923 –168.470 .22
WSKAZÓWKA Jak widać, zero na początku liczb
zmiennoprzecinkowych nie powoduje problemów.
Wybór liczb zmiennoprzecinkowych lub całkowitych zależy od rodzaju danych, na których
pracuje program. Niektóre wielkości (np. wiek czy ilość) można przedstawić za pomocą
liczb całkowitych, a do wyrażenia innych (np. kwot pieniędzy i ciężaru) potrzebne są liczby
zmiennoprzecinkowe. Wewnętrzna reprezentacja liczb całkowitych różni się od reprezentacji
liczb zmiennoprzecinkowych. Jak widać na rysunku 2.2, wartość zmiennoprzecinkowa
z reguły zajmuje dwa razy więcej pamięci niż liczba całkowita. Dlatego jeśli nie jest
to konieczne, lepiej jest nie używać wartości zmiennoprzecinkowych.
RYSUNEK 2.2.
Do przechowywania wartości zmiennoprzecinkowych często potrzeba więcej pamięci niż do zapisu
liczb całkowitych
Poleć książkęKup książkę 30
J(cid:125)ZYK C. PROGRAMOWANIE DLA POCZ(cid:107)TKUJ(cid:107)CYCH
UWAGA Z rysunku 2.2 wynika, że liczby całkowite z reguły zajmują
mniej pamięci niż liczby zmiennoprzecinkowe bez względu na rozmiar
reprezentowanej przez nie wartości. Jednego dnia urząd pocztowy może
otrzymać znacznie więcej listów niż innego. Zawartość skrzynki nie ma
jednak wpływu na jej pojemność. Podobnie jest z typami liczbowymi
w języku C — ich pojemność nie jest uzależniona od wartości liczby.
Różne kompilatory języka C wykorzystują różne ilości pamięci do przechowywania liczb
całkowitych i zmiennoprzecinkowych. Później pokażemy Ci, jak sprawdzić, ile dokładnie
pamięci przeznacza dany kompilator dla każdego typu danych.
Jeszcze jeden przyk(cid:239)ad w ramach podsumowania
Celem tego rozdziału było pokazanie, jak wygląda program w języku C, a w szczególności
przedstawienie funkcji main() jako głównej procedury zawierającej wykonywalne instrukcje.
Pokazaliśmy, że język C jest bardzo liberalny pod względem stosowania odstępów w kodzie
źródłowym, ale bardzo restrykcyjny, jeśli chodzi o stosowanie wielkich i małych liter
w nazwach konstrukcji programistycznych. Małymi literami zapisuje się nazwy wszystkich
standardowych poleceń i funkcji języka C, np. printf().
Na razie nie przejmuj się zbytnio szczegółami przedstawionego w tym rozdziale kodu,
ponieważ wszystko jest dokładnie wyjaśnione w następnych rozdziałach. Ale bardzo
dobrym pomysłem jest przepisanie i przeanalizowanie jak największej liczby programów
— dzięki takiej praktyce zdobywa się pewność siebie! Dlatego poniżej przedstawiamy
jeszcze jeden program, w którym użyto opisanych wcześniej typów danych:
/* Program, w którym wykorzystano znaki, liczby całkowite i liczby zmiennoprzecinkowe */
#include stdio.h
main()
{
system( chcp 65001 );
printf( Ucz(cid:218) si(cid:218) j(cid:218)zyka programowania c.\n , C );
printf( W(cid:239)a(cid:258)nie sko(cid:241)czy(cid:239)em czyta(cid:202) rozdzia(cid:239) d.\n , 2);
printf( Jestem na .1f procent gotów do dalszej pracy , 99.9);
printf( w nast(cid:218)pnym rozdziale!\n );
return 0;
}
Program ten tylko drukuje na ekranie trzy napisy, z których każdy zawiera jeden
z opisanych wcześniej typów danych: znak (C), liczbę całkowitą (2) oraz liczbę
zmiennoprzecinkową (99.9).
UWAGA W pierwszej instrukcji printf ciąg c wskazuje programowi
miejsce, w którym należy wstawić znak C . Litera c w tym ciągu to skrót
od angielskiego wyrazu character (znak), a nie odpowiednik C. Gdyby to
była książka o języku programowania N, to i tak użylibyśmy ciągu c,
aby wstawić w wybranym miejscu literę N .
Poleć książkęKup książkę ROZDZIA(cid:146) 2. (cid:132) PIERWSZY PROGRAM W J(cid:125)ZYKU C
31
Funkcja main() to jedyna funkcja w tym programie napisana przez programistę. Jej treść
musi być objęta klamrą ({}). To samo dotyczy także innych funkcji, jeśli zostaną dodane
do programu. Ponadto w kodzie użyto standardowej funkcji języka C o nazwie printf().
Poniżej znajduje się wynik jej działania:
Ucz(cid:218) si(cid:218) j(cid:218)zyka programowania C.
W(cid:239)a(cid:258)nie sko(cid:241)czy(cid:239)em czyta(cid:202) rozdzia(cid:239) 2.
Jestem na 99.9 procent gotów do dalszej pracy w nast(cid:218)pnym rozdziale!
WSKAZÓWKA Pobaw się tym programem, pozmieniaj coś
w wyświetlanych napisach. Sprawdź też, co się stanie, gdy popełnisz
literówkę, np. zapomnisz średnika na końcu linijki. Dobrze jest wiedzieć,
co się dzieje w takim przypadku podczas kompilacji. Nauka na błędach jest
bardzo efektywna.
ABSOLUTNE MINIMUM
W tym rozdziale skompilowałeś i uruchomiłeś pierwszy program w języku C i zapoznałeś
się z funkcją main(). Oto lista najważniejszych informacji do zapamiętania:
(cid:122) W języku C za nazwą funkcji musi znajdować się nawias. Program C składa się
z przynajmniej jednej funkcji. Funkcja main() jest zawsze obowiązkowa i jest
wykonywana jako pierwsza.
(cid:122) Stosuj dużo odstępów w kodzie programu, aby uczynić go jak najbardziej czytelnym.
(cid:122) Na początku liczb całkowitych nie wpisuj zera, chyba że chcesz użyć właśnie zera.
(cid:122) Pojedyncze znaki umieszczaj między apostrofami. Łańcuchy wpisuje się w podwójnych
prostych cudzysłowach. Liczby całkowite to liczby pozbawione części ułamkowej.
Liczby zmiennoprzecinkowe mają część ułamkową.
Poleć książkęKup książkę 32
J(cid:125)ZYK C. PROGRAMOWANIE DLA POCZ(cid:107)TKUJ(cid:107)CYCH
Poleć książkęKup książkę Skorowidz
A
adresy pamięci, 196
alokacja pamięci, 216
alokowanie wielu obszarów, 219
ANSI C, 20
ASCII, 27, 275
białe znaki, 36
blok, 253
budowa programu, 250
bug, 20
B
C
cytowanie znaków specjalnych, 41
D
dane, 27
literalne, 48
stałe, 48
debugowanie, 20
definiowanie
komentarzy, 35
składowych, 227
stałych, 66
struktury, 226
zmiennych, 50
zmiennych wskaźnikowych, 196
deklaracja, 50
dekrementacja, 87
dereferencja, 198
długość łańcucha, 57, 206
dodawanie
komentarzy, 34
słów do programu, 55
dołączanie plików, 64
dostęp swobodny do pliku, 242
drukowanie łańcuchów, 41
dyrektywa
#define, 25, 66
#include, 64, 66
dyrektywy preprocesora, 63
działania arytmetyczne, 78
dzielenie całkowitoliczbowe, 78
edytor, 20
element, 59, 172
E
F
fałsz, 92
format
dyrektywy #define, 66
funkcji printf(), 40
funkcja, 250
addPayroll(), 254
buildContact(), 251, 254
ceil(), 162
feof(), 239
fgetc(), 245
fgets(), 238
floor(), 162
fopen(), 234, 240–243, 247
fprintf(), 236
fputc(), 245
fputs(), 238
free(), 216, 223
fscanf(), 239
fseek(), 243, 247
getch(), 151
getchar(), 148, 149
gets(), 158, 172, 206
gradeAve(), 270
isalpha(), 154
isdigit(), 154
islower(), 155
isupper(), 154
main(), 26, 31, 249, 255
malloc(), 216, 218, 223
prAgain(), 254
printf(), 30, 40, 46, 71, 147
putchar(), 148, 149
puts(), 158
rand(), 166, 273
Poleć książkęKup książkę 290
J(cid:125)ZYK C. PROGRAMOWANIE DLA POCZ(cid:107)TKUJ(cid:107)CYCH
funkcja
scanf(), 71–76, 147
sqrt(), 268
srand(), 166
strcat(), 157
tolower(), 157
toupper(), 157
funkcje
do testowania znaków, 154
do zmiany wielkości liter, 157
łańcuchowe, 157
matematyczne, 162
G
kontynuacja wykonywania, 134
konwersja, 163
kropka, 229
L
liczby, 28
całkowite, 27, 28
losowe, 166
zmiennoprzecinkowe, 27, 29
listy, 205
znaków, 57
gra w pokera dobieranego, 281
łańcuch, 28, 59, 153
I
(cid:146)
M
IDE, integrated development environment, 17
indeks, 59, 173
inicjowanie łańcuchów, 59
inkrementacja, 87
instrukcja
break, 131, 132, 140
continue, 131, 134, 156
else, 95, 98
if, 93, 98
return, 268
switch, 137, 140
instrukcje
przypisania, 85
złożone, 93
język maszynowy, 19
klamry, 24
klauzula
case, 137
default, 140, 146
J
K
kod źródłowy, 19
kolejność wykonywania operatorów, 80
logicznych, 105
komentarz, 33
konstrukcja if...else, 110
matematyka zaawansowana, 161
metody
przekazywania argumentów, 258
wyszukiwania, 190
miejsce dyrektywy #include, 66
mnożenie złożone, 89
modyfikowanie wartości zmiennych, 85
N
nagłówek string.h, 157
nawiasy, 24, 82
nazwy
tablic, 204
zmiennych, 49
negacja, 103
O
obliczenia matematyczne, 77
obsługa serwisowa, 34
odbieranie danych, 72
operator
., 229
– , 232
dekrementacji, 112
przedrostkowy, 113
przyrostkowy, 113
dereferencji *, 198
Poleć książkęKup książkę
inkrementacji, 112
przedrostkowy, 113
przyrostkowy, 113
przypisania, 51, 82, 86
sizeof(), 114
warunkowy, 110
wskaźnika do struktury, 229
operatory
logiczne, 100
przypisania, 88
relacyjne, 91, 92
złożone, 87
optymalizacja wykorzystania pamięci, 213
organizacja struktury programu, 249
otwieranie pliku, 234, 242
P
pamięć, 196
nieprzydzielona, 214
przydzielona, 214
parametry, 258
pętla, 117
do...while, 120, 140
for, 124, 125
while, 118
pętle
nieskończone, 117
zagnieżdżone, 127
pierwszy program, 23
pisanie programów, 17
pliki
na dysku, 234
nagłówkowe, 67
o dostępie sekwencyjnym, 233, 236
o dostępie swobodnym, 234, 242
pobieranie danych, 147
polecenia języka, 20
poruszanie się po pliku, 243
prawda, 92
proces programowania, 20
program, 16
Code::Blocks, 17
programowanie, 15
strukturalne, 250
prototyp, 267, 271, 273
przechowywanie wartości zmiennoprzecinkowych,
29
przeglądanie listy, 205
SKOROWIDZ
291
przekazywanie argumentów, 258
przez adres, 258, 261
przez wartość, 258, 259
przekazywanie zmiennych do funkcji, 257
przerywanie pętli, 132
przeszukiwanie tablic, 177
przyspieszanie programu, 151
repozytorium SVN, 18
rodzaje
danych, 27
komentarzy, 37
konwersji, 163
pętli, 123
zmiennych, 48
rzutowanie typów, 89
R
S
sortowanie, 185
bąbelkowe, 186
stałe wskaźnikowe, 204
stany binarne, 19
sterta, 213-215
alokacja pamięci, 216
alokowanie wielu obszarów, 219
brak miejsca, 218
po alokacji, 217
zwalnianie pamięci, 219
struktura, 225
invStruct, 227
programu, 249
(cid:165)
środowisko programistyczne, 17
T
tabela znaków ASCII, 27, 275
tablice, 171, 203
element, 59, 172
indeks, 59, 173
metody wyszukiwania, 190
przeszukiwanie, 177
sortowanie, 185
techniki przeszukiwania, 178
Poleć książkęKup książkę 292
J(cid:125)ZYK C. PROGRAMOWANIE DLA POCZ(cid:107)TKUJ(cid:107)CYCH
zero
binarne, 56
null, 56
ziarno, 166
złożone operatory
przypisania, 88
relacyjne, 100
zmiana wielkości liter, 157
zmienne, 47
globalne, 50, 252, 272
lokalne, 50, 235, 252
strukturalne, 229
wskaźnikowe, 195
znacznik \n, 46
znaczniki, 42
konwersji, 43
znak
końca łańcucha, 56
nowego wiersza, 150
znaki, 27, 205
ASCII, 275
konwersji funkcji printf(), 44
specjalne, 41
zwalnianie pamięci, 219
zwracanie
danych, 147, 267
wartości, 258, 268
zwrotny typ danych, 270
tablice
wskaźników, 208
wstawianie wartości, 174, 178
znaków, 57, 171
testowanie
danych, 92
znaków, 154
tryb swobodnego dostępu do pliku, 242
trygonometria, 164
tworzenie pliku nagłówkowego, 67
typy danych, 48
ukośniki, 24
unikanie negacji, 103
użycie instrukcji
do...while, 120
while, 119
U
W
wskaźnik, 195, 203, 205
do struktury, 229
globalny, 235
wstawianie wartości do tablic, 174, 178
wybór środowiska programistycznego, 19
wydajność, 141
wynik, 16
wyszukiwanie, 190
Z
zagnieżdżanie instrukcji, 96
zapisywanie
danych, 51
plików, 241
Poleć książkęKup książkę
Pobierz darmowy fragment (pdf)
