Od zera do gier kodera1

Karol Kuczmarski (Xion)

Od zera do gier kodera

megatutorial

Kurs C++
Tutorial ten jest kompletnym opisem jzyka C++. Rozpoczyna si od wstpu do
programowania i jzyka C++, by potem przeprowadziü Czytelnika przez proces
konstruowania jego pierwszych programów. Po nauce podstaw przychodzi czas na
programowanie obiektowe, a potem zaawansowane aspekty jzyka - z wyjtkami i
szablonami wácznie.
Kurs jest czci megatutoriala Od zera do gier kodera.

Copyright © 2004 Karol Kuczmarski
Udziela si zezwolenia do kopiowania, rozpowszechniania i/lub modyfikacji tego
dokumentu zgodnie z zasadami Licencji GNU Wolnej Dokumentacji w wersji 1.1 lub
dowolnej pó(niejszej, opublikowanej przez Free Software Foundation; bez Sekcji
Niezmiennych, bez Tekstu na Przedniej Okáadce, bez Tekstu na Tylniej Okáadce. Kopia
licencji zaáczona jest w sekcji Licencja GNU Wolnej Dokumentacji.

Wszystkie znaki wystpujce w tekcie s zastrze*onymi znakami firmowymi lub
towarowymi ich wáacicieli.

Autorzy doáo*yli wszelkich stara, aby zawarte w tej publikacji informacje byáy kompletne
i rzetelne. Nie bior jednak *adnej odpowiedzialnoci ani za ich wykorzystanie, ani za
zwizane z tym ewentualne naruszenie praw patentowych i autorskich. Autorzy nie
ponosz równie* *adnej odpowiedzialnoci za ewentualne szkody wynikáe z wykorzystania
informacji zawartych w tej publikacji.

Avocado Software

http://avocado.risp.pl

Game Design PL

http://warsztat.pac.pl

SPIS TRECI

PODSTAWY PROGRAMOWANIA __________________________ 17

Krótko o programowaniu _________________________________________ 19

Krok za krokiem _____________________________________________________________ 19

Jak rozmawiamy z komputerem? ________________________________________________ 21

Jzyki programowania ________________________________________________________ 23

Przegld najwa*niejszych jzyków programowania ________________________________ 23

Brzemienna w skutkach decyzja ______________________________________________ 26

Kwestia kompilatora ________________________________________________________ 27

Podsumowanie ______________________________________________________________ 28

Pytania i zadania __________________________________________________________ 28

Pytania ________________________________________________________________ 28

wiczenia ______________________________________________________________ 28

Z czego skáada si program? ______________________________________ 29

C++, pierwsze starcie ________________________________________________________ 29

Bliskie spotkanie z kompilatorem ______________________________________________ 29

Rodzaje aplikacji___________________________________________________________ 31

Pierwszy program __________________________________________________________ 32

Kod programu_______________________________________________________________ 33

Komentarze ______________________________________________________________ 33

Funkcja main() ___________________________________________________________ 33

Pisanie tekstu w konsoli _____________________________________________________ 34

Doáczanie plików nagáówkowych______________________________________________ 35

Procedury i funkcje ___________________________________________________________ 36

Wáasne funkcje ____________________________________________________________ 36

Tryb ledzenia ____________________________________________________________ 37

Przebieg programu _________________________________________________________ 38

Zmienne i staáe ______________________________________________________________ 39

Zmienne i ich typy _________________________________________________________ 39

Strumie wejcia __________________________________________________________ 40

Staáe ____________________________________________________________________ 41

Operatory arytmetyczne_______________________________________________________ 42

Umiemy liczyü! ____________________________________________________________ 42

Rodzaje operatorów arytmetycznych ___________________________________________ 43

Priorytety operatorów_______________________________________________________ 44

Tajemnicze znaki __________________________________________________________ 44

Podsumowanie ______________________________________________________________ 45

Pytania i zadania __________________________________________________________ 45

Pytania ________________________________________________________________ 46

wiczenia ______________________________________________________________ 46

Dziaáanie programu _____________________________________________ 47

Funkcje nieco bli*ej __________________________________________________________ 47

Parametry funkcji __________________________________________________________ 47

Wartoü zwracana przez funkcj ______________________________________________ 49

Skáadnia funkcji ___________________________________________________________ 50

Sterowanie warunkowe _______________________________________________________ 51

Instrukcja warunkowa if ____________________________________________________ 51

Fraza else _____________________________________________________________ 53

Bardziej záo*ony przykáad__________________________________________________ 54

Instrukcja wyboru switch ___________________________________________________ 56

Ptle ______________________________________________________________________ 58

Ptle warunkowe do i while__________________________________________________ 58

Ptla do _______________________________________________________________ 58

Ptla while_____________________________________________________________ 60

Ptla krokowa for _________________________________________________________ 62

Instrukcje break i continue _________________________________________________ 65

Podsumowanie ______________________________________________________________ 66

Pytania i zadania __________________________________________________________ 67

Pytania ________________________________________________________________ 67

wiczenia ______________________________________________________________ 67

Operacje na zmiennych __________________________________________ 69

Wnikliwy rzut oka na zmienne __________________________________________________ 69

Zasig zmiennych__________________________________________________________ 69

Zasig lokalny __________________________________________________________ 70

Zasig moduáowy ________________________________________________________ 72

Przesáanianie nazw _______________________________________________________ 73

Modyfikatory zmiennych_____________________________________________________ 74

Zmienne statyczne _______________________________________________________ 75

Staáe __________________________________________________________________ 76

Typy zmiennych _____________________________________________________________ 76

Modyfikatory typów liczbowych _______________________________________________ 77

Typy ze znakiem i bez znaku _______________________________________________ 77

Rozmiar typu caákowitego _________________________________________________ 78

Precyzja typu rzeczywistego _______________________________________________ 79

Skrócone nazwy _________________________________________________________ 80

Pomocne konstrukcje _______________________________________________________ 80

Instrukcja typedef_______________________________________________________ 80

Operator sizeof ________________________________________________________ 81

Rzutowanie _______________________________________________________________ 83

Proste rzutowanie________________________________________________________ 84

Operator static_cast ____________________________________________________ 86

Kalkulacje na liczbach_________________________________________________________ 88

Przydatne funkcje__________________________________________________________ 88

Funkcje potgowe _______________________________________________________ 88

Funkcje wykáadnicze i logarytmiczne _________________________________________ 89

Funkcje trygonometryczne_________________________________________________ 90

Liczby pseudolosowe _____________________________________________________ 91

Zaokrglanie liczb rzeczywistych ____________________________________________ 93

Inne funkcje ____________________________________________________________ 94

Znane i nieznane operatory __________________________________________________ 95

Dwa rodzaje ____________________________________________________________ 95

Sekrety inkrementacji i dekrementacji _______________________________________ 96

Sáówko o dzieleniu _______________________________________________________ 97

acuchy znaków ____________________________________________________________ 98

Napisy wedáug C++ ________________________________________________________ 99

Typy zmiennych tekstowych ______________________________________________ 100

Manipulowanie áacuchami znaków ___________________________________________ 100

Inicjalizacja ___________________________________________________________ 100

czenie napisów _______________________________________________________ 102

Pobieranie pojedynczych znaków ___________________________________________ 103

Wyra*enia logiczne __________________________________________________________ 105

Porównywanie wartoci zmiennych ___________________________________________ 105

Operatory logiczne ________________________________________________________ 105

Koniunkcja ____________________________________________________________ 106

Alternatywa ___________________________________________________________ 106

Negacja ______________________________________________________________ 106

Zestawienie operatorów logicznych _________________________________________ 107

Typ bool________________________________________________________________ 108

Operator warunkowy ______________________________________________________ 109

Podsumowanie _____________________________________________________________ 110

Pytania i zadania _________________________________________________________ 111

Pytania _______________________________________________________________ 111

wiczenia _____________________________________________________________ 111

Záo*one zmienne ______________________________________________ 113

Tablice ___________________________________________________________________ 113

Proste tablice ____________________________________________________________ 113

Inicjalizacja tablicy______________________________________________________ 115

Przykáad wykorzystania tablicy ____________________________________________ 116

Wicej wymiarów _________________________________________________________ 119

Deklaracja i inicjalizacja__________________________________________________ 120

Tablice w tablicy________________________________________________________ 121

Nowe typy danych __________________________________________________________ 123

Wyliczania nadszedá czas ___________________________________________________ 123

Przydatnoü praktyczna __________________________________________________ 123

Definiowanie typu wyliczeniowego __________________________________________ 125

U*ycie typu wyliczeniowego _______________________________________________ 126

Zastosowania __________________________________________________________ 126

Kompleksowe typy ________________________________________________________ 128

Typy strukturalne i ich definiowanie ________________________________________ 128

Struktury w akcji _______________________________________________________ 129

Odrobina formalizmu - nie zaszkodzi! _______________________________________ 131

Przykáad wykorzystania struktury __________________________________________ 131

Unie _________________________________________________________________ 136

Wikszy projekt ____________________________________________________________ 137

Projektowanie ____________________________________________________________ 138

Struktury danych w aplikacji ______________________________________________ 138

Dziaáanie programu _____________________________________________________ 139

Interfejs u*ytkownika____________________________________________________ 141

Kodowanie ______________________________________________________________ 142

Kilka moduáów i wáasne nagáówki___________________________________________ 142

Treü pliku nagáówkowego ________________________________________________ 144

Wáaciwy kod gry _______________________________________________________ 145

Zaczynamy __________________________________________________________________ 146

Deklarujemy zmienne __________________________________________________________ 147

Funkcja StartGry() ___________________________________________________________ 147

Funkcja Ruch() _______________________________________________________________ 147

Funkcja RysujPlansze() _______________________________________________________ 152

Funkcja main(), czyli skáadamy program ____________________________________ 155

Uroki kompilacji ________________________________________________________ 156

Uruchamiamy aplikacj __________________________________________________ 158

Wnioski _________________________________________________________________ 158

Dziwaczne projektowanie_________________________________________________ 158

Doü skomplikowane algorytmy____________________________________________ 159

Organizacja kodu _______________________________________________________ 159

Podsumowanie _____________________________________________________________ 159

Pytania i zadania _________________________________________________________ 160

Pytania _______________________________________________________________ 160

wiczenia _____________________________________________________________ 160

Obiekty______________________________________________________ 161

Przedstawiamy klasy i obiekty _________________________________________________ 161

Skrawek historii __________________________________________________________ 161

Maáo zachcajce pocztki ________________________________________________ 161

Wy*szy poziom_________________________________________________________ 162

Skostniaáe standardy ____________________________________________________ 163

Obiektów czar__________________________________________________________ 163

Co dalej? _____________________________________________________________ 163

Pierwszy kontakt _________________________________________________________ 164

Obiektowy wiat ________________________________________________________ 164

Wszystko jest obiektem ________________________________________________________ 164

Okrelenie obiektu_____________________________________________________________ 165

Obiekt obiektowi nierówny ______________________________________________________ 166

Co na to C++? _________________________________________________________ 167

Definiowanie klas _____________________________________________________________ 167

Implementacja metod __________________________________________________________ 168

Tworzenie obiektów____________________________________________________________ 168

Obiekty i klasy w C++ _______________________________________________________ 169

Klasa jako typ obiektowy ___________________________________________________ 169

Dwa etapy okrelania klasy _______________________________________________ 170

Definicja klasy _________________________________________________________ 170

Kontrola dostpu do skáadowych klasy _____________________________________________ 171

Deklaracje pól ________________________________________________________________ 174

Metody i ich prototypy__________________________________________________________ 175

Konstruktory i destruktory ______________________________________________________ 176

Co jeszcze? _________________________________________________________________ 178

Implementacja metod ___________________________________________________ 178

Wska(nik this _______________________________________________________________ 179

Praca z obiektami _________________________________________________________ 179

Zmienne obiektowe _____________________________________________________ 180

Deklarowanie zmiennych i tworzenie obiektów _______________________________________ 180

)

onglerka obiektami ___________________________________________________________ 180

Dostp do skáadników __________________________________________________________ 182

Niszczenie obiektów ___________________________________________________________ 182

Podsumowanie _______________________________________________________________ 183

Wska(niki na obiekty ____________________________________________________ 183

Deklarowanie wska(ników i tworzenie obiektów ______________________________________ 184

Jeden dla wszystkich, wszystkie do jednego _________________________________________ 184

Dostp do skáadników __________________________________________________________ 185

Niszczenie obiektów ___________________________________________________________ 186

Stosowanie wska(ników na obiekty _______________________________________________ 187

Podsumowanie _____________________________________________________________ 188

Pytania i zadania _________________________________________________________ 188

Pytania _______________________________________________________________ 188

wiczenia _____________________________________________________________ 189

Programowanie obiektowe ______________________________________ 191

Dziedziczenie ______________________________________________________________ 191

O powstawaniu klas drog doboru naturalnego __________________________________ 192

Od prostoty do komplikacji, czyli ewolucja ___________________________________ 193

Z klasy bazowej do pochodnej, czyli dziedzictwo przodków ______________________ 194

Obiekt o kilku klasach, czyli zmiennoü gatunkowa_____________________________ 195

Dziedziczenie w C++ ______________________________________________________ 195

Podstawy _____________________________________________________________ 195

Definicja klasy bazowej i specyfikator protected_____________________________________ 195

Definicja klasy pochodnej _______________________________________________________ 197

Dziedziczenie pojedyncze_________________________________________________ 198

Proste przypadki ______________________________________________________________ 198

Sztafeta pokole ______________________________________________________________ 199

Páaskie hierarchie _____________________________________________________________ 201

Podsumowanie _______________________________________________________________ 202

Dziedziczenie wielokrotne ________________________________________________ 202

Puáapki dziedziczenia ____________________________________________________ 202

Co nie jest dziedziczone? _______________________________________________________ 202

Obiekty kompozytowe __________________________________________________________ 203

Metody wirtualne i polimorfizm ________________________________________________ 204

Wirtualne funkcje skáadowe _________________________________________________ 204

To samo, ale inaczej ____________________________________________________ 204

Deklaracja metody wirtualnej ____________________________________________________ 205

Przedefiniowanie metody wirtualnej _______________________________________________ 206

Pojedynek: metody wirtualne przeciwko zwykáym ____________________________________ 206

Wirtualny destruktor ___________________________________________________________ 207

Zaczynamy od zera… dosáownie____________________________________________ 209

Czysto wirtualne metody________________________________________________________ 210

Abstrakcyjne klasy bazowe ______________________________________________________ 210

Polimorfizm______________________________________________________________ 211

Ogólny kod do szczególnych zastosowa_____________________________________ 212

Sprowadzanie do bazy _________________________________________________________ 212

Klasy wiedz same, co nale*y robiü _______________________________________________ 215

Typy pod kontrol ______________________________________________________ 217

Operator dynamic_cast ________________________________________________________ 217

typeid i informacje o typie podczas dziaáania programu _______________________________ 219

Alternatywne rozwizania _______________________________________________________ 221

Projektowanie zorientowane obiektowo __________________________________________ 223

Rodzaje obiektów _________________________________________________________ 223

Singletony ____________________________________________________________ 224

Przykáady wykorzystania ________________________________________________________ 224

Praktyczna implementacja z u*yciem skáadowych statycznych___________________________ 225

Obiekty zasadnicze______________________________________________________ 228

Obiekty narzdziowe ____________________________________________________ 228

Definiowanie odpowiednich klas ______________________________________________ 231

Abstrakcja ____________________________________________________________ 231

Identyfikacja klas _____________________________________________________________ 232

Abstrakcja klasy ______________________________________________________________ 233

Skáadowe interfejsu klasy _______________________________________________________ 234

Implementacja _________________________________________________________ 234

Zwizki midzy klasami ____________________________________________________ 235

Dziedziczenie i zawieranie si _____________________________________________ 235

Zwizek generalizacji-specjalizacji ________________________________________________ 235

Zwizek agregacji _____________________________________________________________ 236

Odwieczny problem: byü czy mieü?________________________________________________ 237

Zwizek asocjacji _______________________________________________________ 237

Krotnoü zwizku______________________________________________________________ 238

Tam i (byü mo*e) z powrotem ___________________________________________________ 239

Podsumowanie _____________________________________________________________ 240

Pytania i zadania _________________________________________________________ 240

Pytania _______________________________________________________________ 241

wiczenia _____________________________________________________________ 241

Wska(niki____________________________________________________ 243

Ku pamici ________________________________________________________________ 244

Rodzaje pamici __________________________________________________________ 244

Rejestry procesora ______________________________________________________ 244

Zmienne przechowywane w rejestrach _____________________________________________ 245

Dostp do rejestrów ___________________________________________________________ 246

Pamiü operacyjna ______________________________________________________ 246

Skd si bierze pamiü operacyjna? _______________________________________________ 246

Pamiü wirtualna ______________________________________________________________ 247

Pamiü trwaáa__________________________________________________________ 247

Organizacja pamici operacyjnej _____________________________________________ 247

Adresowanie pamici ____________________________________________________ 248

Epoka niewygodnych segmentów _________________________________________________ 248

Páaski model pamici ___________________________________________________________ 249

Stos i sterta ___________________________________________________________ 249

Czym jest stos? _______________________________________________________________ 249

O stercie ____________________________________________________________________ 250

Wska(niki na zmienne _______________________________________________________ 250

U*ywanie wska(ników na zmienne____________________________________________ 250

Deklaracje wska(ników __________________________________________________ 252

Nieod*aáowany spór o gwiazdk __________________________________________________ 252

Wska(niki do staáych ___________________________________________________________ 253

Staáe wska(niki _______________________________________________________________ 254

Podsumowanie deklaracji wska(ników _____________________________________________ 255

Niezbdne operatory ____________________________________________________ 256

Pobieranie adresu i dereferencja __________________________________________________ 256

Wyáuskiwanie skáadników _______________________________________________________ 257

Konwersje typów wska(nikowych __________________________________________ 258

Matka wszystkich wska(ników____________________________________________________ 259

Przywracanie do stanu u*ywalnoci _______________________________________________ 260

Midzy palcami kompilatora _____________________________________________________ 260

Wska(niki i tablice ______________________________________________________ 261

Tablice jednowymiarowe w pamici _______________________________________________ 261

Wska(nik w ruchu _____________________________________________________________ 262

Tablice wielowymiarowe w pamici ________________________________________________ 263

acuchy znaków w stylu C______________________________________________________ 263

Przekazywanie wska(ników do funkcji _______________________________________ 265

Dane otrzymywane poprzez parametry_____________________________________________ 265

Zapobiegamy niepotrzebnemu kopiowaniu __________________________________________ 266

Dynamiczna alokacja pamici _______________________________________________ 268

Przydzielanie pamici dla zmiennych ________________________________________ 268

Alokacja przy pomocy new_______________________________________________________ 268

Zwalnianie pamici przy pomocy delete ___________________________________________ 269

Nowe jest lepsze ______________________________________________________________ 270

Dynamiczne tablice _____________________________________________________ 270

Tablice jednowymiarowe ________________________________________________________ 271

Opakowanie w klas ___________________________________________________________ 272

Tablice wielowymiarowe ________________________________________________________ 274

Referencje ______________________________________________________________ 277

Typy referencyjne ______________________________________________________ 278

Deklarowanie referencji_________________________________________________________ 278

Prawo staáoci referencji ________________________________________________________ 278

Referencje i funkcje _____________________________________________________ 279

Parametry przekazywane przez referencje __________________________________________ 279

Zwracanie referencji ___________________________________________________________ 280

Wska(niki do funkcji _________________________________________________________ 281

Cechy charakterystyczne funkcji _____________________________________________ 282

Typ wartoci zwracanej przez funkcj _______________________________________ 282

Instrukcja czy wyra*enie________________________________________________________ 283

Konwencja wywoáania ___________________________________________________ 283

O czym mówi konwencja wywoáania? ______________________________________________ 284

Typowe konwencje wywoáania ___________________________________________________ 285

Nazwa funkcji __________________________________________________________ 286

Rozterki kompilatora i linkera ____________________________________________________ 286

Parametry funkcji _______________________________________________________ 286

U*ywanie wska(ników do funkcji _____________________________________________ 287

Typy wska(ników do funkcji_______________________________________________ 287

Wáasnoci wyró*niajce funkcj __________________________________________________ 287

Typ wska(nika do funkcji _______________________________________________________ 287

Wska(niki do funkcji w C++ ______________________________________________ 288

Od funkcji do wska(nika na ni ___________________________________________________ 288

Specjalna konwencja___________________________________________________________ 289

Skáadnia deklaracji wska(nika do funkcji ___________________________________________ 290

Wska(niki do funkcji w akcji _____________________________________________________ 290

Przykáad wykorzystania wska(ników do funkcji_______________________________________ 291

Zastosowania __________________________________________________________ 295

Podsumowanie _____________________________________________________________ 295

Pytania i zadania _________________________________________________________ 296

Pytania _______________________________________________________________ 296

wiczenia _____________________________________________________________ 296

ZAAWANSOWANE C++ _______________________________ 299

Preprocesor __________________________________________________ 301

Pomocnik kompilatora _______________________________________________________ 301

Gdzie on jest…? __________________________________________________________ 302

Zwyczajowy przebieg budowania programu __________________________________ 302

Dodajemy preprocesor ___________________________________________________ 303

Dziaáanie preprocesora _____________________________________________________ 304

Dyrektywy ____________________________________________________________ 304

Bez rednika _________________________________________________________________ 304

Ciekawostka: sekwencje trójznakowe ______________________________________________ 305

Preprocesor a reszta kodu ________________________________________________ 306

Makra ____________________________________________________________________ 307

Proste makra ____________________________________________________________ 307

Definiowianie prostych makr ______________________________________________ 307

Zastpowanie wikszych fragmentów kodu _________________________________________ 308

W kilku linijkach ____________________________________________________________ 309

Makra korzystajce z innych makr ________________________________________________ 309

Pojedynek: makra kontra staáe ____________________________________________ 310

Makra nie s zmiennymi ________________________________________________________ 310

Zasig ____________________________________________________________________ 310

Miejsce w pamici i adres _____________________________________________________ 310

Typ ______________________________________________________________________ 311

Efekty skáadniowe _____________________________________________________________ 311

rednik ___________________________________________________________________ 311

Nawiasy i priorytety operatorów________________________________________________ 312

Dygresja: odpowied( na pytanie o sens *ycia _____________________________________ 313

Predefiniowane makra kompilatora _________________________________________ 314

Numer linii i nazwa pliku ________________________________________________________ 314

Numer wiersza _____________________________________________________________ 314

Nazwa pliku z kodem ________________________________________________________ 315

Dyrektywa #line ___________________________________________________________ 315

Data i czas___________________________________________________________________ 315

Czas kompilacji_____________________________________________________________ 315

Czas modyfikacji pliku _______________________________________________________ 316

Typ kompilatora ______________________________________________________________ 316

Inne nazwy __________________________________________________________________ 316

Makra parametryzowane ___________________________________________________ 316

Definiowanie parametrycznych makr ________________________________________ 317

Kilka przykáadów ______________________________________________________________ 318

Wzory matematyczne ________________________________________________________ 318

Skracanie zapisu____________________________________________________________ 318

Operatory preprocesora ________________________________________________________ 319

Sklejacz __________________________________________________________________ 319

Operator áacuchujcy _______________________________________________________ 319

Niebezpieczestwa makr _________________________________________________ 320

Brak kontroli typów ____________________________________________________________ 320

Parokrotne obliczanie argumentów ________________________________________________ 321

Priorytety operatorów __________________________________________________________ 321

Zalety makrodefinicji ____________________________________________________ 322

Efektywnoü _________________________________________________________________ 322

Funkcje inline ______________________________________________________________ 322

Makra kontra funkcje inline ___________________________________________________ 323

Brak kontroli typów ____________________________________________________________ 323

Ciekawostka: funkcje szablonowe ______________________________________________ 323

Zastosowania makr _____________________________________________________ 324

Nie korzystajmy z makr, lecz z obiektów const ____________________________________ 324

Nie korzystajmy z makr, lecz z (szablonowych) funkcji inline _________________________ 324

Korzystajmy z makr, by zastpowaü powtarzajce si fragmenty kodu__________________ 324

Korzystajmy z makr, by skracaü sobie zapis ______________________________________ 324

Korzystajmy z makr zgodnie z ich przeznaczeniem _________________________________ 325

Kontrola procesu kompilacji ___________________________________________________ 325

Dyrektywy #ifdef i #ifndef ________________________________________________ 326

Puste makra ___________________________________________________________ 326

Dyrektywa #ifdef ______________________________________________________ 326

Dyrektywa #ifndef _____________________________________________________ 327

Dyrektywa #else _______________________________________________________ 327

Dyrektywa warunkowa #if _________________________________________________ 328

Konstruowanie warunków ________________________________________________ 328

Operator defined _____________________________________________________________ 328

Záo*one warunki ______________________________________________________________ 329

Skomplikowane warunki kompilacji _________________________________________ 329

Zagnie*d*anie dyrektyw ________________________________________________________ 329

Dyrektywa #elif______________________________________________________________ 330

Dyrektywa #error ______________________________________________________ 330

Reszta dobroci _____________________________________________________________ 331

Doáczanie plików _________________________________________________________ 331

Dwa warianty #include __________________________________________________ 331

Z nawiasami ostrymi ___________________________________________________________ 331

Z cudzysáowami_______________________________________________________________ 332

Który wybraü? ________________________________________________________________ 332

Nasz czy biblioteczny ________________________________________________________ 332

cie*ki wzgldne____________________________________________________________ 333

Zabezpieczenie przed wielokrotnym doáczaniem ______________________________ 333

Tradycyjne rozwizanie _________________________________________________________ 333

Pomaga kompilator ____________________________________________________________ 334

Polecenia zale*ne od kompilatora ____________________________________________ 334

Dyrektywa #pragma _____________________________________________________ 334

Wa*niejsze parametry #pragma w Visual C++ .NET ____________________________ 334

Komunikaty kompilacji _________________________________________________________ 335

message __________________________________________________________________ 335

deprecated _______________________________________________________________ 336

warning __________________________________________________________________ 336

Funkcje inline ________________________________________________________________ 337

auto_inline ______________________________________________________________ 337

inline_recursion __________________________________________________________ 338

inline_depth______________________________________________________________ 338

Inne________________________________________________________________________ 339

comment __________________________________________________________________ 339

once _____________________________________________________________________ 339

Podsumowanie _____________________________________________________________ 340

Pytania i zadania _________________________________________________________ 340

Pytania _______________________________________________________________ 340

wiczenia _____________________________________________________________ 341

Zaawansowana obiektowoü _____________________________________ 343

O przyja(ni ________________________________________________________________ 343

Funkcje zaprzyja(nione ____________________________________________________ 345

Deklaracja przyja(ni z funkcj _____________________________________________ 345

Na co jeszcze trzeba zwróciü uwag ________________________________________ 346

Funkcja zaprzyja(niona nie jest metod ____________________________________________ 346

Deklaracja przyja(ni jest te* deklaracj funkcji ______________________________________ 347

Deklaracja przyja(ni jako prototyp funkcji ________________________________________ 347

Dodajemy definicj __________________________________________________________ 347

Klasy zaprzyja(nione ______________________________________________________ 348

Przyja( z pojedynczymi metodami _________________________________________ 348

Przyja( z caá klas ____________________________________________________ 349

Jeszcze kilka uwag ________________________________________________________ 351

Cechy przyja(ni klas w C++ ______________________________________________ 351

Przyja( nie jest automatycznie wzajemna__________________________________________ 351

Przyja( nie jest przechodnia ____________________________________________________ 351

Przyja( nie jest dziedziczna_____________________________________________________ 351

Zastosowania __________________________________________________________ 352

Wykorzystanie przyja(ni z funkcj ________________________________________________ 352

Korzyci czerpane z przyja(ni klas ________________________________________________ 352

Konstruktory w szczegóáach ___________________________________________________ 352

Maáa powtórka ___________________________________________________________ 352

Konstruktory __________________________________________________________ 353

Cechy konstruktorów___________________________________________________________ 353

Definiowanie _________________________________________________________________ 353

Przeci*anie _______________________________________________________________ 353

Konstruktor domylny _______________________________________________________ 354

Kiedy wywoáywany jest konstruktor _______________________________________________ 355

Niejawne wywoáanie _________________________________________________________ 355

Jawne wywoáanie ___________________________________________________________ 355

Inicjalizacja ___________________________________________________________ 355

Kiedy si odbywa _____________________________________________________________ 355

Jak wyglda__________________________________________________________________ 355

Inicjalizacja typów podstawowych ______________________________________________ 356

Agregaty __________________________________________________________________ 356

Inicjalizacja konstruktorem ___________________________________________________ 356

Listy inicjalizacyjne________________________________________________________ 357

Inicjalizacja skáadowych __________________________________________________ 357

Wywoáanie konstruktora klasy bazowej ______________________________________ 358

Konstruktory kopiujce ____________________________________________________ 359

O kopiowaniu obiektów __________________________________________________ 359

Pole po polu__________________________________________________________________ 360

Gdy to nie wystarcza… _________________________________________________________ 360

Konstruktor kopiujcy ___________________________________________________ 361

Do czego sáu*y konstruktor kopiujcy ______________________________________________ 361

Konstruktor kopiujcy a przypisanie - ró*nica maáa lecz wa*na________________________ 362

Dlaczego konstruktor kopiujcy ________________________________________________ 362

Definiowanie konstruktora kopiujcego ____________________________________________ 362

Inicjalizator klasy CIntArray __________________________________________________ 363

Konwersje_______________________________________________________________ 363

Sposoby dokonywania konwersji ___________________________________________ 364

Konstruktory konwertujce ______________________________________________________ 365

Konstruktor z jednym obowizkowym parametrem _________________________________ 365

Sáówko explicit ___________________________________________________________ 367

Operatory konwersji ___________________________________________________________ 367

Stwarzamy sobie problem ____________________________________________________ 368

Definiowanie operatora konwersji ______________________________________________ 368

Wybór odpowiedniego sposobu ____________________________________________ 369

Przeci*anie operatorów ______________________________________________________ 370

Cechy operatorów ________________________________________________________ 371

Liczba argumentów _____________________________________________________ 371

Operatory jednoargumentowe____________________________________________________ 372

Operatory dwuargumentowe_____________________________________________________ 372

Priorytet ______________________________________________________________ 372

cznoü ______________________________________________________________ 373

Operatory w C++ _________________________________________________________ 373

Operatory arytmetyczne _________________________________________________ 374

Unarne operatory arytmetyczne __________________________________________________ 374

Inkrementacja i dekrementacja ________________________________________________ 374

Binarne operatory arytmetyczne __________________________________________________ 375

Operatory bitowe _______________________________________________________ 375

Operacje logiczno-bitowe _______________________________________________________ 375

Przesunicie bitowe ____________________________________________________________ 376

Operatory strumieniowe ______________________________________________________ 376

Operatory porównania ___________________________________________________ 376

Operatory logiczne ______________________________________________________ 377

Operatory przypisania ___________________________________________________ 377

Zwykáy operator przypisania _____________________________________________________ 378

L-wartoü i r-wartoü ________________________________________________________ 378

Rezultat przypisania _________________________________________________________ 379

Uwaga na przypisanie w miejscu równoci ________________________________________ 379

Záo*one operatory przypisania ___________________________________________________ 380

Operatory wska(nikowe __________________________________________________ 380

Pobranie adresu ______________________________________________________________ 380

Dostp do pamici poprzez wska(nik ______________________________________________ 381

Dereferencja _______________________________________________________________ 381

Indeksowanie ______________________________________________________________ 381

Operatory pamici ______________________________________________________ 382

Alokacja pamici ______________________________________________________________ 382

new ______________________________________________________________________ 382

new[] ____________________________________________________________________ 382

Zwalnianie pamici ____________________________________________________________ 383

delete ___________________________________________________________________ 383

delete[] _________________________________________________________________ 383

Operator sizeof ______________________________________________________________ 383

Ciekawostka: operator __alignof ______________________________________________ 384

Operatory typów _______________________________________________________ 384

Operatory rzutowania __________________________________________________________ 384

static_cast ______________________________________________________________ 384

dynamic_cast______________________________________________________________ 385

reinterpret_cast __________________________________________________________ 385

const_cast _______________________________________________________________ 386

Rzutowanie w stylu C ________________________________________________________ 386

Rzutowanie funkcyjne________________________________________________________ 386

Operator typeid ______________________________________________________________ 387

Operatory dostpu do skáadowych __________________________________________ 387

Wyáuskanie z obiektu __________________________________________________________ 387

Wyáuskanie ze wska(nika _______________________________________________________ 388

Operator zasigu ______________________________________________________________ 388

Pozostaáe operatory _____________________________________________________ 388

Nawiasy okrgáe ______________________________________________________________ 388

Operator warunkowy ___________________________________________________________ 389

Przecinek ____________________________________________________________________ 389

Nowe znaczenia dla operatorów ______________________________________________ 389

Funkcje operatorowe ____________________________________________________ 389

Kilka uwag wstpnych __________________________________________________________ 390

Ogólna skáadnia funkcji operatorowej____________________________________________ 390

Operatory, które mo*emy przeci*aü ____________________________________________ 390

Czego nie mo*emy zmieniü ___________________________________________________ 391

Pozostaáe sprawy ___________________________________________________________ 391

Definiowanie przeci*onych wersji operatorów _______________________________________ 391

Operator jako funkcja skáadowa klasy ___________________________________________ 392

Problem przemiennoci_______________________________________________________ 393

Operator jako zwykáa funkcja globalna___________________________________________ 393

Operator jako zaprzyja(niona funkcja globalna ____________________________________ 394

Sposoby przeci*ania operatorów __________________________________________ 394

Najczciej stosowane przeci*enia _______________________________________________ 394

Typowe operatory jednoargumentowe ___________________________________________ 395

Inkrementacja i dekrementacja ________________________________________________ 396

Typowe operatory dwuargumentowe ____________________________________________ 397

Operatory przypisania _______________________________________________________ 399

Operator indeksowania _________________________________________________________ 402

Operatory wyáuskania __________________________________________________________ 404

Operator -> _______________________________________________________________ 404

Ciekawostka: operator ->*____________________________________________________ 406

Operator wywoáania funkcji______________________________________________________ 407

Operatory zarzdzania pamici __________________________________________________ 409

Lokalne wersje operatorów____________________________________________________ 410

Globalna redefinicja _________________________________________________________ 411

Operatory konwersji ___________________________________________________________ 412

Wskazówki dla pocztkujcego przeci*acza __________________________________ 412

Zachowujmy sens, logik i konwencj _____________________________________________ 412

Symbole operatorów powinny odpowiadaü ich znaczeniom ___________________________ 412

Zapewnijmy analogiczne zachowania jak dla typów wbudowanych _____________________ 413

Nie przeci*ajmy wszystkiego ____________________________________________________ 413

Wska(niki do skáadowych klasy ________________________________________________ 414

Wska(nik na pole klasy ____________________________________________________ 414

Wska(nik do pola wewntrz obiektu ________________________________________ 414

Wska(nik na obiekt ____________________________________________________________ 414

Pokazujemy na skáadnik obiektu __________________________________________________ 415

Wska(nik do pola wewntrz klasy __________________________________________ 415

Miejsce pola w definicji klasy ____________________________________________________ 416

Pobieranie wska(nika __________________________________________________________ 417

Deklaracja wska(nika na pole klasy _______________________________________________ 418

U*ycie wska(nika _____________________________________________________________ 419

Wska(nik na metod klasy __________________________________________________ 420

Wska(nik do statycznej metody klasy _______________________________________ 420

Wska(nik do niestatycznej metody klasy_____________________________________ 421

Wykorzystanie wska(ników na metody _____________________________________________ 421

Deklaracja wska(nika ________________________________________________________ 421

Pobranie wska(nika na metod klasy ____________________________________________ 423

U*ycie wska(nika ___________________________________________________________ 423

Ciekawostka: wska(nik do metody obiektu__________________________________________ 423

Wska(nik na metod obiektu konkretnej klasy ____________________________________ 425

Wska(nik na metod obiektu dowolnej klasy ______________________________________ 427

Podsumowanie _____________________________________________________________ 430

Pytania i zadania _________________________________________________________ 430

Pytania _______________________________________________________________ 430

wiczenia _____________________________________________________________ 431

Wyjtki______________________________________________________ 433

Mechanizm wyjtków w C++ __________________________________________________ 433

Tradycyjne metody obsáugi bádów ___________________________________________ 434

Dopuszczalne sposoby ___________________________________________________ 434

Zwracanie nietypowego wyniku __________________________________________________ 434

Specjalny rezultat___________________________________________________________ 435

Wady tego rozwizania_______________________________________________________ 435

Oddzielenie rezultatu od informacji o bádzie ________________________________________ 436

Wykorzystanie wska(ników ___________________________________________________ 436

U*ycie struktury ____________________________________________________________ 437

Niezbyt dobre wyjcia ___________________________________________________ 438

Wywoáanie zwrotne ____________________________________________________________ 438

Uwaga o wygodnictwie _______________________________________________________ 438

Uwaga o logice _____________________________________________________________ 439

Uwaga o niedostatku mechanizmów_____________________________________________ 439

Zakoczenie programu _________________________________________________________ 439

Wyjtki _________________________________________________________________ 439

Rzucanie i áapanie wyjtków ______________________________________________ 440

Blok try-catch _______________________________________________________________ 440

Instrukcja throw ______________________________________________________________ 441

Wdrówka wyjtku __________________________________________________________ 441

throw a return ____________________________________________________________ 441

Wáaciwy chwyt ________________________________________________________ 442

Kolejnoü bloków catch ________________________________________________________ 443

Dopasowywanie typu obiektu wyjtku ___________________________________________ 444

Szczegóáy przodem __________________________________________________________ 445

Zagnie*d*one bloki try-catch ___________________________________________________ 446

Záapanie i odrzucenie ________________________________________________________ 448

Blok catch(...), czyli chwytanie wszystkiego ____________________________________ 448

Odwijanie stosu ____________________________________________________________ 449

Midzy rzuceniem a záapaniem_______________________________________________ 449

Wychodzenie na wierzch _________________________________________________ 449

Porównanie throw z break i return _______________________________________________ 450

Wyjtek opuszcza funkcj _______________________________________________________ 450

Specyfikacja wyjtków _______________________________________________________ 451

Káamstwo nie popáaca ________________________________________________________ 451

Niezáapany wyjtek ____________________________________________________________ 453

Porzdki ______________________________________________________________ 454

Niszczenie obiektów lokalnych ___________________________________________________ 454

Wypadki przy transporcie _______________________________________________________ 454

Niedozwolone rzucenie wyjtku ________________________________________________ 454

Strefy bezwyjtkowe ________________________________________________________ 455

Skutki wypadku ____________________________________________________________ 456

Zarzdzanie zasobami w obliczu wyjtków _____________________________________ 456

Opakowywanie _________________________________________________________ 458

Destruktor wska(nika?… ________________________________________________________ 459

Sprytny wska(nik _____________________________________________________________ 459

Nieco uwag __________________________________________________________________ 461

Ró*ne typy wska(ników ______________________________________________________ 461

U*ywajmy tylko tam, gdzie to konieczne _________________________________________ 461

Co ju* zrobiono za nas ___________________________________________________ 461

Klasa std::auto_ptr __________________________________________________________ 461

Pliki w Bibliotece Standardowej___________________________________________________ 462

Wykorzystanie wyjtków _____________________________________________________ 463

Wyjtki w praktyce________________________________________________________ 463

Projektowanie klas wyjtków ______________________________________________ 464

Definiujemy klas _____________________________________________________________ 464

Hierarchia wyjtków ___________________________________________________________ 465

Organizacja obsáugi wyjtków _____________________________________________ 466

Umiejscowienie bloków try i catch _______________________________________________ 466

Kod warstwowy_____________________________________________________________ 466

Podawanie bádów wy*ej _____________________________________________________ 467

Dobre wyporodkowanie______________________________________________________ 467

Chwytanie wyjtków w blokach catch _____________________________________________ 468

Szczegóáy przodem - druga odsáona _____________________________________________ 468

Lepiej referencj____________________________________________________________ 469

Uwagi ogólne ____________________________________________________________ 469

Korzyci ze stosowania wyjtków __________________________________________ 469

Informacja o bádzie w ka*dej sytuacji _____________________________________________ 469

Uproszczenie kodu ____________________________________________________________ 470

Wzrost niezawodnoci kodu _____________________________________________________ 470

Nadu*ywanie wyjtków __________________________________________________ 471

Nie u*ywajmy ich tam, gdzie wystarcz inne konstrukcje ______________________________ 471

Nie u*ywajmy wyjtków na siá __________________________________________________ 471

Podsumowanie _____________________________________________________________ 472

Pytania i zadania _________________________________________________________ 472

Pytania _______________________________________________________________ 472

wiczenia _____________________________________________________________ 472

Szablony ____________________________________________________ 473

Podstawy _________________________________________________________________ 474

Idea szablonów___________________________________________________________ 474

cisáoü C++ powodem bólu gáowy _________________________________________ 474

Dwa typowe problemy__________________________________________________________ 474

Problem 1: te same funkcje dla ró*nych typów ____________________________________ 474

Problem 2: klasy operujce na dowolnych typach danych ____________________________ 475

Mo*liwe rozwizania ___________________________________________________________ 475

Wykorzystanie preprocesora __________________________________________________ 475

U*ywanie ogólnych typów ____________________________________________________ 475

Szablony jako rozwizanie ________________________________________________ 476

Kod niezale*ny od typu _________________________________________________________ 476

Kompilator to potrafi ___________________________________________________________ 476

Skáadnia szablonu___________________________________________________________ 476

Co mo*e byü szablonem ______________________________________________________ 477

Szablony funkcji __________________________________________________________ 478

Definiowanie szablonu funkcji _____________________________________________ 478

Podstawowa definicja szablonu funkcji _____________________________________________ 478

Stosowalnoü definicji________________________________________________________ 479

Parametr szablonu u*yty w ciele funkcji__________________________________________ 479

Parametr szablonu i parametr funkcji____________________________________________ 480

Kilka parametrów szablonu ___________________________________________________ 480

Specjalizacja szablonu funkcji ____________________________________________________ 481

Wyjtkowy przypadek _______________________________________________________ 482

Ciekawostka: specjalizacja czciowa szablonu funkcji ______________________________ 482

Wywoáywanie funkcji szablonowej __________________________________________ 483

Jawne okrelenie typu __________________________________________________________ 484

Wywoáywanie konkretnej wersji funkcji szablonowej ________________________________ 484

U*ycie wska(nika na funkcj szablonow _________________________________________ 484

Dedukcja typu na podstawie argumentów funkcji_____________________________________ 485

Jak to dziaáa _______________________________________________________________ 485

Dedukcja przy wykorzystaniu kilku parametrów szablonu ____________________________ 486

Szablony klas ____________________________________________________________ 487

Definicja szablonu klas___________________________________________________ 487

Prosty przykáad tablicy _________________________________________________________ 488

Definiujemy szablon _________________________________________________________ 489

Implementacja metod poza definicj ____________________________________________ 490

Korzystanie z tablicy_________________________________________________________ 491

Dziedziczenie i szablony klas_____________________________________________________ 492

Dziedziczenie klas szablonowych _______________________________________________ 492

Dziedziczenie szablonów klas __________________________________________________ 493

Deklaracje w szablonach klas ____________________________________________________ 494

Aliasy typedef _____________________________________________________________ 494

Deklaracje przyja(ni _________________________________________________________ 495

Szablony funkcji skáadowych __________________________________________________ 495

Korzystanie z klas szablonowych ___________________________________________ 497

Tworzenie obiektów____________________________________________________________ 497

Stwarzamy obiekt klasy szablonowej ____________________________________________ 497

Co si dzieje, gdy tworzymy obiekt szablonu klasy _________________________________ 498

Funkcje operujce na obiektach klas szablonowych ___________________________________ 500

Specjalizacje szablonów klas ______________________________________________ 501

Specjalizowanie szablonu klasy___________________________________________________ 501

Wáasna klasa specjalizowana __________________________________________________ 501

Specjalizacja metody klasy____________________________________________________ 503

Czciowa specjalizacja szablonu klasy_____________________________________________ 504

Problem natury tablicowej ____________________________________________________ 504

Rozwizanie: przypadek szczególniejszy, ale nie za bardzo___________________________ 504

Domylne parametry szablonu klasy_______________________________________________ 506

Typowy typ ________________________________________________________________ 506

Skorzystanie z poprzedniego parametru _________________________________________ 508

Wicej informacji ___________________________________________________________ 508

Parametry szablonów ______________________________________________________ 508

Typy _________________________________________________________________ 509

Przypominamy banalny przykáad__________________________________________________ 509

class zamiast typename ________________________________________________________ 510

Staáe _________________________________________________________________ 510

U*ycie parametrów pozatypowych ________________________________________________ 510

Przykáad szablonu klasy ______________________________________________________ 511

Przykáad szablonu funkcji _____________________________________________________ 512

Dwie wartoci, dwa ró*ne typy _________________________________________________ 512

Ograniczenia dla parametrów pozatypowych ________________________________________ 513

Wska(niki jako parametry szablonu _____________________________________________ 513

Inne restrykcje _____________________________________________________________ 514

Szablony parametrów ___________________________________________________ 514

Idc za potrzeb ______________________________________________________________ 514

Dodatkowy parametr: typ wewntrznej tablicy ____________________________________ 515

Drobna niedogodnoü ________________________________________________________ 516

Deklarowanie szablonowych parametrów szablonów __________________________________ 516

Problemy z szablonami_____________________________________________________ 517

Uáatwienia dla kompilatora________________________________________________ 517

Nawiasy ostre ________________________________________________________________ 518

Nieoczywisty przykáad _______________________________________________________ 518

Ciekawostka: dlaczego tak si dzieje ____________________________________________ 518

Nazwy zale*ne________________________________________________________________ 519

Sáowo kluczowe typename ____________________________________________________ 520

Ciekawostka: konstrukcje ::template, .template i ->template ______________________ 521

Organizacja kodu szablonów ______________________________________________ 522

Model wáczania ______________________________________________________________ 522

Zwykáy kod ________________________________________________________________ 523

Próbujemy zastosowaü szablony _______________________________________________ 523

Rozwizanie - istota modelu wáczania __________________________________________ 524

Konkretyzacja jawna ___________________________________________________________ 525

Instrukcje jawnej konkretyzacji ________________________________________________ 525

Wady i zalety konkretyzacji jawnej _____________________________________________ 525

Model separacji _______________________________________________________________ 526

Szablony eksportowane ______________________________________________________ 526

Nie ma ró*y bez kolców ______________________________________________________ 527

Wspóápraca modelu wáczania i separacji_________________________________________ 527

Zastosowania szablonów _____________________________________________________ 529

Zastpienie makrodefinicji __________________________________________________ 529

Szablon funkcji i makro __________________________________________________ 529

Pojedynek na szczycie ___________________________________________________ 530

Starcie drugie: problem dopasowania tudzie* wydajnoci ______________________________ 530

Jak zadziaáa szablon _________________________________________________________ 530

Jak zadziaáa makro __________________________________________________________ 531

Wynik ____________________________________________________________________ 531

Starcie trzecie: problem rozwinicia albo poprawnoci _________________________________ 531

Jak zadziaáa szablon _________________________________________________________ 531

Jak zadziaáa makro __________________________________________________________ 532

Wynik ____________________________________________________________________ 532

Konkluzje____________________________________________________________________ 532

Struktury danych _________________________________________________________ 532

Krotki ________________________________________________________________ 533

Przykáad pary ________________________________________________________________ 533

Definicja szablonu___________________________________________________________ 533

Pomocna funkcja ___________________________________________________________ 534

Dalsze usprawnienia _________________________________________________________ 535

Trójki i wy*sze krotki __________________________________________________________ 536

Pojemniki _____________________________________________________________ 537

Przykáad klasy kontenera - stos __________________________________________________ 538

Czym jest stos _____________________________________________________________ 538

Definicja szablonu klasy ______________________________________________________ 538

Korzystanie z szablonu _______________________________________________________ 539

Programowanie ogólne _________________________________________________________ 540

Podsumowanie _____________________________________________________________ 540

Pytania i zadania _________________________________________________________ 541

Pytania _______________________________________________________________ 541

wiczenia _____________________________________________________________ 541

INNE _____________________________________________ 543

Indeks ______________________________________________________ 545

Licencja GNU Wolnej Dokumentacji ________________________________ 551

0. Preambuáa ______________________________________________________________ 551

1. Zastosowanie i definicje ____________________________________________________ 551

2. Kopiowanie dosáowne ______________________________________________________ 552

3. Kopiowanie ilociowe ______________________________________________________ 553

4. Modyfikacje _____________________________________________________________ 553

5. àczenie dokumentów _____________________________________________________ 555

6. Zbiory dokumentów _______________________________________________________ 555

7. Zestawienia z pracami niezale*nymi __________________________________________ 555

8. Táumaczenia _____________________________________________________________ 556

9. Wyganicie _____________________________________________________________ 556

10. Przyszáe wersje Licencji ___________________________________________________ 556

Zaácznik: Jak zastosowaü t Licencj do swojego dokumentu? _____________________ 556

ODSTAWY

PROGRAMOWANIA

KRÓTKO O

PROGRAMOWANIU

Programy nie spadaj z nieba,

najpierw tym niebem potrzü trzeba.

gemGreg

Rozpoczynamy zatem nasz kurs programowania gier. Zanim jednak napiszesz swojego
wáasnego Quake’a, Warcrafta czy te* inny wielki przebój, musisz nauczyü si tworzenia
programów (gry to przecie* te* programy, prawda?) – czyli programowania.

Jeszcze niedawno czynnoü ta byáa traktowana na poáy mistycznie: oto bowiem
programista (czytaj jajogáowy) wpisuje jakie dziwne cigi liter i numerków, a potem w
niemal magiczny sposób zamienia je w edytor tekstu, kalkulator czy wreszcie gr.
Obecnie obraz ten nie przystaje ju* tak bardzo do rzeczywistoci, a tworzenie programów
jest prostsze ni* jeszcze kilkanacie lat temu. Nadal jednak wiele zale*y od umiejtnoci
samego kodera oraz jego dowiadczenia, a zyskiwanie tych*e jest kwesti dáugiej pracy i
realizacji wielu projektów.
Nagrod za ten wysiáek jest mo*liwoü urzeczywistnienia dowolnego praktycznie pomysáu
i wielka satysfakcja.

Czas wic przyjrzeü si, jak powstaj programy.

Krok za krokiem

Wikszoü aplikacji zostaáa stworzona do realizacji jednego, konkretnego, choü
obszernego zadania. Przykáadowo, Notatnik potrafi edytowaü pliki tekstowe, Winamp –
odtwarzaü muzyk, a Paint tworzyü rysunki.

Screen 1. Gáównym zadaniem Winampa jest odtwarzanie plików muzycznych

Mo*emy wic powiedzieü, *e gáówn funkcj ka*dego z tych programów bdzie
odpowiednio edycja plików tekstowych, odtwarzanie muzyki czy tworzenie rysunków.
Funkcj t mo*na jednak podzieliü na mniejsze, bardziej szczegóáowe. I tak Notatnik
potrafi otwieraü i zapisywaü pliki, drukowaü je i wyszukiwaü w nich tekst. Winamp za
pozwala nie tylko odtwarzaü utwory, ale te* ukáadaü z nich playlisty.

Podstawy programowania

Idc dalej, mo*emy dotrzeü do nastpnych, coraz bardziej szczegóáowych funkcji danego
programu. Przypominaj one wic co w rodzaju drzewka, które pozwala nam niejako
„rozáo*yü dan aplikacj na czci”.

Schemat 1. Podziaá programu Notatnik na funkcje skáadowe

Zastanawiasz si pewnie, na jak drobne czci mo*emy w ten sposób dzieliü programy.
Innymi sáowy, czy dojdziemy wreszcie do takiego elementu, który nie da si rozdzieliü na
mniejsze. Spiesz z odpowiedzi, i* oczywicie tak – w przypadku Notatnika bylimy
zreszt bardzo blisko.

Czynnoü zatytuáowana Otwieranie plików wydaje si byü ju* jasno okrelona. Kiedy
wybieramy z menu Plik programu pozycj Otwórz, Notatnik robi kilka rzeczy: najpierw
pokazuje nam okno wyboru pliku. Gdy ju* zdecydujemy si na jaki, pyta nas, czy
chcemy zachowaü zmiany w ju* otwartym dokumencie (je*eli jakiekolwiek zmiany
rzeczywicie poczynilimy). W przypadku, gdy je zapiszemy w innym pliku lub odrzucimy,
program przystpi do odczytania zawartoci *danego przez nas dokumentu i wywietli
go na ekranie. Proste, prawda? :)
Przedstawiona powy*ej charakterystyka czynnoci otwierania pliku posiada kilka
znaczcych cech:

okrela dokáadnie kolejne kroki wykonywane przez program

wskazuje ró*ne mo*liwe warianty sytuacji i dla ka*dego z nich przewiduje
odpowiedni reakcj

Pozwalaj one nazwaü niniejszy opis algorytmem.

Algorytm to jednoznacznie okrelony sposób, w jaki program komputerowy realizuje
jak elementarn czynnoü.

Jest to bardzo wa*ne pojcie. Myl o algorytmie jako o czym w rodzaju przepisu albo
instrukcji, która „mówi” aplikacji, co ma zrobiü gdy napotka tak czy inn sytuacj. Dziki
swoim algorytmom programy wiedz co zrobiü po naciniciu przycisku myszki, jak
zapisaü, otworzyü czy wydrukowaü plik, jak wywietliü poprawnie stron WWW, jak
odtworzyü utwór w formacie MP3, jak rozpakowaü archiwum ZIP i ogólnie – jak
wykonywaü zadania, do których zostaáy stworzone.

Jeli nie podoba ci si, i* caáy czas mówimy o programach u*ytkowych zamiast o grach,
to wiedz, *e gry tak*e dziaáaj w oparciu o algorytmy. Najczciej s one nawet znacznie

Nie jest to cisáa matematyczna definicja algorytmu, ale na potrzeby programistyczne nadaje si bardzo

dobrze :)

Edycja plików tekstowych

Otwieranie i zapisywanie plików

Drukowanie plików

Wyszukiwanie i zamiana tekstu

Otwieranie plików

Zapisywanie plików

Wyszukiwanie tekstu w pliku

Zamiana danego tekstu na inny

Krótko o programowaniu

bardziej skomplikowane od tych wystpujcych w u*ywanych na co dzie aplikacjach.
Czy* nie áatwiej narysowaü prost tabelk z liczbami ni* skomplikowan scen
trójwymiarow? :)

Z tego wáanie powodu wymylanie algorytmów jest wa*n czci pracy twórcy
programów, czyli programisty. Wáanie t drog koder okrela sposób dziaáania
(„zachowanie”) pisanego programu.

Podsumujmy: w ka*dej aplikacji mo*emy wskazaü wykonywane przez ni czynnoci,
które z kolei skáadaj si z mniejszych etapów, a te jeszcze z mniejszych itd. Zadania te
realizowane s poprzez algorytmy, czyli przepisy okrelone przez programistów –
twórców programów.

Jak rozmawiamy z komputerem?

Wiemy ju*, *e programy dziaáaj dziki temu, *e programici konstruuj dla nich
odpowiednie algorytmy. Poznalimy nawet prosty algorytm, który byü mo*e jest
stosowany jest przez program Notatnik do otwierania plików tekstowych.

Zauwa* jednak, *e jest on napisany w jzyku naturalnym – to znaczy takim, jakim
posáuguj si ludzie. Chocia* jest doskonale zrozumiaáy dla wszystkich, to ma jedn
niezaprzeczaln wad: nie rozumie go komputer! Dla bezmylnej maszyny jest on po
prostu zbyt niejednoznaczny i niejasny.
Z drugiej strony, ju* istniejce programy s przecie* doskonale „zrozumiaáe” dla
komputera i dziaáaj bez *adnych problemów. Jak to mo*liwe? Otó* pecet te* posáuguje
si pewnego rodzaju jzykiem. Chcc zobaczyü próbk jego talentu lingwistycznego,
wystarczy podejrzeü zawartoü dowolnego pliku EXE. Co zobaczymy? Cig
bezsensownych, chyba nawet losowych liter, liczb i innych znaków. On ma jednak sens,
tyle *e nam bardzo trudno poznaü go w tej postaci. Po prostu jzyk komputera jest dla
równowagi zupeánie niezrozumiaáy dla nas, ludzi :)

Screen 2. Tak wyglda plik EXE :-)

Jak poradziü sobie z tym, zdawaáoby si nierozwizalnym, problemem? Jak radz sobie
wszyscy twórcy oprogramowania, skoro budujc swoje programy musz przecie*
„rozmawiaü” z komputerem?
Poniewa* nie mo*emy peceta nauczyü naszego wáasnego jzyka i jednoczenie sami nie
potrafimy porozumieü si z nim w jego „mowie”, musimy zastosowaü rozwizanie
kompromisowe. Na pocztek ucilimy wic i przejrzycie zorganizujemy nasz opis
algorytmów. W przypadku otwierania plików w Notatniku mo*e to wygldaü na przykáad
tak:

Algorytm

Plik -> Otwórz

Poka* okno wyboru plików

Je*eli

u*ytkownik klikná Anuluj,

Przerwij

Podstawy programowania

Je*eli

poczyniono zmiany w aktualnym dokumencie,

Wywietl komunikat "Czy zachowaü zmiany w aktualnym

dokumencie?" z przyciskami Tak, Nie, Anuluj

Sprawd(

decyzj u*ytkownika

Decyzja

Tak: wywoáaj polecenie Plik -> Zapisz

Decyzja

Anuluj: Przerwij

Odczytaj wybrany plik

Wywietl zawartoü pliku

Koniec Algorytmu

Jak widaü, sprecyzowalimy tu kolejne kroki wykonywane przez program – tak aby
„wiedziaá”, co nale*y po kolei zrobiü. Fragmenty zaczynajce si od Je*eli i Sprawd(
pozwalaj odpowiednio reagowaü na ró*ne sytuacje, takie jak zmiana decyzji
u*ytkownika i wcinicie przycisku Anuluj.
Czy to wystarczy, by komputer wykonaá to, co mu ka*emy? Otó* nie bardzo… Chocia*
wprowadzilimy ju* nieco porzdku, nadal u*ywamy jzyka naturalnego – jedynie
struktura zapisu jest bardziej cisáa. Notacja taka, zwana pseudokodem, przydaje si
jednak bardzo do przedstawiania algorytmów w czytelnej postaci. Jest znacznie bardziej
przejrzysta oraz wygodniejsza ni* opis w formie zwykáych zda, które musiaáyby byü
najczciej wielokrotnie záo*one i niezbyt poprawne gramatycznie. Dlatego te*, kiedy
bdziesz wymylaá wáasne algorytmy, staraj si u*ywaü pseudokodu do zapisywania ich
ogólnego dziaáania.

No dobrze, wyglda to caákiem nie(le, jednak nadal nie potrafimy si porozumieü z tym
maáo inteligentnym stworem, jakim jest nasz komputer. Wszystko dlatego, i* nie wie on,
w jaki sposób przetworzyü nasz algorytm, napisany w powstaáym ad hoc jzyku, do
postaci zrozumiaáych dla niego „krzaczków”, które widziaáe wczeniej.
Dla rozwizania tego problemu stworzono sztuczne jzyki o dokáadnie okrelonej skáadni i
znaczeniu, które dziki odpowiednim narzdziom mog byü zamieniane na kod binarny,
czyli form zrozumiaá dla komputera. Nazywamy je jzykami programowania i to
wáanie one sáu* do tworzenia programów komputerowych. Wiesz ju* zatem, czego
najpierw musisz si nauczyü :)

Jzyk programowania to forma zapisu instrukcji dla komputera i programów
komputerowych, porednia midzy jzykiem naturalnym a kodem maszynowym.

Program zapisany w jzyku programowania jest, podobnie jak nasz algorytm w
pseudokodzie, zwykáym tekstem. Podobiestwo tkwi równie* w fakcie, *e sam taki tekst
nie wystarczy, aby napisan aplikacj uruchomiü – najpierw nale*y j zamieniü w plik
wykonywalny (w systemie Windows s to pliki z rozszerzeniem EXE). Czynnoü ta jest
dokonywana w dwóch etapach.
Podczas pierwszego, zwanego kompilacj, program nazywany kompilatorem zamienia
instrukcje jzyka programowania (czyli kod (ródáowy, który, jak ju* mówilimy, jest po
prostu tekstem) w kod maszynowy (binarny). Zazwyczaj na ka*dy plik z kodem
(

ródáowym (zwany moduáem) przypada jeden plik z kodem maszynowym.

Kompilator – program zamieniajcy kod (ródáowy, napisany w jednym z jzyków
programowania, na kod maszynowy w postaci oddzielnych moduáów.

Drugi etap to linkowanie (zwane te* konsolidacj lub po prostu áczeniem). Jest to
budowanie gotowego pliku EXE ze skompilowanych wczeniej moduáów. Oprócz nich
mog tam zostaü wáczone tak*e inne dane, np. ikony czy kursory. Czyni to program
zwany linkerem.

Krótko o programowaniu

Linker áczy skompilowane moduáy kodu i inne pliki w jeden plik wykonywalny, czyli
program (w przypadku Windows – plik EXE).

Tak oto zdjlimy nimb magii z procesu tworzenia programu ;D

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

Skoro kompilacja i linkowanie s przeprowadzane automatycznie, a programista musi

jedynie wydaü polecenie rozpoczcia tego procesu, to dlaczego nie pójü dalej – niech

komputer na bie*co táumaczy sobie program na swój kod maszynowy. Rzeczywicie,

jest to mo*liwe – powstaáo nawet kilka jzyków programowania dziaáajcych w ten

sposób (tak zwanych jzyków interpretowanych, przykáadem jest choüby PHP, sáu*cy do

tworzenia stron internetowych). Jednak*e ogromna wikszoü programów jest nadal

tworzona w „tradycyjny” sposób.

Dlaczego? Có* – je*eli w programowaniu nie wiadomo, o co chodzi, to na pewno chodzi o

wydajnoü

;)) Kompilacja i linkowanie trwa po prostu dáugo, od kilkudziesiciu sekund w

przypadku niewielkich programów, do nawet kilkudziesiciu minut przy du*ych. Lepiej

zrobiü to raz i u*ywaü szybkiej, gotowej aplikacji ni* nie robiü w ogóle i czekaü dwie

minuty na rozwinicie menu podrcznego :DD

Zatem czas na konkluzj i usystematyzowanie zdobytej wiedzy. Programy piszemy w
jzykach programowania, które s niejako form komunikacji z komputerem i wydawania
mu polece. S one nastpnie poddawane procesom kompilacji i konsolidacji, które
zamieniaj zapis tekstowy w binarny kod maszynowy. W wyniku tych czynnoci powstaje
gotowy plik wykonywalny, który pozwala uruchomiü program.

Jzyki programowania

Przegld najwa*niejszych jzyków programowania

Obecnie istnieje bardzo, bardzo wiele jzyków programowania. Niektóre przeznaczono do
konkretnych zastosowa, na przykáad sieci neuronowych, inne za s narzdziami
ogólnego przeznaczenia. Zazwyczaj wiksze korzyci zajmuje znajomoü tych drugich,
dlatego nimi wáanie si zajmiemy.
Od razu musz zaznaczyü, *e mimo to nie ma czego takiego jak jzyk, który bdzie
dobry do wszystkiego. Sporód jzyków „ogólnych” niektóre s nastawione na szybkoü,
inne na rozmiar kodu, jeszcze inne na przejrzystoü itp. Jednym sáowem, panuje totalny
rozgardiasz ;)

Nale*y koniecznie odró*niaü jzyki programowania od innych jzyków u*ywanych w
informatyce. Na przykáad HTML jest jzykiem opisu, gdy* za jego pomoc definiujemy
jedynie wygld stron WWW (wszelkie interaktywne akcje to ju* domena JavaScriptu).
Inny rodzaj to jzyki zapyta w rodzaju SQL, sáu*ce do pobierania danych z ró*nych
(

ródeá (na przykáad baz danych).

Niepoprawne jest wic (popularne skdind) stwierdzenie „programowaü w HTML”.

Przyjrzyjmy si wic najwa*niejszym u*ywanym obecnie jzykom programowania:

Visual Basic
Jest to nastpca popularnego swego czasu jzyka BASIC. Zgodnie z nazw (basic
znaczy prosty), byá on przede wszystkim áatwy do nauki. Visual Basic pozwala na
tworzenie programów dla rodowiska Windows w sposób wizualny, tzn. poprzez
konstruowanie okien z takich elementów jak przyciski czy pola tekstowe.
Jzyk ten posiada dosyü spore mo*liwoci, jednak ma równie* jedn, za to bardzo

Niektórzy powiedz, *e o niezawodnoü, ale to ju* kwestia osobistych priorytetów :)

Podstawy programowania

powa*n wad. Programy w nim napisane nie s kompilowane w caáoci do kodu
maszynowego, ale interpretowane podczas dziaáania. Z tego powodu s
znacznie wolniejsze od tych kompilowanych caákowicie.
Obecnie Visual Basic jest jednym z jzyków, który umo*liwia tworzenie aplikacji
pod lansowan przez Microsoft platform .NET, wic pewnie jeszcze o nim
usáyszymy :)

Screen 3. Kod przykáadowego projektu w Visual Basicu

Object Pascal (Delphi)
Delphi z kolei wywodzi si od popularnego jzyka Pascal. Podobnie jak VB jest
á

atwy do nauczenia, jednak*e oferuje znacznie wiksze mo*liwoci zarówno jako

jzyk programowania, jak i narzdzie do tworzenia aplikacji. Jest caákowicie
kompilowany, wic dziaáa tak szybko, jak to tylko mo*liwe. Posiada równie*
mo*liwoü wizualnego konstruowania okien. Dziki temu jest to obecnie chyba
najlepsze rodowisko do budowania programów u*ytkowych.

Screen 4.Tworzenie aplikacji w Delphi

C++
C++ jest teraz chyba najpopularniejszym jzykiem do zastosowa wszelakich.
Powstaáo do niego bardzo wiele kompilatorów pod ró*ne systemy operacyjne i
dlatego jest uwa*any za najbardziej przenony. Istnieje jednak druga strona
medalu – mnogoü tych narzdzi prowadzi do niewielkiego rozgardiaszu i pewnych

Krótko o programowaniu

trudnoci w wyborze którego z nich. Na szczcie sam jzyk zostaá w 1997 roku
ostatecznie ustandaryzowany.
O C++ nie mówi si zwykle, *e jest áatwy – byü mo*e ze wzgldu na dosyü
skondensowan skáadni (na przykáad odpowiednikiem pascalowych sáów begin i
end s po prostu nawiasy klamrowe

{ i }). To jednak dosyü powierzchowne

przekonanie, a sam jzyk jest spójny i logiczny.
Je*eli chodzi o mo*liwoci, to w przypadku C++ s one bardzo du*e – w sumie
mo*na powiedzieü, *e nieco wiksze ni* Delphi. Jest on te* chyba najbardziej
elastyczny – niejako dopasowuje si do preferencji programisty.

Java
Ostatnimi czasy Java staáa si niemal czci kultury masowej – wystarczy choüby
wspomnieü o telefonach komórkowych i przeznaczonych do aplikacjach. Ilustruje
to dobrze gáówny cel Javy, a mianowicie przenonoü – i to nie kodu, lecz
skompilowanych programów! Osignito to poprzez kompilacj do tzw. bytecode,
który jest wykonywany w ramach specjalnej maszyny wirtualnej. W ten sposób,
program w Javie mo*e byü uruchamiany na ka*dej platformie, do której istnieje
maszyna wirtualna Javy – a istnieje prawie na wszystkich, od Windowsa przez
Linux, OS/2, QNX, BeOS, palmtopy czy wreszcie nawet telefony komórkowe. Z
tego wáanie powodu Java jest wykorzystywana do pisania niewielkich programów
umieszczanych na stronach WWW, tak zwanych apletów.
Cen za t przenonoü jest rzecz jasna szybkoü – bytecode Javy dziaáa znacznie
wolniej ni* zwykáy kod maszynowy, w dodatku jest strasznie pamicio*erny.
Poniewa* jednak zastosowaniem tego jzyka nie s wielkie i wymagajce
aplikacje, lecz proste programy, nie jest to a* tak wielki mankament.
Skáadniowo Java bardzo przypomina C++.

Screen 5. Krzy*ówka w formie apletu Javy

PHP
PHP (skrót od Hypertext Preprocessor) jest jzykiem u*ywanym przede wszystkim
w zastosowaniach internetowych, dokáadniej na stronach WWW. Pozwala dodaü im
znacznie wiksz funkcjonalnoü ni* ta oferowana przez zwykáy HTML. Obecnie
miliony serwisów wykorzystuje PHP – du* rol w tym sukcesie ma zapewne jego
licencja, oparta na zasadach Open Source (czyli brak ogranicze w
rozprowadzaniu i modyfikacji).
Mo*liwoci PHP s caákiem du*e, nie mo*na tego jednak powiedzieü o szybkoci –
jest to jzyk interpretowany. Jednak*e w przypadku gáównego zastosowania PHP,
czyli obsáudze serwisów internetowych, nie ma ona wikszego znaczenia – czas

Podstawy programowania

wczytywania strony WWW to przecie* w wikszoci czas przesyáania gotowego
kodu HTML od serwera do odbiorcy.
Je*eli chodzi o skáadni, to troch przypomina ona C++. Kod PHP mo*na jednak
swobodnie przeplataü znacznikami HTML.
Z punktu widzenia programisty gier jzyk ten jest w zasadzie zupeánie
bezu*yteczny (chyba *e kiedy sam bdziesz wykonywaá oficjaln stron
internetow swojej wielkiej produkcji ;D), wspominam o nim jednak ze wzgldu
na bardzo szerokie grono u*ytkowników, co czyni go jednym z wa*niejszych
jzyków programowania.

Screen 6. Popularny skrypt forów dyskusyjnych, phpBB, tak*e dziaáa w oparciu o PHP

To oczywicie nie wszystkie jzyki – jak ju* pisaáem, jest ich caáe mnóstwo. Jednak*e w
ogromnej wikszoci przypadków gáówn ró*nic midzy nimi jest skáadnia, a wic
sprawa maáo istotna (szczególnie, je*eli dysponuje si dobr dokumentacj :D). Z tego
powodu poznanie jednego z nich bardzo uáatwia nauk nastpnych – po prostu im wicej
jzyków ju* znasz, tym áatwiej uczysz si nastpnych :)

Brzemienna w skutkach decyzja

Musimy zatem zdecydowaü, którego jzyka bdziemy si uczyü, aby zrealizowaü nasz
nadrzdny cel, czyli poznanie tajników programowania gier. Sprecyzujmy wic
wymagania wobec owego jzyka:

programy w nim napisane musz byü szybkie – w takim wypadku mo*emy wziü
pod uwag jedynie jzyki caákowicie kompilowane do kodu maszynowego

musi dobrze wspóápracowaü z ró*norodnymi bibliotekami graficznymi, na przykáad
DirectX

powinien posiadaü du*e mo*liwoci i zapewniaü gotowe, czsto u*ywane
rozwizania

nie zaszkodzi te*, gdy bdzie w miar prosty i przejrzysty :)

Je*eli uwzgldnimy wszystkie te warunki, to sporód caáej mnogoci jzyków
programowania (w tym kilku przedstawionych wczeniej) zostaj nam a*… dwa – Delphi
oraz C++.

Przygldajc si bli*ej Delphi, mo*emy zauwa*yü, i* jest on przeznaczony przede
wszystkim do programowania aplikacji u*ytkowych, które pozostaj przecie* poza
krgiem naszego obecnego zainteresowania :) Na plus mo*na jednak zaliczyü prostot i
przejrzystoü jzyka oraz jego bardzo du* wydajnoü. Równie* mo*liwoci Delphi s
caákiem spore.
Z kolei C++ zdaje si byü bardziej uniwersalny. Dobrze rozumie si z wa*nymi dla nas
bibliotekami graficznymi, jest tak*e bardzo szybki i posiada du*e mo*liwoci. Skáadnia z
kolei jest raczej „ekonomiczna” i byü mo*e nieco bardziej skomplikowana.

Krótko o programowaniu

Czy*bymy mieli zatem remis, a prawda le*aáa (jak zwykle) porodku? :) Otó*
niezupeánie – nie uwzgldnilimy bowiem wa*nego czynnika, jakim jest popularnoü
danego jzyka. Je*eli jest on szeroko znany i u*ywany (do programowania gier), to z
pewnoci istnieje o nim wicej przydatnych (ródeá informacji, z których mógáby
korzystaü.
Z tego wáanie powodu Delphi jest gorszym wyborem, poniewa* ogromna wikszoü
dokumentacji, artykuáów, kursów itp. dotyczy jzyka C++. Wystarczy chocia*by
wspomnieü, i* Microsoft nie dostarcza narzdzi pozwalajcych na wykorzystanie DirectX
w Delphi – s one tworzone przez niezale*ne zespoáy

i ich u*ywanie wymaga pewnego

dowiadczenia.

A wic – C++! Jzyk ten wydaje si najlepszym wyborem, je*eli chodzi o programowanie
gier komputerowych. A skoro mamy ju* t wa*n decyzj za sob, zostaáa nam jeszcze
tylko pewna drobnostka – trzeba si tego jzyka nauczyü :))

Kwestia kompilatora

Jak ju* wspominaáem kilkakrotnie, C++ jest bardzo przenonym jzykiem,
umo*liwiajcym tworzenie aplikacji na ró*nych platformach sprztowych i programowych.
Z tego* powodu istnieje do niego caáe mnóstwo kompilatorów.
Ale kompilator to tylko program do zamiany kodu C++ na kod maszynowy – w dodatku
dziaáa on zwykle w trybie wiersza polece, a wic nie jest zbyt wygodny w u*yciu.
Dlatego równie wa*ne jest rodowisko programistyczne, które umo*liwiaáoby
wygodne pisanie kodu, zarzdzanie caáymi projektami i uáatwiaáoby kompilacj.

rodowisko programistyczne (ang. integrated development environment – w skrócie

IDE) to pakiet aplikacji uáatwiajcych tworzenie programów w danym jzyku
programowania. Umo*liwia najczciej organizowanie plików z kodem w projekty, áatw
kompilacj, czasem te* wizualne tworzenie okien dialogowych.
Popularnie, rodowisko programistyczne nazywa si po prostu kompilatorem (gdy* jest
jego gáówn czci).

Przykáady takich rodowisk zaprezentowaáem na screenach przy okazji przegldu jzyków
programowania. Nietrudno si domyleü, i* dla C++ równie* przewidziano takie
narzdzia. W przypadku rodowiska Windows, które rzecz jasna interesuje nas
najbardziej, mamy ich kilka:

Bloodshed Dev-C++
Pakiet ten ma niewtpliw zalet – jest darmowy do wszelakich zastosowa, tak*e
komercyjnych. Niestety zdaje si, *e na tym jego zalety si kocz :) Posiada
wprawdzie caákiem wygodne IDE, ale nie mo*e si równaü z profesjonalnymi
narzdziami: nie posiada na przykáad mo*liwoci edycji zasobów (ikon, kursorów
itd.)
Mo*na go znale(ü na

stronie producenta

Borland C++Builder
Z wygldu bardzo przypomina Delphi – oczywicie poza zastosowanym jzykiem
programowania, którym jest C++. Niemniej, tak samo jak swój kuzyn jest on
przeznaczony gáównie do tworzenia aplikacji u*ytkowych, wic nie odpowiadaáby
nam zbytnio :)

Microsoft Visual C++
Poniewa* jest to produkt firmy Microsoft, znakomicie integruje si z innym
produktem tej firmy, czyli DirectX – wobec czego dla nas, (przyszáych)

Najbardziej znanym jest

JEDI

Podstawy programowania

programistów gier, wypada bardzo korzystnie. Nic dziwnego zatem, *e u*ywaj go
nawet profesjonalni twórcy.

Tak jest, dobrze mylisz – zalecam Visual C++ :) Warto naladowaü najlepszych, a skoro
ogromna wikszoü komercyjnych gier powstaje przy u*yciu tego narzdzia (i to nie tylko
w poáczeniu z DirectX), musi to chyba znaczyü, *e faktycznie jest dobre

Je*eli upierasz si przy innym rodowisku, to pamitaj, *e przedstawione przeze mnie
opisy niektórych polece i opcji mog nie odpowiadaü twojemu IDE. W wikszoci nie
dotyczy to jednak samego jzyka C++, którego skáadni i mo*liwoci zachowuj
wszystkie kompilatory. W razie jakichkolwiek káopotów mo*esz zawsze odwoáaü si do
dokumentacji :)

Podsumowanie

Uff, to ju* koniec tego rozdziaáu :) Zaczlimy go od dokáadnego zlustrowania Notatnika i
podzieleniu go na drobne czci – a* doszlimy do algorytmów. Dowiedzielimy si, i* to
gáównie one skáadaj si na gotowy program i *e zadaniem programisty jest wáanie
wymylanie algorytmów.
Nastpnie rozwizalimy problem wzajemnego niezrozumienia czáowieka i komputera,
dziki czemu w przyszáoci bdziemy mogli tworzyü wáasne programy. Poznalimy sáu*ce
do tego narzdzia, czyli jzyki programowania.
Wreszcie, podjlimy (OK, ja podjáem :D) wa*ne decyzje, które wytyczaj nam kierunek
dalszej nauki – a wic wybór jzyka C++ oraz rodowiska Visual C++.

Nastpny rozdziaá jest wcale nie mniej znaczcy, a mo*e nawet wa*niejszy. Napiszesz
bowiem swój pierwszy program :)

Pytania i zadania

Có*, prace domowe s nieuniknione :) Odpowiedzenie na poni*sze pytania i wykonanie
ü

wicze pozwoli ci lepiej zrozumieü i zapamitaü informacje z tego rozdziaáu.

Pytania

Dlaczego jzyki interpretowane s wolniejsze od kompilowanych?

wiczenia

Wybierz dowolny program i spróbuj nazwaü jego gáówn funkcj. Postaraj si te*
wyró*niü te bardziej szczegóáowe.

Zapisz w postaci pseudokodu algorytm… parzenia herbaty :D Pamitaj o
uwzgldnieniu takich sytuacji jak: peány/pusty czajnik, brak zapaáek lub
zapalniczki czy brak herbaty

Wiem, *e dla niektórych pojcia „dobry produkt” i „Microsoft” wzajemnie si wykluczaj, ale akurat w tym

przypadku wcale tak nie jest :)

Z CZEGO SKàADA SI

PROGRAM?

Ka*dy dziaáajcy program jest przestarzaáy.

pierwsze prawo Murphy’ego o oprogramowaniu

Gdy mamy ju* przyswojon niezbdn dawk teoretycznej i pseudopraktycznej wiedzy,
mo*emy przejü od sáów do czynów :)

W aktualnym rozdziale zapoznamy si z podstawami jzyka C++, które pozwol nam
opanowaü umiejtnoü tworzenia aplikacji w tym jzyku. Napiszemy wic swój pierwszy
program (drugi, trzeci i czwarty zreszt te* :D), zaznajomimy si z podstawowymi
pojciami u*ywanymi w programowaniu i zdobdziemy garü niezbdnej wiedzy :)

C++, pierwsze starcie

Zanim w ogóle zaczniemy programowaü, musisz zaopatrzyü si w odpowiedni kompilator
C++ - wspominaáem o tym pod koniec poprzedniego rozdziaáu, zalecajc jednoczenie
u*ywanie Visual C++. Dlatego te* opisy polece IDE czy screeny bd dotyczyáy wáanie
tego narzdzia. Nie uniemo*liwia to oczywicie u*ywania innego rodowiska, lecz w takim
wypadku bdziesz w wikszym stopniu zdany na siebie. Ale przecie* lubisz wyzwania,
prawda? ;)

Bliskie spotkanie z kompilatorem

Pierwsze wyzwanie, jakim jest instalacja rodowiska, powiniene mieü ju* za sob, wic
pozwol sobie optymistycznie zaáo*yü, i* faktycznie tak jest :) Swoj drog, instalowanie
programów jest czci niezbdnego zestawu umiejtnoci, które trzeba posiü, by
mieniü si (rednio)zaawansowanym u*ytkownikiem komputera. Za kandydat na
przyszáego programist powinien niewtpliwie posiadaü pewien (w domyle – raczej
wikszy ni* mniejszy) poziom obeznania w kwestii obsáugi peceta. W ostatecznoci
mo*na jednak signü do odpowiednich pomocy naukowych :D

rodowisko programistyczne bdzie twoim podstawowym narzdziem pracy, wic musisz

je dobrze poznaü. Nie jest ono zbyt skomplikowane w obsáudze – z pewnoci nie zawiera
takiego natáoku nikomu niepotrzebnych funkcji jak chocia*by popularne pakiety
biurowe :) Niemniej, z pewnoci przyda ci kilka sáów wprowadzenia.

W u*yciu jest par wersji Visual C++. W tym tutorialu bd opieraá si na pakiecie Visual
Studio 7 .NET (Visual C++ jest jego czci), który ró*ni si nieco od wczeniejszej, do
niedawna bardzo popularnej, wersji 6. Dlatego te* w miar mo*liwoci bd staraá si
wskazywaü na najwa*niejsze ró*nice midzy tymi dwoma edycjami IDE.

Podstawy programowania

„Goáy” kompilator jest tylko maszynk zamieniajc kod C++ na kod maszynowy,
dziaáajc na zasadzie „ty mi podajesz plik ze swoim kodem, a ja go kompiluj”. Gdy
uwiadomimy sobie, *e przecitny program skáada si z kilku(nastu) plików kodu
(

ródáowego, z których ka*dy nale*aáoby kompilowaü oddzielnie i wreszcie linkowaü je w

jeden plik wykonywalny, docenimy zawarte w rodowiskach programistycznych
mechanizmy zarzdzania projektami.

Projekt w rodowiskach programistycznych to zbiór moduáów kodu (ródáowego i innych
plików, które po kompilacji i linkowaniu staj si pojedynczym plikiem EXE, czyli
programem.

Do najwa*niejszych zalet projektu nale*y bardzo áatwa kompilacja – wystarczy wydaü
jedno polecenie (na przykáad wybraü opcj z menu), a projekt zostanie automatycznie
skompilowany i zlinkowany. Zwa*ywszy, i* tak nie tak dawno temu czynnoü ta
wymagaáa wpisania kilkunastu dáugich polece lub napisania oddzielnego skryptu,
widzimy tutaj du*y postp :)

Kilka projektów mo*na pogrupowaü w tzw. rozwizania

(ang. solutions). Przykáadowo,

je*eli tworzysz gr, do której doáczysz edytor etapów, to zasadnicza gra oraz edytor
bd oddzielnymi projektami, ale rozsdnie bdzie zorganizowaü je w jedno rozwizanie.

***

Teraz, gdy wiemy ju* sporo na temat sposobu dziaáania naszego rodowiska oraz
przyczyn, dlaczego uáatwia nam ono *ycie, przydaáoby si je uruchomiü – uczy wic to
niezwáocznie. Powiniene zobaczyü na przykáad taki widok:

Screen 7. Okno pocztkowe rodowiska Visual Studio .NET

Có*, czas wic co napisaü - skoro mamy nauczyü si programowania, pisanie
programów jest przecie* koniecznoci :D
Na podstawie tego, co wczeniej napisaáem o projektach, nietrudno si domyleü, i*
rozpoczcie pracy nad aplikacj oznacza wáanie stworzenie nowego projektu. Robi si to
bardzo prosto: najbardziej elementarna metoda to po prostu kliknicie w przycisk New

W Visual C++ 6 byáy to obszary robocze (ang. workspaces)

Z czego skáada si program?

Project widoczny na ekranie startowym; mo*na równie* u*yü polecenia File|New|Project
z menu.

Twoim oczom uka*e si wtedy okno zatytuáowane, a jak*e, New Project

:) Mo*esz w nim

wybraü typ projektu – my zdecydujemy si oczywicie na Visual C++ oraz Win32 Project,
czyli aplikacj Windows.

Screen 8. Opcje nowego projektu

Nadaj swojemu projektowi jak dobr nazw (chocia*by tak, jak na screenie), wybierz
dla niego katalog i kliknij OK.

Najlepiej je*eli utworzysz sobie specjalny folder na programy, które napiszesz podczas
tego kursu. Pamitaj, porzdek jest bardzo wa*ny :)

Po krótkiej chwili ujrzysz nastpne okno – kreator :) Obsesja Microsoftu na ich punkcie
jest powszechnie znana, wic nie bd( zdziwiony widzc kolejny przejaw ich radosnej
twórczoci ;) Ten*e egzemplarz sáu*y dokáadnemu dopasowaniu parametrów projektu do
osobistych *ycze. Najbardziej interesujca jest dla nas strona zatytuáowana Application
Settings – przeácz si zatem do niej.

Rodzaje aplikacji

Skoncentrujemy si przede wszystkim na opcji Application Type, a z kilku dopuszczalnych
wariantów we(miemy pod lup dwa:

Windows application to zgodnie z nazw aplikacja okienkowa. Skáada si z
jednego lub kilku okien, zawierajcych przyciski, pola tekstowe, wyboru itp. –
czyli wszystko to, z czym stykamy si w Windows nieustannie.

Console application jest programem innego typu: do komunikacji z u*ytkownikiem
u*ywa tekstu wypisywanego w konsoli – std nazwa. Dzisiaj mo*e wydawaü si
to archaizmem, jednak aplikacje konsolowe s szeroko wykorzystywane przez
dowiadczonych u*ytkowników systemów operacyjnych. Szczególnie dotyczy to
tych z rodziny Unixa, ale w Windows tak*e mog byü bardzo przydatne.

Programy konsolowe nie s tak efektowne jak ich okienkowi bracia, posiadaj za to
bardzo wa*n dla pocztkujcego programisty cech – s proste :) Najprostsza aplikacja
tego typu to kwestia kilku linijek kodu, podczas gdy program okienkowy wymaga ich

Analogiczne okno w Visual C++ 6 wygldaáo zupeánie inaczej, jednak ma podobne opcje

Podstawy programowania

kilkudziesiciu. Idee dziaáania takiego programu s równie* troch bardziej
skomplikowane.

Z tych wáanie powodów zajmiemy si na razie wyácznie aplikacjami konsolowymi –
pozwol nam w miar áatwo nauczyü si samego jzyka C++ (co jest przecie* naszym
aktualnym priorytetem), bez zagábiania si w skomplikowane meandry programowania
Windows.

Screen 9. Ustawienia aplikacji

Wybierz wic pozycj Console application na licie Application type. Dodatkowo zaznacz
te* opcj Empty project – spowoduje to utworzenie pustego projektu, a oto nam
aktualnie chodzi.

Pierwszy program

Gdy wreszcie ustalimy i zatwierdzimy wszystkie opcje projektu, mo*emy przystpiü do
wáaciwej czci tworzenia programu, czyli kodowania.
Aby dodaü do naszego projektu pusty plik z kodem (ródáowym, wybierz pozycj menu
Project|Add New Item. W okienku, które si pojawi, w polu Templates zaznacz ikon
C++ File (.cpp), a jako nazw wpisz po prostu main. W ten sposób utworzysz plik
main.cpp, który wypeánimy kodem naszego programu.

Plik ten zostanie od razu otwarty, wic mo*esz bez zwáoki wpisaü do taki oto kod:

// First - pierwszy program w C++

#include

#include

<conio.h>

void

main()

{
std::cout

"Hurra! Napisalem pierwszy program w C++!"

<< std::endl;

getch();
}

Tak jest, to wszystko – te kilka linijek kodu skáadaj si na caáy nasz program. Pewnie
niezbyt wielka to teraz pociecha, bo ów kod jest dla ciebie zapewne „troch” niejasny, ale
spokojnie – powoli wszystko sobie wyjanimy :)

Z czego skáada si program?

Na razie wcinij klawisz F7 (lub wybierz z menu Build|Build Solution), by skompilowaü i
zlinkowaü aplikacj. Jak widzisz, jest to proces caákowicie automatyczny i, je*eli tylko kod
jest poprawny, nie wymaga *adnych dziaáa z twojej strony.
W kocu, wcinij F5 (lub wybierz Debug|Start) i podziwiaj konsol z wywietlonym
entuzjastycznym komunikatem :D (A gdy si nim nacieszysz, nacinij dowolny klawisz,
by zakoczyü program.)

Kod programu

Naturalnie, teraz przyjrzymy si bli*ej naszemu elementarnemu projektowi, przy okazji
odkrywajc najwa*niejsze aspekty programowania w C++.

Komentarze

Pierwsza linijka:

// First – pierwszy program w C++

to komentarz, czyli dowolny opis sáowny. Jest on caákowicie ignorowany przez
kompilator, natomiast mo*e byü pomocny dla piszcego i czytajcego kod.
Komentarze piszemy w celu wyjanienia pewnych fragmentów kodu programu,
oddzielenia jednej jego czci od drugiej, oznaczania funkcji i moduáów itp. Odpowiednia
iloü komentarzy uáatwia zrozumienie kodu, wic stosuj je czsto :)

W C++ komentarze zaczynamy od

(dwóch slashy):

// To jest komentarz

lub umieszczamy je midzy

, na przykáad:

/* Ten komentarz mo*e byü bardzo dáugi
i

skáadaü si z kilku linijek.

W moim komentarzu do programu umieciáem jego tytuá

oraz krótki opis; bd t

zasad stosowaá na pocztku ka*dego przykáadowego kodu. Oczywicie, ty mo*esz
komentowaü swoje (ródáa wedle wáasnych upodoba, do czego ci gorco zachcam :D

Funkcja main()

Kiedy uruchamiamy nasz program, zaczyna on wykonywaü kod zawarty w funkcji main().
Od niej wic rozpoczyna si dziaáanie aplikacji – a nawet wicej: na niej te* to dziaáanie
si koczy. Zatem program (konsolowy) to przede wszystkim kod zawarty w funkcji
main() – determinuje on bezporednio jego zachowanie.

W przypadku rozwa*anej aplikacji funkcja ta nie jest zbyt obszerna, niemniej zawiera
wszystkie niezbdne elementy.
Najwa*niejszym z nich jest nagáówek, który u nas prezentuje si nastpujco:

void

main()

Takim samym tytuáem jest oznaczony gotowy program przykáadowy doáczony do kursu

Podstawy programowania

Wystpujce na pocztku sáowo kluczowe

void

mówi kompilatorowi, *e nasz program nie

bdzie informowaá systemu operacyjnego o wyniku swojego dziaáania. Niektóre programy
robi to poprzez zwracanie liczby – zazwyczaj zera w przypadku braku bádów i innych
wartoci, gdy wystpiáy jakie problemy. Nam to jest jednak zupeánie niepotrzebne – w
kocu nie wykonujemy *adnych záo*onych operacji, zatem nie istnieje mo*liwoü
jakiekolwiek niepowodzenia

Gdybymy jednak chcieli uczyniü systemowi zadoü, to powinnimy zmieniü nagáówek na

int

main() i na kocu funkcji dopisaü

return

; - a wic poinformowaü system o

sukcesie operacji. Jak jednak przekonalimy si wczeniej, nie jest to niezbdne.

Po nagáówku wystpuje nawias otwierajcy {. Jego gáówna rola to informowanie
kompilatora, *e „tutaj co si zaczyna”. Wraz z nawiasem zamykajcym } tworzy on blok
kodu – na przykáad funkcj. Z takimi parami nawiasów bdziesz si stale spotykaá; maj
one znaczenie tak*e dla programisty, gdy* porzdkuj kod i czyni go bardziej
czytelnym.

Przyjte jest, i* nastpne linijki po nawiasie otwierajcym {, a* do zamykajcego },
powinny byü przesunite w prawo za pomoc wciü (uzyskiwanych spacjami lub
klawiszem TAB). Poprawia to oczywicie przejrzystoü kodu, lecz pamitanie o tej
zasadzie podczas pisania mo*e byü uci*liwe. Na szczcie dzisiejsze rodowiska
programistyczne s na tyle sprytne, *e same dbaj o wáaciwe umieszczanie owych
wciü. Nie musisz wic zawracaü sobie gáowy takimi báahostkami – grunt, *eby wiedzieü,
komu nale*y byü wdzicznym ;))

Takim oto sposobem zapoznalimy si ze struktur funkcji main(), bdcej gáówn
czci programu konsolowego w C++. Teraz czas zajü si jej zawartoci i dowiedzieü
si, jak i dlaczego nasz program dziaáa :)

Pisanie tekstu w konsoli

Mielimy okazj si przekonaü, *e nasz program pokazuje nam komunikat podczas
dziaáania. Nietrudno dociec, i* odpowiada za to ta linijka:

std::cout <<

"Hurra! Napisalem pierwszy program w C++!"

<< std::endl;

std::cout oznacza tak zwany strumie wyjcia. Jego zadaniem jest wywietlanie na
ekranie konsoli wszystkiego, co do wylemy – a wysyáaü mo*emy oczywicie tekst.
Korzystanie z tego strumienia umo*liwia zatem pokazywanie nam w oknie konsoli
wszelkiego rodzaju komunikatów i innych informacji. Bdziemy go u*ywaü bardzo czsto,
dlatego musisz koniecznie zaznajomiü si ze sposobem wysyáania do tekstu.
A jest to wbrew pozorom bardzo proste, nawet intuicyjne. Spójrz tylko na omawian
linijk – nasz komunikat jest otoczony czym w rodzaju strzaáek wskazujcych
std::cout, czyli wáanie strumie wyjcia. Wpisujc je (za pomoc znaku mniejszoci),
robimy dokáadnie to, o co nam chodzi: wysyáamy nasz tekst do strumienia wyjcia.
Drugim elementem, który tam trafia, jest std::endl. Oznacza on ni mniej, ni wicej, jak
tylko koniec linijki i przejcie do nastpnej. W przypadku, gdy wywietlamy tylko jedn
lini tekstu nie ma takiej potrzeby, ale przy wikszej ich liczbie jest to niezbdne.

Wystpujcy przez nazwami cout i endl przedrostek std:: oznacza tzw. przestrze

nazw. Taka przestrze to nic innego, jak zbiór symboli, któremu nadajemy nazw.

Podobny optymizm jest zazwyczaj grub przesad i mo*emy sobie na niego pozwoliü tylko w najprostszych

programach, takich jak niniejszy :)

Z czego skáada si program?

Niniejsze dwa nale* do przestrzeni std, gdy* s czci Biblioteki Standardowej jzyka

C++ (wszystkie jej elementy nale* do tej przestrzeni). Mo*emy uwolniü si od

koniecznoci pisania przedrostka przestrzeni nazw std, je*eli przed funkcj main()

umiecimy deklaracj

using

namespace

std;. Wtedy moglibymy u*ywaü krótszych

nazw cout i endl.

Konkludujc: strumie wyjcia pozwala nam na wywietlanie tekstu w konsoli, za
u*ywamy go poprzez std::cout oraz „strzaáki” <<.

***

Druga linijka funkcji main() jest bardzo krótka:

getch();

Podobnie krótko powiem wic, *e odpowiada ona za oczekiwanie programu na nacinicie
dowolnego klawisza. Traktujc rzecz cilej, getch()jest funkcj podobnie jak main(),
jednak*e do zwizanego z tym faktem zagadnienia przejdziemy nieco pó(niej. Na razie
zapamitaj, i* jest to jeden ze sposobów na wstrzymanie dziaáania programu do
momentu wcinicia przez u*ytkownika dowolnego klawisza na klawiaturze.

Doáczanie plików nagáówkowych

Pozostaáy nam jeszcze dwie pierwsze linijki programu:

#include

#include

<conio.h>

które wcale nie s tak straszne, jak wygldaj na pierwszy rzut oka :)
Przede wszystkim zauwa*my, *e zaczynaj si one od znaku

, czym niewtpliwie ró*ni

si od innych instrukcji jzyka C++. S to bowiem specjalne polecenia wykonywane
jeszcze przed kompilacj - tak zwane dyrektywy. Przekazuj one ró*ne informacje i
komendy, pozwalaj wic sterowaü przebiegiem kompilacji programu.

Jedn z tych dyrektyw jest wáanie

#include

. Jak sama nazwa wskazuje, sáu*y ona do

doáczania – przy jej pomocy wáczamy do naszego programu pliki nagáówkowe Ale
czym one s i dlaczego ich potrzebujemy?
By si o tym przekonaü, zapomnijmy na chwil o programowaniu i wczujmy si w rol
zwykáego u*ytkownika komputera. Gdy instaluje on now gr, zazwyczaj musi równie*
zainstalowaü DirectX, je*eli jeszcze go nie ma. To caákowicie naturalne, gdy* wikszoü
gier korzysta z tej biblioteki, wic wymaga jej do dziaáania. Równie oczywisty jest tak*e
fakt, *e do u*ywania edytora tekstu czy przegldarki WWW ów pakiet nie jest potrzebny
– te programy po prostu z niego nie korzystaj.
Nasz program nie korzysta ani z DirectX, ani nawet ze standardowych funkcji Windows
(bo nie jest aplikacj okienkow). Wykorzystuje natomiast konsol i dlatego potrzebuje
odpowiednich mechanizmów do jej obsáugi - zapewniaj je wáanie pliki nagáówkowe.

Pliki nagáówkowe umo*liwiaj korzystanie z pewnych funkcji, technik, bibliotek itp.
wszystkim programom, które doáczaj je do swojego kodu (ródáowego.

W naszym przypadku dyrektywa

#include

ma za zadanie wáczenie do kodu plików

iostream i conio.h. Pierwszy z nich pozwala nam pisaü w oknie konsoli za pomoc
std::cout, drugi za wywoáaü funkcj getch(), która czeka na dowolny klawisz.

Podstawy programowania

Nie znaczy to jednak, *e ka*dy plik nagáówkowy odpowiada tylko za jedn instrukcj.
Jest wrcz odwrotnie, na przykáad wszystkie funkcje systemu Windows (a jest ich kilka
tysicy) wymagaj doáczenia tylko jednego pliku!

Koniecznoü doáczania plików nagáówkowych (zwanych w skrócie nagáówkami) mo*e ci
si wydawaü celowym utrudnianiem *ycia programicie. Ma to jednak gáboki sens, gdy*
zmniejsza rozmiary programów. Dlaczego kompilator miaáby powikszaü plik EXE zwykáej
aplikacji konsolowej o nazwy (i nie tylko nazwy) wszystkich funkcji Windows czy DirectX,
skoro i tak nie bdzie ona z nich korzystaü? Mechanizm plików nagáówkowych pozwala
temu zapobiec i t drog korzystnie wpáynü na objtoü programów.

***

Tym zagadnieniem zakoczylimy omawianie naszego programu - mo*emy sobie
pogratulowaü :) Nie byá on wprawdzie ani wielki, ani szczególnie imponujcy, lecz
pocztki zawsze s skromne. Nie spoczywajmy zatem na laurach i kontynuujmy…

Procedury i funkcje

Pierwszy napisany przez nas program skáadaá si wyácznie z jednej funkcji main(). W
praktyce takie sytuacje w ogóle si nie zdarzaj, a kod aplikacji zawiera najczciej
bardzo wiele procedur i funkcji. Poznamy zatem dogábnie istot tych konstrukcji, by móc
pisaü prawdziwe programy.

Procedura lub funkcja to fragment kodu, który jest wpisywany raz, ale mo*e byü
wykonywany wielokrotnie. Realizuje on najczciej jak pojedyncz czynnoü przy
u*yciu ustalonego przez programist algorytmu. Jak wiemy, dziaáanie wielu algorytmów
skáada si na prac caáego programu, mo*emy wic powiedzieü, *e procedury i funkcje s
podprogramami, których czstkowa praca przyczynia si do funkcjonowania programu
jako caáoci.

Gdy mamy ju* (a mamy? :D) peán jasnoü, czym s podprogramy i rozumiemy ich rol,
wyjanijmy sobie ró*nic midzy procedur a funkcj.

Procedura to wydzielony fragment kodu programu, którego zadaniem jest wykonywanie
jakiej czynnoci.

Funkcja zawiera kod, którego celem jest obliczenie i zwrócenie jakiej wartoci

Procedura mo*e przeprowadzaü dziaáania takie jak odczytywanie czy zapisywanie pliku,
wypisywanie tekstu czy rysowanie na ekranie. Funkcja natomiast mo*e policzyü iloü
wszystkich znaków ‘a’ w danym pliku czy te* wyznaczyü najmniejsz liczb sporód wielu
podanych.
W praktyce (i w jzyku C++) ró*nica midzy procedur a funkcj jest dosyü subtelna,
dlatego czsto obie te konstrukcje nazywa si dla uproszczenia funkcjami. A poniewa*
lubimy wszelk prostot, te* bdziemy tak czyniü :)

Wáasne funkcje

Na pocztek dokonamy prostej modyfikacji programu napisanego wczeniej. Jego kod
bdzie teraz wygldaá tak:

Oczywicie mo*e ona przy tym wykonywaü pewne dodatkowe operacje

Z czego skáada si program?

// Functions – przykáad wáasnych funkcji

#include

#include

<conio.h>

void

PokazTekst()

{
std::cout

"Umiem juz pisac wlasne funkcje! :)"

<< std::endl;

}

void

main()

{
PokazTekst();
getch();
}

Po kompilacji i uruchomieniu programu nie widaü wikszych zmian – nadal pokazuje on
komunikat w oknie konsoli (oczywicie o innej treci, ale to raczej rednio wa*ne :)).
Jednak wyra(nie widaü, *e kod ulegá powa*nym zmianom. Na czym one polegaj?
Otó* wydzielilimy fragment odpowiedzialny za wypisywanie tekstu do osobnej funkcji o
nazwie PokazTekst(). Jest ona teraz wywoáywana przez nasz gáówn funkcj, main().
Zmianie ulegá wic sposób dziaáania programu – rozpoczyna si od funkcji main(), ale od
razu „przeskakuje” do PokazTekst(). Po jej zakoczeniu ponownie wykonywana jest
funkcja main(), która z kolei wywoáuje funkcj getch(). Czeka ona na wcinicie
dowolnego klawisza i gdy to nastpi, wraca do main(), której jedynym zadaniem jest
teraz zakoczenie programu.

Tryb ledzenia

Przekonajmy si, czy to faktycznie prawda! W tym celu uruchomimy nasz program w
specjalnym trybie krokowym. Aby to uczyniü wystarczy wybraü z menu opcj
Debug|Step Into lub Debug|Step Over, ewentualnie wcisnü F11 lub F10.
Zamiast konsoli z wypisanym komunikatem widzimy nadal okno kodu z *óát strzaák,
wskazujc nawias otwierajcy funkcj main(). Jest to aktualny punkt wykonania
(ang. execution point) programu, czyli bie*co wykonywana instrukcja kodu – tutaj
pocztek funkcji main().
Wcinicie F10 lub F11 spowoduje „wejcie” w ow funkcj i sprawi, *e strzaáka spocznie
teraz na linijce

PokazTekst();

Jest to wywoáanie naszej wáasnej funkcji PokazTekst(). Chcemy dokáadnie przeledziü jej
przebieg, dlatego wciniemy F11 (lub skorzystamy z menu Debug|Step Into), by
skierowaü si do jej wntrza. U*ycie klawisza F10 (albo Debug|Step Over)
spowodowaáoby ominicie owej funkcji i przejcie od razu do nastpnej linijki w main().
Oczywicie mija si to z naszym zamysáem i dlatego skorzystamy z F11.
Punkt wykonania osiadá obecnie na pocztku funkcji PokazTekst(), wic korzystajc z
którego z dwóch u*ywanych ostatnio klawiszy mo*emy umieciü go w jej kodzie.
Dokáadniej, w pierwszej linijce

std::cout <<

"Umiem juz pisac wlasne funkcje! :)"

<< std::endl;

Jak wiemy, wypisuje ona tekst do okna konsoli. W tym momencie u*yj Alt+Tab lub
jakiego innego windowsowego sposobu, by przeáczyü si do niego. Przekonasz si
(czarno na czarnym ;)), i* jest caákowicie puste. Wróü wic do okna kodu, wcinij

Podstawy programowania

F10/F11 i ponownie spójrz na konsol. Zobaczysz naocznie, i* std::cout faktycznie
wypisuje nam to, co chcemy :D
Po kolejnych dwóch uderzeniach w jeden z klawiszy powrócimy do funkcji main(), a
strzaáka zwana punktem wykonania ustawi si na

getch();

Moglibymy teraz u*yü F11 i zobaczyü kod (ródáowy funkcji getch(), ale to ma raczej
niewielki sens. Poza tym, darowanemu koniowi (jakim s z pewnocia tego rodzaju
funkcje!) nie patrzy si w zby :) Posáu*ymy si przeto klawiszem F10 i pozwolimy
funkcji wykonaü si bez przeszkód.
Zaraz zaraz… Gdzie podziaáa si strzaáka? Czy*by co poszáo nie tak?… Spokojnie,
wszystko jest w jak najlepszym porzdku. Pamitamy, *e funkcja getch() oczekuje na
przycinicie dowolnego klawisza, wic teraz wraz z ni czeka na to caáa aplikacja. Aby
nie przedáu*aü nadto wyczekiwania, przeácz si do okna konsoli i uczy mu zadoü :)
I tak oto dotarlimy do epilogu – punkt wykonania jest teraz na kocu funkcji main(). Tu
koczy si kod napisany przez nas, na program skáada si jednak tak*e dodatkowy kod,
dodany przez kompilator. Oszczdzimy go sobie i wciniciem F5 (tudzie*
Debug|Continue) pozwolimy przebiec po nim sprintem i w konsekwencji zakoczyü
program.

T oto drog zapoznalimy si z bardzo wa*nym narzdziem pracy programisty, czyli
trybem krokowym, prac krokow lub trybem ledzenia

. Widzielimy, *e pozwala on

dokáadnie przestudiowaü dziaáanie programu od pocztku do koca, poprzez wszystkie
jego instrukcje. Z tego powodu jest nieocenionym pomocnikiem przy szukaniu i usuwaniu
bádów w kodzie.

Przebieg programu

Konkluzj naszej przygody z funkcjami i prac krokow bdzie diagram, obrazujcy
dziaáanie programu od pocztku do koca:

Schemat 2. Sposób dziaáania przykáadowego programu

Czarne linie ze strzaákami oznaczaj wywoáywanie i powrót z funkcji, za du*e biaáe – ich
wykonywanie. Program zaczyna si u z lewej strony schematu, a koczy po prawej;
zauwa*my te*, *e w obu tych miejscach wykonywan funkcj jest main(). Prawd jest
zatem fakt, i* to ona jest gáówn czci aplikacji konsolowej.
Jeli opis sáowny nie byá dla ciebie nie do koca zrozumiaáy, to ten schemat powinien
wyjaniü wszystkie wtpliwoci :)

Inne nazwy to tak*e przechodzenie krok po kroku czy ledzenie

Z czego skáada si program?

Zmienne i staáe

Umiemy ju* wypisywaü tekst w konsoli i tworzyü wáasne funkcje. Niestety, nasze
programy s na razie zupeánie bierne, je*eli chodzi o kontakt z u*ytkownikiem. Nie ma on
przy nich nic do roboty oprócz przeczytania komunikatu i wcinicia dowolnego klawisza.
Najwy*szy czas to zmieniü. Napiszmy wic program, który bdzie porozumiewaá si z
u*ytkownikiem. Mo*e on wygldaü na przykáad tak:

// Input – u*ycie zmiennych i strumienia wejcia

#include

#include

#include

<conio.h>

void

main()

{
std::string

strImie;

std::cout

"Podaj swoje imie: "

;

std::cin >> strImie;

std::cout

"Twoje imie to "

<< strImie <<

"."

<< std::endl;

getch();
}

Po kompilacji i uruchomieniu widaü ju* wyra(ny postp w dziedzinie form komunikacji :)
Nasza aplikacja oczekuje na wpisanie imienia u*ytkownika i potwierdzenie klawiszem
ENTER, a nastpnie chwali si dopiero co zdobyt informacj.

Patrzc w kod programu widzimy kilka nowych elementów, zatem nie bdzie
niespodziank, je*eli teraz przystpi do ich omawiania :D

Zmienne i ich typy

Na pocztek zauwa*my, *e program pobiera od nas pewne dane i wykonuje na nich
operacje. S to dziaáania doü trywialne (jak wywietlenie rzeczonych danych w
niezmienionej postaci), jednak wymagaj przechowania przez jaki czas uzyskanej porcji
informacji.
W jzykach programowania sáu* do tego zmienne.

Zmienna (ang. variable) to miejsce w pamici operacyjnej, przechowujce pojedyncz
wartoü okrelonego typu. Ka*da zmienna ma nazw, dziki której mo*na si do niej
odwoáywaü.

Przed pierwszym u*yciem zmienn nale*y zadeklarowaü, czyli po prostu poinformowaü
kompilator, *e pod tak a tak nazw kryje si zmienna danego typu. Mo*e to wygldaü
choüby tak:

std::string strImie;

W ten sposób zadeklarowalimy w naszym programie zmienn typu std::string o
nazwie strImie. W deklaracji piszemy wic najpierw typ zmiennej, a potem jej nazw.
Nazwa zmiennej mo*e zawieraü liczby, litery oraz znak podkrelenia w dowolnej
kolejnoci. Nie mo*na jedynie zaczynaü jej od liczby. W nazwie zmiennej nie jest tak*e
dozwolony znak spacji.

Podstawy programowania

Zasady te dotycz wszystkich nazw w C++ i, jak sdz, nie szczególnie trudne do
przestrzegania.
Z brakiem spacji mo*na sobie poradziü u*ywajc w jej miejsce podkrelenia
(jakas_zmienna) lub rozpoczynaü ka*dy wyraz z wielkiej litery (JakasZmienna).

W jednej linijce mo*emy ponadto zadeklarowaü kilka zmiennych, oddzielajc ich nazwy
przecinkami. Wszystkie bd wtedy przynale*ne do tego samego typu.

Typ okrela nam rodzaj informacji, jakie mo*na przechowywaü w naszej zmiennej. Mog
to byü liczby caákowite, rzeczywiste, tekst (czyli áacuchy znaków, ang. strings), i tak
dalej. Mo*emy tak*e sami tworzyü wáasne typy zmiennych, czym zreszt niedáugo si
zajmiemy. Na razie jednak powinnimy zapoznaü si z doü szerokim wachlarzem typów
standardowych, które to obrazuje niniejsza tabelka:

nazwa typu

opis

int

liczba caákowita (dodatnia lub ujemna)

float

liczba rzeczywista (z czci uáamkow)

bool

wartoü logiczna (prawda lub faász)

char

pojedynczy znak

std::string

acuch znaków (tekst)

Tabela 1. Podstawowe typy zmiennych w C++

U*ywajc tych typów mo*emy zadeklarowaü takie zmienne jak:

int

nLiczba;

// liczba caákowita, np. 45 czy 12 + 89

float

fLiczba;

// liczba rzeczywista (1.4, 3.14, 1.0e-8 itp.)

std::string strNapis;

// dowolny tekst

Byü mo*e zauwa*yáe, *e na pocztku ka*dej nazwy widnieje tu przedrostek, np. str czy

n. Jest to tak zwana notacja wgierska; pozwala ona m.in. rozró*niü typ zmiennej na

podstawie nazwy. Zapis ten staá si bardzo popularny, szczególnie wród programistów

jzyka C++ - spora ich czü uwa*a, *e znacznie poprawia on czytelnoü kodu.

Szerszy opis notacji wgierskiej mo*esz znale(ü w Dodatku A.

Strumie wejcia

Có* by nam jednak byáo po zmiennych, jeli nie mielimy skd wziü dla nich danych?…

Prostych sposobem uzyskania ich jest proba do u*ytkownika o wpisanie odpowiednich
informacji z klawiatury. Tak te* czynimy w aktualnie analizowanym programie –
odpowiada za to kod:

std::cin >> strImie;

Wyglda on podobnie do tego, który jest odpowiedzialny za wypisywanie tekstu w
konsoli. Wykonuje jednak czynnoü dokáadnie odwrotn: pozwala na wprowadzenie
sekwencji znaków i zapisuje j do zmiennej strImie.
std::cin symbolizuje strumie wejcia, który zadaniem jest wáanie pobieranie
wpisanego przez u*ytkownika tekstu. Nastpnie kieruje go (co obrazuj „strzaáki” >>) do
wskazanej przez nas zmiennej.

Zauwa*my, *e w naszej aplikacji kursor pojawia si w tej samej linijce, co komunikat
„Podaj swoje imi”. Nietrudno domyleü si, dlaczego – nie umiecilimy po nim
std::endl, wobec czego nie jest wykonywane przejcie do nastpnego wiersza.

Z czego skáada si program?

Jednoczenie znaczy to, i* strumie wejcia zawsze pokazuje kursor tam, gdzie
skoczylimy pisanie – warto o tym pamitaü.

***

Strumienie wejcia i wyjcia stanowi razem nierozáczn par mechanizmów, które
umo*liwiaj nam peán swobod komunikacji z u*ytkownikiem w aplikacjach
konsolowych.

Schemat 3. Komunikacja midzy programem konsolowym i u*ytkownikiem

Staáe

Staáe s w swoim przeznaczeniu bardzo podobne do zmiennych - tyle tylko *e s…
niezmienne :)) U*ywamy ich, aby nadaü znaczce nazwy jakim niezmieniajcym si
wartociom w programie.

Staáa to niezmienna wartoü, której nadano nazw celem áatwego jej odró*nienia od
innych, czsto podobnych wartoci, w kodzie programu.

Jej deklaracja, na przykáad taka:

const

int

STALA =

;

przypomina nieco sposób deklarowania zmiennych – nale*y tak*e podaü typ oraz nazw.
Sáówko

const

(ang. constant – staáa) mówi jednak kompilatorowi, *e ma do czynienia ze

staá, dlatego oczekuje równie* podania jej wartoci. Wpisujemy j po znaku równoci =.

W wikszoci przypadków staáych u*ywamy do identyfikowania liczb - zazwyczaj takich,
które wystpuj w kodzie wiele razy i maj po kilka znacze w zale*noci od kontekstu.
Pozwala to uniknü pomyáek i poprawia czytelnoü programu.

Staáe maj te* t zalet, *e ich wartoci mo*emy okrelaü za pomoc innych staáych, na
przykáad:

const

int

NETTO =

2000

;

const

int

PODATEK =

;

const

int

BRUTTO = NETTO + NETTO * PODATEK /

100

;

Je*eli kiedy zmieni si jedna z tych wartoci, to bdziemy musieli dokonaü zmiany tylko
w jednym miejscu kodu – bez wzgldu na to, ile razy u*ylimy danej staáej w naszym
programie. I to jest pikne :)

Inne przykáady staáych:

Podstawy programowania

const

int

DNI_W_TYGODNIU =

;

// :-)

const

float

PI =

3.141592653589793

;

// w kocu to te* staáa!

const

int

MAX_POZIOM =

;

// np. w grze RPG

Operatory arytmetyczne

Przyznajmy szczerze: nasze dotychczasowe aplikacje nie wykonywaáy *adnych
sensownych zada – bo czy mo*na nimi nazwaü wypisywanie cigle tego samego tekstu?
Z pewnoci nie. Czy to si szybko zmieni? Niczego nie obiecuj, jednak z czasem
powinno byü w tym wzgldzie coraz lepiej :D

Znajomoü operatorów arytmetycznych z pewnoci poprawi ten stan rzeczy – w kocu
od dawien dawna podstawowym przeznaczeniem wszelkich programów komputerowych
jest wáanie liczenie.

Umiemy liczyü!

Tradycyjnie ju* zaczniemy od przykáadowego programu:

// Arithmetic - proste dziaáania matematyczne

#include

#include

<conio.h>

void

main()

{

int

nLiczba1;

std::cout

"Podaj pierwsza liczbe: "

;

std::cin >> nLiczba1;

int

nLiczba2;

std::cout

"Podaj druga liczbe: "

;

std::cin >> nLiczba2;

int

nWynik = nLiczba1 + nLiczba2;

std::cout << nLiczba1 <<

" + "

<< nLiczba2 <<

" = "

<< nWynik;

getch();
}

Po uruchomieniu skompilowanej aplikacji przekonasz si, i* jest to prosty… kalkulator :)
Prosi on najpierw o dwie liczby caákowite i zwraca pó(niej wynik ich dodawania. Nie jest
to mo*e imponujce, ale z pewnoci bardzo po*yteczne ;)

Zajrzyjmy teraz w kod programu. Pocztkowa czü funkcji main():

int

nLiczba1;

std::cout <<

"Podaj pierwsza liczbe: "

;

std::cin >> nLiczba1;

odpowiada za uzyskanie od u*ytkownika pierwszej z liczb. Mamy tu deklaracj zmiennej,
w której zapiszemy ow liczb, wywietlenie proby przy pomocy strumienia wyjcia oraz
pobranie wartoci za pomoc strumienia wejcia.
Kolejne trzy linijki s bardzo podobne do powy*szych, gdy* ich zadanie jest niemal
identyczne – chodzi oczywicie o zdobycie drugiej liczby naszej sumy. Nie ma wic
potrzeby dokáadnego ich omawiania.

Z czego skáada si program?

Wa*ny jest za to nastpny wiersz:

int

nWynik = nLiczba1 + nLiczba2;

Jest to deklaracja zmiennej nWynik, poáczona z przypisaniem do niej sumy dwóch liczb
uzyskanych poprzednio. Tak czynnoü (natychmiastowe nadanie wartoci deklarowanej
zmiennej) nazywamy inicjalizacj. Oczywicie mo*na by zrobiü to w dwóch instrukcjach,
ale tak jest áadniej, prociej i efektywniej :)

Znak = nie wskazuje tu absolutnie na równoü dwóch wyra*e – jest to bowiem operator
przypisania, którego u*ywamy do ustawiania wartoci zmiennych.

Ostatnie dwie linijki nie wymagaj zbyt wiele komentarza – jest to po prostu
wywietlenie obliczonego wyniku i przywoáanie znanej ju* skdind funkcji getch(),
która oczekuje na dowolny klawisz.

Rodzaje operatorów arytmetycznych

Znak +, którego u*ylimy w napisanym przed chwil programie, jest jednym z kilkunastu
operatorów jzyka C++.

Operator to jeden lub kilka znaków (zazwyczaj niebdcych literami), które maj
specjalne znaczenie w jzyku programowania.

Operatory dzielimy na kilka grup; jedn z nich s wáanie operatory arytmetyczne, które
sáu* do wykonywania prostych dziaáa na liczbach. Odpowiadaj one podstawowym
operacjom matematycznym, dlatego ich poznanie nie powinno nastrczaü ci problemów.
Przedstawia je ta oto tabelka:

operator opis

dodawanie

odejmowanie

mno*enie

dzielenie

reszta z dzielenia

Tabela 2. Operatory arytmetyczne w C++

Pierwsze trzy pozycje s na tyle jasne i oczywiste, *e darujemy sobie ich opis :)
Przyjrzymy si za to bli*ej operatorom zwizanym z dzieleniem.

Operator / dziaáa na dwa sposoby w zale*noci od tego, jakiego typu liczby dzielimy.
Rozró*nia on bowiem dzielenie caákowite, kiedy interesuje nas jedynie wynik bez czci
po przecinku, oraz rzeczywiste, gdy *yczymy sobie uzyskaü dokáadny iloraz. Rzecz
jasna, w takich przypadkach jak

czy

221

wynik bdzie zawsze

liczb caákowit. Gdy jednak mamy do czynienia z liczbami niepodzielnymi przez siebie,
sytuacja nie wyglda ju* tak prosto.
Kiedy zatem mamy do czynienia z którym z typów dzielenia? Zasada jest bardzo prosta
– jeli obie dzielone liczby s caákowite, wynik równie* bdzie liczb caákowit; je*eli
natomiast choü jedna jest rzeczywista, wtedy otrzymamy iloraz wraz z czci uáamkow.
No dobrze, wynika std, *e takie przykáadowe dziaáanie

float

fWynik =

11.5

2.5

;

da nam prawidáowy wynik

4.6

. Co jednak zrobiü, gdy dzielimy dwie niepodzielne liczby

caákowite i chcemy uzyskaü dokáadny rezultat?… Musimy po prostu obie liczby zapisaü

Podstawy programowania

jako rzeczywiste, a wic wraz z czci uáamkow – choüby byáa równa zeru,
przykáadowo:

float

fWynik =

8.0

5.0

;

Uzyskamy w ten sposób prawidáowy wynik

1.6

A co z tym dziwnym „procentem”, czyli operatorem %? Zwizany jest on cile z
dzieleniem caákowitym, mianowicie oblicza nam reszt z dzielenia jednej liczby przez
drug. Dobr ilustracj dziaáania tego operatora mog byü… zakupy :) Powiedzmy, *e
wybralimy si do sklepu z siedmioma záotymi w garci celem nabycia drog kupna
jakiego towaru, który kosztuje 3 záote za sztuk i jest mo*liwy do sprzeda*y jedynie w
caáoci. W takiej sytuacji dzielc (caákowicie!) 7 przez 3 otrzymamy iloü sztuk, które
mo*emy kupiü. Za

int

nReszta =

;

bdzie kwot, która pozostanie nam po dokonaniu transakcji – czyli jedn záotówk. Czy*
to nie banalne? ;)

Priorytety operatorów

Proste obliczenia, takie jak powy*sze, rzadko wystpuj w prawdziwych programach.
Najczciej áczymy kilka dziaáa w jedno wyra*enie i wtedy mo*e pojawiü si problem
pierwszestwa (priorytetu) operatorów, czyli po prostu kolejnoci wykonywania
dziaáa.
W C++ jest ona na szczcie identyczna z t znan nam z lekcji matematyki. Najpierw
wic wykonywane jest mno*enie i dzielenie, a potem dodawanie i odejmowanie. Mo*emy
uáo*yü obrazujc ten fakt tabelk:

priorytet operator(y)

*, /, %

+, -

Tabela 3. Priorytety operatorów arytmetycznych w C++

Najlepiej jednak nie polegaü na tej wáasnoci operatorów i u*ywaü nawiasów w przypadku
jakichkolwiek wtpliwoci.

Nawiasy chroni przed trudnymi do wykrycia bádami zwizanymi z pierwszestwem
operatorów, dlatego stosuj je w przypadku ka*dej wtpliwoci co do kolejnoci dziaáa.

***

W taki oto sposób zapoznalimy si wáanie z operatorami arytmetycznymi.

Tajemnicze znaki

Twórcy jzyka C++ mieli chyba na uwadze oszczdnoü palców i klawiatur programistów,
uczynili wic jego skáadni wyjtkowo zwart i dodali kilka mechanizmów skracajcych
zapis kodu. Z jednym z nich, bardzo czsto wykorzystywanym, zapoznamy si za chwil.

Otó* instrukcje w rodzaju

nZmienna = nZmienna + nInnaZmienna;
nX = nX *

;

Z czego skáada si program?

i = i +

;

j = j –

;

mog byü, przy u*yciu tej techniki, napisane nieco krócej. Zanim j poznamy, zauwa*my,
i* we wszystkich przedstawionych przykáadach po obu stronach znaku = znajduj si te
same zmienne. Instrukcje powy*sze nie s wic przypisywaniem zmiennej nowej
wartoci, ale modyfikacj ju* przechowywanej liczby.
Korzystajc z tego faktu, pierwsze dwie linijki mo*emy zapisaü jako

nZmienna += nInnaZmienna;
nX *=

;

Jak widzimy, operator + przeszedá w +=, za * w *=. Podobna „sztuczka” mo*liwa jest
tak*e dla trzech pozostaáych znaków dziaáa

. Sposób ten nie tylko czyni kod krótszym,

ale tak*e przyspiesza jego wykonywanie (pomyl, dlaczego!).
Je*eli chodzi o nastpne wiersze, to oczywicie dadz si one zapisaü w postaci

i +=

;

j -=

;

Mo*na je jednak skróciü (i przyspieszyü) nawet bardziej. Dodawanie i odejmowanie
jedynki s bowiem na tyle czstymi czynnociami, *e dorobiáy si wáasnych operatorów
++ i –- (tzw. inkrementacji i dekrementacji), których u*ywamy tak:

i++;
j--;

lub

tak:

++i;
--j;

Na pierwszy rzut oka wyglda to nieco dziwnie, ale gdy zaczniesz stosowaü t technik w
praktyce, szybko docenisz jej wygod.

Podsumowanie

Bohatersko brnc przez kolejne akapity dotarlimy wreszcie do koca tego rozdziaáu :))
Przyswoilimy sobie przy okazji spory kawaáek koderskiej wiedzy.

Rozpoczlimy od bliskiego spotkania z IDE Visual Studio, nastpnie napisalimy swój
pierwszy program. Po zapoznaniu si z dziaáaniem strumienia wyjcia, przeszlimy do
funkcji (przy okazji poznajc uroki trybu ledzenia), a potem wreszcie do zmiennych i
strumienia wejcia. Gdy ju* dowiedzielimy si, czym one s, okrasilimy wszystko
drobn porcj informacji na temat operatorów arytmetycznych. Smacznego! ;)

Pytania i zadania

Od niestrawnoci uchroni ci odpowiedzi na poni*sze pytania i wykonanie üwicze :)

A tak*e dla niektórych innych rodzajów operatorów, które poznamy pó(niej

Istnieje ró*nica midzy tymi dwoma formami zapisu, ale na razie nie jest ona dla nas istotna… co nie znaczy,

e nie bdzie :)

Podstawy programowania

Pytania

Dziki jakim elementom jzyka C++ mo*emy wypisywaü tekst w konsoli i zwracaü
si do u*ytkownika?

Jaka jest rola funkcji w kodzie programu?

Czym s staáe i zmienne?

Wymie poznane operatory arytmetyczne.

wiczenia

Napisz program wywietlajcy w konsoli trzy linijki tekstu i oczekujcy na dowolny
klawisz po ka*dej z nich.

Zmie program napisany przy okazji poznawania zmiennych (ten, który pytaá o
imi) tak, aby zadawaá równie* pytanie o nazwisko i wywietlaá te dwie informacje
razem (w rodzaju „Nazywasz si Jan Kowalski”).

Napisz aplikacj obliczajc iloczyn trzech podanych liczb.

(Trudne) Poczytaj, na przykáad w

MSDN

, o deklarowaniu staáych za pomoc

dyrektywy

#define

. Zastanów si, jakie niebezpieczestwo bádów mo*e byü z

tym zwizane.
Wskazówka: chodzi o priorytety operatorów.

DZIAàANIE PROGRAMU

Nic nie dzieje si wbrew naturze,

lecz wbrew temu, co o niej wiemy.

Fox Mulder w serialu „Z archiwum X”

Poznalimy ju* przedsmak uroków programowania w C++ i stworzylimy kilka wáasnych
programów. Opanowalimy jednoczenie najbardziej podstawowe podstawy podstaw
kodowania w tym jzyku :)

Mo*emy wic odkryü kolejne, wa*ne jego elementy, które pozwol nam tworzyü bardziej
interesujce i przydatne programy. Przyszáa bowiem pora na spotkanie z instrukcjami
sterujcymi przebiegiem aplikacji i sposobem jej dziaáania.

Funkcje nieco bli*ej

Z funkcjami mielimy do czynienia ju* wczeniej. Powiedzielimy sobie wtedy, *e s to
wydzielone fragmenty kodu realizujce jak czynnoü. Przytoczyáem przy tym doü
banalny przykáad funkcji PokazTekst(), wywietlajcej w konsoli ustalony napis.

Niewtpliwie byá on klarowny i ukazywaá wspomniane tam przeznaczenie funkcji (czyli
podziaá kodu na fragmenty), jednak*e pomijaá dwa bardzo wa*ne aspekty z nimi
zwizane. Chodzi mianowicie o parametry oraz zwracanie wartoci. Rozszerzaj one
u*ytecznoü i mo*liwoci funkcji tak znacznie, *e bez nich w zasadzie trudno wyobraziü
sobie skuteczne i efektywne programowanie.

W takiej sytuacji nie mo*emy wszak przejü obok nich obojtnie - niezwáocznie
przystpimy zatem do poznawania tych arcywa*nych zagadnie :)

Parametry funkcji

Nie tylko w programowaniu trudno wskazaü operacj, któr mo*na wykonaü bez
posiadania o niej dodatkowych informacji. Przykáadowo, nie mo*na wykonaü operacji
kopiowania czy przesunicia pliku do innego katalogu, jeli nie jest znana nazwa tego*
pliku oraz nazwa docelowego folderu.
Gdybymy napisali funkcj realizujc tak czynnoü, to nazwy pliku oraz katalogu
finalnego byáyby jej parametrami.

Parametry funkcji to dodatkowe dane, przekazywane do funkcji podczas jej wywoáania.

Parametry peáni rol dodatkowych zmiennych wewntrz funkcji i mo*na ich u*ywaü
podobnie jak innych zmiennych, zadeklarowanych w niej bezporednio. Ró*ni si one
oczywicie tym, *e wartoci parametrów pochodz z „zewntrz” – s im przypisywane
podczas wywoáania funkcji.

Podstawy programowania

Po tym krótkim opisie czas na obrazowy przykáad. Oto zmodyfikujemy nasz program
liczcy tak, *eby korzystaá z dobrodziejstw parametrów funkcji:

// Parameters - wykorzystanie parametrów funkcji

#include

#include

<conio.h>

void

Dodaj(

int

nWartosc1,

int

nWartosc2)

{

int

nWynik = nWartosc1 + nWartosc2;

std::cout << nWartosc1 <<

" + "

<< nWartosc2 <<

" = "

<< nWynik;

std::cout << std::endl;

}

void

main()

{

int

nLiczba1;

std::cout

"Podaj pierwsza liczbe: "

;

std::cin >> nLiczba1;

int

nLiczba2;

std::cout

"Podaj druga liczbe: "

;

std::cin >> nLiczba2;

Dodaj (nLiczba1, nLiczba2);

getch();
}

Rzut oka na dziaáajcy program pozwala stwierdziü, i* wykonuje on tak sam prac, jak
jego poprzednia wersja. Z kolei spojrzenie na kod ujawnia w nim widoczne zmiany –
przyjrzyjmy si im.

Zasadnicza czynnoü programu, czyli dodawanie dwóch liczb, zostaáa wyodrbniona w
postaci osobnej funkcji Dodaj(). Posiada ona dwa parametry nWartosc1 i nWartosc2,
które s w niej dodawane do siebie i wywietlane w konsoli.
Wielce interesujcy jest w zwizku z tym nagáówek funkcji Dodaj(), zawierajcy
deklaracj owych dwóch parametrów:

void

Dodaj(

int

nWartosc1,

int

nWartosc2)

Jak sam widzisz, wyglda ona bardzo podobnie do deklaracji zmiennych – najpierw
piszemy typ parametru, a nastpnie jego nazw. Nazwa ta pozwala odwoáywaü si do
wartoci parametru w kodzie funkcji, a wic na przykáad u*yü jej jako skáadnika sumy.
Okrelenia kolejnych parametrów oddzielamy od siebie przecinkami, za caá deklaracj
umieszczamy w nawiasie po nazwie funkcji.

Wywoáanie takiej funkcji jest raczej oczywiste:

Dodaj (nLiczba1, nLiczba2);

Podajemy tu w nawiasie kolejne wartoci, które zostan przypisane jej parametrom;
oddzielamy je tradycyjnie ju* przecinkami. W niniejszym przypadku parametrowi
nWartosc1 zostanie nadana wartoü zmiennej nLiczba1, za nWartosc2 – nLiczba2.
Myl, *e jest to doü intuicyjne i nie wymaga wicej wyczerpujcego komentarza :)

***

Dziaáanie programu

Reasumujc: parametry pozwalaj nam przekazywaü funkcjom dodatkowe dane, których
mog u*yü do wykonania swoich dziaáa. Iloü, typy i nazwy parametrów deklarujemy w
nagáówku funkcji, za podczas jej wywoáywania podajemy ich wartoci w analogiczny
sposób.

Wartoü zwracana przez funkcj

Spora czü funkcji pisanych przez programistów ma za zadanie obliczenie jakiego
wyniku (czsto na podstawie przekazanych im parametrów). Inne z kolei wykonuj
operacje, które nie zawsze musz si udaü (choüby usunicie pliku – dany plik mo*e
przecie* ju* nie istnieü).
W takich przypadkach istnieje wic potrzeba, by funkcja zwróciáa jak wartoü.
Niekiedy bdzie to rezultat jej intensywnej pracy, a innym razem jedynie informacja, czy
zlecona funkcji czynnoü zostaáa wykonana pomylnie.

Zgodnie ze zwyczajem, popatrzymy teraz na odpowiedni program przykáadowy

:) Pyta

on u*ytkownika o dáugoci boków prostokta, wywietlajc w zamian jego pole
powierzchni oraz obwód. Czyni to ten kod (jest to fragment funkcji main()):

// ReturnValue - funkcje zwracajce wartoü

int

nDlugosc1;

std::cout <<

"Podaj dlugosc pierwszego boku: "

;

std::cin >> nDlugosc1;

int

nDlugosc2;

std::cout <<

"Podaj dlugosc drugiego boku: "

;

std::cin >> nDlugosc2;

std::cout <<

"Obwod prostokata: "

<< Obwod(nDlugosc1, nDlugosc2) <<

std::endl;
std::cout <<

"Pole prostokata: "

<< Pole(nDlugosc1, nDlugosc2) <<

std::endl;
getch();

Linijki wywietlajce gotowy wynik zawieraj wywoáania dwóch funkcji – Obwod() i
Pole(). Mo*na je umieciü w tym miejscu, gdy* zwracaj one wartoci – w dodatku te,
które chcemy zaprezentowaü :) Wywietlamy je dokáadnie w ten sam sposób jak wartoci
zmiennych i wszystkich innych wyra*e liczbowych.

Caáa istota dziaáania aplikacji zawiera si wic w tych dwóch funkcjach. Prezentuj si
one nastpujco:

int

Obwod(

int

nBok1,

int

nBok2)

{

return

* (nBok1 + nBok2);

}

int

Pole(

int

nBok1,

int

nBok2)

{

return

nBok1 * nBok2;

}

Có* ciekawego mo*emy o nich rzec? Widoczn ró*nic w stosunku do dotychczasowych
przykáadów funkcji, jakie mielimy okazj napotkaü, jest chocia*by zastpienie sáówka

Caáoü programu jest doáczona do tutoriala, tutaj zaprezentujemy tylko jego najwa*niejsze fragmenty

Podstawy programowania

void

przez nazw typu,

int

. To oczywicie nie przypadek – w taki wáanie sposób

informujemy kompilator, i* nasza funkcja ma zwracaü wartoü oraz wskazujemy jej typ.
Kod funkcji to tylko jeden wiersz, zaczynajcy si od

return

(‘powrót’). Okrela on ni

mniej, ni wicej, jak tylko ow wartoü, która bdzie zwrócona i stanie si wynikiem
dziaáania funkcji. Rezultat ten zobaczymy w kocu i my w oknie konsoli:

Screen 10. Miernik prostoktów w akcji

return

powoduje jeszcze jeden efekt, który nie jest tu tak wyra(nie widoczny. U*ycie tej

instrukcji skutkuje mianowicie natychmiastowym przerwaniem dziaáania funkcji i
powrotem do miejsca jej wywoáania. Wprawdzie nasze proste funkcje i tak kocz si
niemal od razu, wic nie ma to wikszego znaczenia, jednak w przypadku powa*niejszych
podprogramów nale*y o tym fakcie pamitaü.

Wynika z niego tak*e mo*liwoü u*ycia

return

w funkcjach niezwracajcych *adnej

wartoci – mo*na je w ten sposób przerwaü, zanim wykonaj swój kod w caáoci.
Poniewa* nie mamy wtedy *adnej wartoci do zwracania, u*ywamy samego sáowa

return

; - bez wskazywania nim jakiego wyra*enia.

***

Dowiedzielimy si zatem, i* funkcja mo*e zwracaü wartoü jako wynik swej pracy.
Rezultat taki winien byü okrelonego typu – deklarujemy go w nagáówku funkcji jeszcze
przed jej nazw. Natomiast w kodzie funkcji mo*emy u*yü instrukcji

return

, by wskazaü

wartoü bdc jej wynikiem. Jednoczenie instrukcja ta spowoduje zakoczenie
dziaáania funkcji.

Skáadnia funkcji

Gdy ju* poznalimy zawiáoci i niuanse zwizane z u*ywaniem funkcji w swoich
aplikacjach, mo*emy t wydatn porcj informacji podsumowaü ogólnymi reguáami
skáadniowymi dla podprogramów w C++. Otó* postaü funkcji w tym jzyku jest
nastpujca:

typ_zwracanej_wartoci/

void

nazwa_funkcji([typ_parametru nazwa, ...])

{
instrukcje_1

return

wartoü_funkcji_1;

instrukcje_2

return

wartoü_funkcji_2;

instrukcje_3

return

wartoü_funkcji_3;

...

return

wartoü_funkcji_n;

}

Je*eli dokáadnie przestudiowaáe (i zrozumiaáe! :)) wiadomoci z tego paragrafu i z
poprzedniego rozdziaáu, nie powinna byü ona dla ciebie *adnym zaskoczeniem.

Wyszukiwarka

Podobne podstrony:
inwestycje, OD ZERA DO MIL1009/131033/1762
Od zera do gier kodera7
Od zera do gier kodera5
Od zer1021/8852
od zera do ecedeela cz 2

więcej podobnych podstron