Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00103 007550 13274799 na godz. na dobę w sumie
Język C. Programowanie dla początkujących. Wydanie III - ebook/pdf
Język C. Programowanie dla początkujących. Wydanie III - ebook/pdf
Autor: , Liczba stron: 296
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-283-1644-7 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> c - programowanie
Porównaj ceny (książka, ebook, audiobook).

Przewodnik dla adeptów programowania!

Język C ujrzał światło dzienne w 1972 roku i pomimo zaawansowanego wieku wciąż jest powszechnie używany. Na rynku istnieje oczywiście wiele innych języków, zazwyczaj łatwiejszych dla programistów, jednak C wciąż nie ma sobie równych w wielu zastosowaniach. Wszędzie tam, gdzie wymagana jest bezpośrednia kontrola nad sprzętem, najwyższa wydajność oraz przewidywalność czasu wykonania, C jest najczęściej wybieranym rozwiązaniem. Co więcej, jeżeli poznasz ten język, nauka kolejnych nie będzie stanowiła dla Ciebie żadnego problemu!

Dołącz do świata prawdziwych programistów — jeśli przeczytasz tę książkę, zrobisz spory krok w tym kierunku. Znajdziesz tu informacje na temat kluczowych elementów języka C: zmiennych, pętli, instrukcji warunkowych. To podstawowe konstrukcje, które pozwolą Ci napisać Twój pierwszy program. Następnie przejdziesz do poznawania bardziej zaawansowanych zagadnień, takich jak tablice, wskaźniki oraz operacje na plikach. Na sam koniec dowiesz się, jak optymalnie wykorzystać dostępną pamięć, alokować oraz zwalniać miejsce na stercie oraz przechowywać dane w strukturach. Najnowsze wydanie książki zostało wzbogacone i zaktualizowane o informacje na temat nowego standardu C11. Ta książka jest pozycją, która sprawdzi się w rękach każdego adepta programowania.

Oto lista niektórych opisanych zagadnień:

Odkryj pasjonujący świat programowania!

Znajdź podobne książki Ostatnio czytane w tej kategorii

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)

Gdzie kupić całą publikację:

Język C. Programowanie dla początkujących. Wydanie III
Autor:
,

Opinie na temat publikacji:


Inne popularne pozycje z tej kategorii:


Czytaj również:


Prowadzisz stronę lub blog? Wstaw link do fragmentu tej książki i współpracuj z Cyfroteką: