Od zera do gier kodera3np

Dziaáanie programu

Zauwa* jeszcze, ze fraza

return

mo*e wystpowaü kilka razy, zwracaü w ka*dym z

wariantów ró*ne wartoci, a caáoü funkcji mieü logiczny sens i dziaáaü poprawnie. Jest to
mo*liwe midzy innymi dziki instrukcjom warunkowym, które poznamy ju* za chwil.

***

W ten oto sposób uzyskalimy bardzo wa*n umiejtnoü programistyczn, jak jest
poprawne u*ywanie funkcji we wáasnych programach. Upewnij si przeto, i* skrupulatnie
przyswoiáe sobie informacje o tym zagadnieniu, jakie serwowaáem w aktualnym i
poprzednim rozdziale. W dalszej czci kursu bdziemy czsto korzystaü z funkcji w
przykáadowych kodach i omawianych tematach, dlatego wa*ne jest, by nie miaá
káopotów z nimi.

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

Jeli natomiast czujesz si na siáach i chcesz dowiedzieü czego wicej o funkcjach,

zajrzyj do

pomocy MSDN

zawartej w Visual Studio.

Sterowanie warunkowe

Dobrze napisany program powinien byü przygotowany na ka*d ewentualnoü i
nietypow sytuacj, jaka mo*e si przydarzyü w czasie jego dziaáania. W niektórych
przypadkach nawet proste czynnoci mog potencjalnie koczyü si niepowodzeniem, za
porzdna aplikacja musi radziü sobie z takimi drobnymi (lub caákiem sporymi) kryzysami.
Oczywicie program nie uczyni nic, czego nie przewidziaáby jego twórca. Dlatego te*
wa*nym zadaniem programisty jest opracowanie kodu reagujcego odpowiednio na
nietypowe sytuacje, w rodzaju bádnych danych wprowadzonych przez u*ytkownika lub
braku pliku potrzebnego aplikacji do dziaáania.

Mo*liwe s te* przypadki, w których dla kilku caákowicie poprawnych sytuacji, danych itp.
trzeba wykonaü zupeánie inne operacje. Wa*ne jest wtedy rozró*nienie tych wszystkich
wariantów i skierowanie dziaáania programu na wáaciwe tory, gdy ma miejsce który z
nich.

Do wszystkich tych zada stworzono w C++ (i w ka*dym jzyku programowania) zestaw
odpowiednich narzdzi, zwanych instrukcjami warunkowymi. Ich przeznaczeniem jest
wáanie dokonywanie ró*norakich wyborów, zale*nych od ustalonych warunków.
Jak widaü, przydatnoü tych konstrukcji jest nadspodziewanie du*a, *al byáoby wic
ominü je bez wnikania w ich szczegóáy, prawda? :) Niezwáocznie zatem zajmiemy si
nimi, poznajc ich skáadni i sposób funkcjonowania.

Instrukcja warunkowa

Instrukcja

(‘je*eli’) pozwala wykonaü jaki kod tylko wtedy, gdy speániony jest

okrelony warunek. Jej dziaáanie sprowadza si wic do sprawdzenia tego* warunku i,
jeli zostanie stwierdzona jego prawdziwoü, wykonania wskazanego bloku kodu.
T prost ide mo*e ilustrowaü choüby taki przykáad:

// SimpleIf – prosty przykáad instrukcji if

void

main()

{

int

nLiczba;

std::cout

"Wprowadz liczbe wieksza od 10: "

;

std::cin >> nLiczba;

Podstawy programowania

(nLiczba >

)

{

std::cout

"Dziekuje."

<< std::endl;

std::cout

"Wcisnij dowolny klawisz, by zakonczyc."

;

getch();

}
}

Uruchom ten program dwa razy – najpierw podaj liczb mniejsz od 10, za za drugim
razem speánij *yczenie aplikacji. Zobaczysz, *e w pierwszym przypadku zostaniesz
potraktowany raczej maáo przyjemnie, gdy* program bez sáowa zakoczy si. W drugim
natomiast otrzymasz stosowne podzikowanie za swoj uprzejmoü ;)
„Winna” jest temu, jak*eby inaczej, wáanie instrukcja

. W linijce:

(nLiczba >

)

wykonywane jest bowiem sprawdzenie, czy podana przez ciebie liczba jest rzeczywicie
wiksza od 10. Wyra*enie nLiczba >

jest tu wic warunkiem instrukcji

W przypadku, gdy oka*e si on prawdziwy, wykonywane s trzy instrukcje zawarte w
nawiasach klamrowych. Jak pamitamy, sekwencj tak nazywamy blokiem kodu.
Je*eli za warunek jest nieprawdziwy (a liczba mniejsza lub równa 10), program omija
ten blok i wykonuje nastpn instrukcj wystpujc za nim. Poniewa* jednak u nas po
bloku

nie ma *adnych instrukcji, aplikacja zwyczajnie koczy si, gdy* nie ma nic

konkretnego do roboty :)

Po takim sugestywnym przykáadzie nie od rzeczy bdzie przedstawienie skáadni instrukcji
warunkowej

w jej prostym wariancie:

(warunek)

{

instrukcje

}

Stopie jej komplikacji z pewnoci sytuuje si poni*ej przecitnej ;) Nic w tym dziwnego
– to w zasadzie najprostsza, lecz jednoczenie bardzo czsto u*ywana konstrukcja
programistyczna.
Warto jeszcze zapamitaü, *e blok instrukcji skáadajcy si tylko z jednego polecenia
mo*emy zapisaü nawet bez nawiasów klamrowych

. Wtedy jednak nale*y postawiü na

jego kocu rednik:

(warunek) instrukcja;

Taka skrócona wersja jest u*ywana czsto do sprawdzania wartoci parametrów funkcji,
na przykáad:

void

Funkcja(

int

nParametr)

{

// sprawdzenie, czy parametr nie jest mniejszy lub równy zeru -

je*eli tak, to funkcja koczy si

(nParametr <=

)

return

;

// ... (reszta funkcji)

}

Zasada ta dotyczy prawie ka*dego bloku kodu w C++ (z wyjtkiem funkcji)

Dziaáanie programu

Fraza

else

Prosta wersja instrukcji

nie zawsze jest wystarczajca – nieeleganckie zachowanie

naszego przykáadowego programu jest dobrym tego uzasadnieniem. Powinien on wszak*e
pokazaü stosowny komunikat równie* wtedy, gdy u*ytkownik nie wyka*e si chci
wspóápracy i nie wprowadzi *danej liczby. Musi wic uwzgldniü przypadek, w którym
warunek badany przez instrukcj

(u nas nLiczba >

) nie jest prawdziwy i

zareagowaü na w odpowiedni sposób.
Naturalnie, mo*na by umieciü stosowny kod po konstrukcji

, ale jednoczenie

nale*aáoby zadbaü, aby nie byá on wykonywany w razie prawdziwoci warunku. Sztuczka
z dodaniem instrukcji

return

; (przerywajcej funkcj main(), a wic i caáy program) na

koniec bloku

zdaáaby oczywicie egzamin, lecz straty w przejrzystoci i prostocie kodu

byáyby zdecydowanie niewspóámierne do efektów :))
Dlatego te* C++, jako pretendent do miana nowoczesnego jzyka programowania,
posiada bardziej sensowny i logiczny sposób rozwizania tego problemu. Jest nim
mianowicie fraza

else

(‘w przeciwnym wypadku’) – czü instrukcji warunkowej

Korzystajca z niej, ulepszona wersja poprzedniej aplikacji przykáadowej mo*e zatem
wygldaü chocia*by tak:

// Else – blok alternatywny w instrukcji if

void

main()

{

int

nLiczba;

std::cout

"Wprowadz liczbe wieksza od 10: "

;

std::cin >> nLiczba;

(nLiczba >

)

{

std::cout

"Dziekuje."

<< std::endl;

std::cout

"Wcisnij dowolny klawisz, by zakonczyc."

;

}

else

{

std::cout

"Liczba "

<< nLiczba

" nie jest wieksza od 10."

<< std::endl;

std::cout

"Czuj sie upomniany :P"

;

}

getch();
}

Gdy uruchomisz powy*szy program dwa razy, w podobny sposób jak poprzednio, w
ka*dym wypadku zostaniesz poczstowany jakim komunikatem. Zale*nie od wpisanej
przez ciebie liczby bdzie to podzikowanie albo upomnienie :)

Screeny 11 i 12. Dwa warianty dziaáania programu, czyli instrukcje

else

w caáej swej krasie :)

Wystpujcy tu blok

else

jest uzupeánieniem instrukcji

– kod w nim zawarty zostanie

wykonany tylko wtedy, gdy okrelony w

warunek nie bdzie speániony. Dziki temu

mo*emy odpowiednio zareagowaü na ka*d ewentualnoü, a zatem nasz program
zachowuje si porzdnie w obu mo*liwych przypadkach :)

Podstawy programowania

Funkcja getch() jest w tej aplikacji wywoáywana poza blokami warunkowymi, gdy*
niezale*nie od wpisanej liczby i treci wywietlanego komunikatu istnieje potrzeba
poczekania na dowolny klawisz. Zamiast wic umieszczaü t instrukcj zarówno w bloku

, jak i

else

, mo*na j zostawiü caákowicie poza nimi.

Czas teraz zaprezentowaü skáadni peánej wersji instrukcji

, uwzgldniajcej tak*e blok

alternatywny

else

(warunek)

{

instrukcje_1

}

else

{

instrukcje_2

}

Kiedy warunek jest prawdziwy, uruchamiane s instrukcje_1, za w przeciwnym
przypadku (

else

) – instrukcje_2. Czy wiat widziaá kiedy co równie

elementarnego? ;) Nie daj si jednak zwieü tej prostocie – instrukcja warunkowa

jest

w istocie pot*nym narzdziem, z którego intensywnie korzystaj wszystkie programy.

Bardziej záo*ony przykáad

By caákowicie upewniü si, i* znamy i rozumiemy t szalenie wa*n konstrukcj
programistyczn, przeanalizujemy ostatni, bardziej skomplikowan ilustracj jej u*ycia.
Bdzie to aplikacja rozwizujca równania liniowe – tzn. wyra*enia postaci:

Jak zapewne pamitamy ze szkoáy, mog mieü one zero, jedno lub nieskoczenie wiele
rozwiza, a wszystko zale*y od wartoci wspóáczynników a i b. Mamy zatem du*e pole
do popisu dla instrukcji

Program realizujcy to zadanie wyglda wic tak:

// LinearEq – rozwizywanie równa liniowych

float

fA;

std::cout <<

"Podaj wspolczynnik a: "

;

std::cin >> fA;

float

fB;

std::cout <<

"Podaj wspolczynnik b: "

;

std::cin >> fB;

(fA ==

0.0

)

{

(fB ==

0.0

)

std::cout <<

"Rownanie spelnia kazda liczba rzeczywista."

std::endl;

else

std::cout

"Rownanie nie posiada rozwiazan."

<< std::endl;

}

else

std::cout

"x = "

<< -fB / fA << std::endl;

getch();

Dziaáanie programu

Zagnie*d*ona instrukcja

wyglda mo*e cokolwiek tajemniczo, ale w gruncie rzeczy

istota jej dziaáania jest w miar prosta. Wyjanimy j za moment.
Najpierw powtórka z matematyki :) Przypomnijmy, i* równanie liniowe ax + b = 0:

posiada nieskoczenie wiele rozwiza, je*eli wspóáczynniki a i b s jednoczenie
równe zeru

nie posiada w ogóle rozwiza, je*eli a jest równe zeru, za b nie

ma dokáadnie jedno rozwizanie (-b/a), gdy a jest ró*ne od zera

Wynika std, *e istniej trzy mo*liwe przypadki i scenariusze dziaáania programu.
Zauwa*my jednak, *e warunek „a jest równe zeru” jest konieczny do realizacji dwóch z
nich – mo*emy wic go wyodrbniü i zapisaü w postaci pierwszej (bardziej zewntrznej)
instrukcji

Nadal wszak*e pozostaje nam problem wspóáczynnika b – sam fakt zerowej wartoci a
nie przecie* pozwala na obsáu*enie wszystkich mo*liwoci. Rozwizaniem jest
umieszczenie instrukcji sprawdzajcej b (czyli tak*e

) wewntrz bloku

sprawdzajcego a! Umo*liwia to poprawne wykonanie programu dla wszystkich wartoci
liczb a i b.

Screen 13. Program rozwizujcy równania liniowe

U*ywamy tote* dwóch instrukcji

, które razem odpowiadaj za wáaciwe zachowanie

si aplikacji w trzech mo*liwych przypadkach. Pierwsza z nich:

(fA ==

0.0

)

kontroluje wartoü wspóáczynnika a i tworzy pierwsze rozgaázienie na szlaku dziaáania
programu. Jedna z wychodzcych z niego dróg prowadzi do celu zwanego „dokáadnie
jedno rozwizanie równania”, druga natomiast do kolejnego rozwidlenia:

(fB ==

0.0

)

Ono te* kieruje wykonywanie aplikacji albo do „nieskoczenie wielu rozwiza”, albo te*
do „braku rozwiza” równania – zale*y to oczywicie od ewentualnej równoci b z
zerem.

Operatorem równoci w C++ jest ==, czyli podwójny znak „równa si” (=). Nale*y
koniecznie odró*niaü go od operatora przypisania, czyli pojedynczego znaku =. Jeli
omyákowo u*ylibymy tego drugiego w wyra*eniu bdcym warunkiem, to
najprawdopodobniej byáby on zawsze albo prawdziwy, albo faászywy

– na pewno jednak

nie dziaáaáby tak, jak bymy tego oczekiwali. Co gorsza, mo*na by si o tym przekonaü
dopiero w czasie dziaáania programu, gdy* jego kompilacja przebiegáaby bez zakáóce.
Pamitajmy wic, by w wyra*eniach warunkowych do sprawdzania równoci u*ywaü
zawsze operatora ==, rezerwujc znak = do przypisywania wartoci zmiennym.

***

Zale*aáoby to od wartoci po prawej stronie znaku równoci – jeli byáaby równa zeru, warunek byáby

faászywy, w przeciwnym wypadku - prawdziwy

Podstawy programowania

Ostrze*eniem tym koczymy nasze nieco przydáugie spotkanie z instrukcj warunkow

. Mo*na miaáo powiedzieü, *e oto poznalimy jeden z fundamentów, na których opiera

si dziaáanie wszelkich algorytmów w programach komputerowych. Twoje aplikacje
nabior przez to elastycznoci i bd zdolne do wykonywania mniej trywialnych zada…
je*eli sumiennie przestudiowaáe ten podrozdziaá! :))

Instrukcja wyboru

switch

Instrukcja

switch

(‘przeácz’) jest w pewien sposób podobna do

: jej przeznaczeniem

jest tak*e wybór jednego z wariantów kodu podczas dziaáania programu. Pomidzy
obiema konstrukcjami istniej jednak doü znaczne ró*nice.
O ile

podejmuje decyzj na podstawie prawdziwoci lub faászywoci jakiego warunku,

o tyle

switch

bierze pod uwag wartoü podanego wyra*enia. Z tego te* powodu mo*e

dokonywaü wyboru sporód wikszej liczby mo*liwoci ni* li tylko dwóch (prawdy lub
faászu).
Najlepiej widaü to na przykáadzie:

// Switch – instrukcja wyboru

void

main()

{

// (pomijam tu kod odpowiedzialny za pobranie od u*ytkownika dwóch

// liczb – robilimy to tyle razy, *e nie powiniene mieü z tym

káopotów :)) Liczby s zapisane w zmiennych fLiczba1 i fLiczba2)

int

nOpcja;

std::cout

"Wybierz dzialanie:"

<< std::endl;

std::cout

"1. Dodawanie"

<< std::endl;

std::cout

"2. Odejmowanie"

<< std::endl;

std::cout

"3. Mnozenie"

<< std::endl;

std::cout

"4. Dzielenie"

<< std::endl;

std::cout

"0. Wyjscie"

<< std::endl;

std::cout

"Twoj wybor: "

;

std::cin >> nOpcja;

switch

(nOpcja)

{

case

: std::cout << fLiczba1 <<

" + "

<< fLiczba2 <<

" = "

fLiczba1

fLiczba2;

break

;

case

: std::cout << fLiczba1 <<

" - "

<< fLiczba2 <<

" = "

fLiczba1

fLiczba2;

break

;

case

: std::cout << fLiczba1 <<

" * "

<< fLiczba2 <<

" = "

fLiczba1

fLiczba2;

break

;

case

(fLiczba2 ==

0.0

)

std::cout

"Dzielnik nie moze byc zerem!"

;

else

std::cout << fLiczba1 <<

" / "

<< fLiczba2 <<

" = "

fLiczba1

fLiczba2;

break

;

case

: std::cout <<

"Dziekujemy :)"

;

break

;

default

: std::cout <<

"Nieznana opcja!"

;

}

getch();
}

No, to ju* jest program, co si zowie: posiada szerok funkcjonalnoü, prosty interfejs –
krótko mówic peáen profesjonalizm ;) Tym bardziej wic powinnimy przejrzeü

Dziaáanie programu

dokáadniej jego kod (ródáowy - zwa*ywszy, i* zawiera interesujc nas w tym momencie
instrukcj

switch

Zajmuje ona zreszt poka(n czü listingu; na dodatek jest to ten fragment, w którym
wykonywane s obliczenia, bdce podstaw dziaáania programu. Jaka jest zatem rola tej
konstrukcji?

Screen 14. Kalkulator w dziaáaniu

Có*, nie jest trudno domyleü si jej – skoro mamy w naszym programie menu,
bdziemy te* mieli kilka wariantów jego dziaáania. Wybranie przez u*ytkownika jednego z
nich zostaje wcielone w *ycie wáanie poprzez instrukcj

switch

. Porównuje ona kolejno

wartoü zmiennej nOpcja (do której zapisujemy numer wskazanej pozycji menu) z
picioma wczeniej ustalonymi przypadkami. Ka*demu z nich odpowiada fragment kodu,
zaczynajcy si od sáówka

case

(‘przypadek’) i koczcy na

break

; (‘przerwij’). Gdy

który z nich zostanie uznany za wáaciwy (na podstawie wartoci wspomnianej ju*
zmiennej), wykonywane s zawarte w nim instrukcje. Je*eli za *aden nie bdzie
pasowaá, program „skoczy” do dodatkowego wariantu

default

(‘domylny’) i uruchomi

jego kod. Ot, i caáa filozofia :)

Po tym pobie*nym wyjanieniu dziaáania instrukcji

switch

, poznamy jej peán postaü

skáadniow:

switch

(wyra*enie)

{

case

wartoü_1:

instrukcje_1

[

break

;]

case

wartoü_2:

instrukcje_2

[

break

;]

...

case

wartoü_n;

instrukcje_n;

[

break

;]

[

default

instrukcje_domylne]

}

Korzystajc z niej, jeszcze prociej zrozumieü przeznaczenie konstrukcji

switch

oraz

wykonywane przez ni czynnoci. Mianowicie, oblicza ona wpierw wynik wyra*enia, by
potem porównywaü go kolejno z podanymi (w instrukcjach

case

) wartociami. Kiedy

stwierdzi, *e zachodzi równoü, skacze na pocztek pasujcego wariantu i wykonuje caáy
kod a* do koca bloku

switch

Zaraz – jak to do koca bloku? Przecie* w naszym przykáadowym programie, gdy
wybralimy, powiedzmy, operacj odejmowania, to otrzymywalimy wyácznie ró*nic
liczb – bez iloczynu i ilorazu (czyli dalszych opcji). Przyczyna tego tkwi w instrukcji

Podstawy programowania

break

, umieszczonej na kocu ka*dej pozycji rozpocztej przez

case

. Polecenie to

powoduje bowiem przerwanie dziaáania konstrukcji

switch

i wyjcie z niej; tym

sposobem zapobiega ono wykonaniu kodu odpowiadajcego nastpnym wariantom.

W wikszoci przypadków nale*y zatem koczyü fragment kodu rozpoczty przez

case

instrukcj

break

- gwarantuje to, i* tylko jedna z mo*liwoci ustalonych w

switch

zostanie wykonana.

Znaczenie ostatniej, nieobowizkowej frazy

default

wyjanilimy sobie ju* wczeniej.

Mo*na jedynie dodaü, *e peáni ona w

switch

podobn rol, co

else

i umo*liwia

wykonanie jakiego kodu tak*e wtedy, gdy *adna z przewidzianych wartoci nie bdzie
zgadzaü si z wyra*eniem. Brak tej instrukcji bdzie za skutkowaü niepodjciem
*

adnych dziaáa w takim przypadku.

***

Omówilimy w ten sposób obie konstrukcje, dziki którym mo*na sterowaü przebiegiem
programu na podstawie ustalonych warunków czy te* wartoci wyra*e. Potrafimy wic
ju* sprawiü, aby nasze aplikacje zachowywaáy si prawidáowo niezale*nie od okolicznoci.
Nie zmienia to jednak faktu, *e nadal potrafi one co najwy*ej tyle, ile maáo funkcjonalny
kalkulator i nie wykorzystuj w peáni w ogromnych mo*liwoci komputera. Zmieniü to
mo*e kolejny element jzyka C++, który teraz wáanie poznamy. Przy pomocy ptli, bo o
nich mowa, zdoáamy zatrudniü leniuchujcy dotd procesor do wyt*onej pracy, która
wycinie z niego siódme poty ;)

Ptle

Ptle (ang. loops), zwane te* instrukcjami iteracyjnymi, stanowi podstaw prawie
wszystkich algorytmów. Lwia czü zada wykonywanych przez programy komputerowe
opiera si w caáoci lub czciowo wáanie na ptlach.

Ptla to element jzyka programowania, pozwalajcy na wielokrotne, kontrolowane
wykonywanie wybranego fragmentu kodu.

Liczba takich powtórze (zwanych cyklami lub iteracjami ptli) jest przy tym
ograniczona w zasadzie tylko inwencj i rozsdkiem programisty. Te pot*ne narzdzia
daj wic mo*liwoü zrealizowania niemal ka*dego algorytmu.
Ptle s te* niewtpliwie jednym z atutów C++: ich elastycznoü i prostota jest wiksza
ni* w wielu innych jzykach programowania. Je*eli zatem bdziesz kiedy kodowaá jak
záo*on funkcj przy u*yciu skomplikowanych ptli, z pewnoci przypomnisz sobie i
docenisz te zalety :)

Ptle warunkowe

while

Na pocztek poznamy dwie konstrukcje, które zwane s ptlami warunkowymi. Miano
to okrela caákiem dobrze ich zastosowanie: cigáe wykonywanie kodu, dopóki speániony
jest okrelony warunek. Ptla sprawdza go przy ka*dym swoim cyklu - je*eli stwierdzi
jego faászywoü, natychmiast koczy dziaáanie.

Ptla

Prosty przykáad obrazujcy ten mechanizm prezentuje si nastpujco:

// Do – pierwsza ptla warunkowa

Dziaáanie programu

#include

#include

<conio.h>

void

main()

{

int

nLiczba;

{

std::cout

"Wprowadz liczbe wieksza od 10: "

;

std::cin >> nLiczba;

}

while

(nLiczba <=

);

std::cout

"Dziekuje za wspolprace :)"

;

getch();
}

Program ten, podobnie jak jeden z poprzednich, oczekuje od nas o liczby wikszej ni*
dziesiü. Tym razem jednak nie daje si zbyü byle czym - je*eli nie bdziemy skáonni od
razu przychyliü si do jego proby, bdzie j niezáomnie powtarzaá a* do skutku (lub do
u*ycia Ctrl+Alt+Del ;D).

Screen 15. Nieugity program przeciwko krnbrnemu u*ytkownikowi :)

Upór naszej aplikacji bierze si oczywicie z umieszczonej wewntrz niej ptli

(‘czy’) .

Wykonuje ona kod odpowiedzialny za prob do u*ytkownika tak dáugo, jak dáugo ten
jest konsekwentny w ignorowaniu jej :) Przejawia si to rzecz jasna wprowadzaniem
liczb, które nie s wiksze od 10, lecz mniejsze lub równe tej wartoci – odpowiada to
warunkowi ptli nLiczba <=

. Instrukcja niniejsza wykonuje si wic dopóty, dopóki

(ang.

while

) zmienna nLiczba, która przechowuje liczb pobran od u*ytkownika, nie

przekracza granicznej wartoci dziesiciu. Przedstawia to pogldowo poni*szy diagram:

Schemat 4. Dziaáanie przykáadowej ptli

Podstawy programowania

Co si jednak dzieje przy pierwszym „obrocie” ptli, gdy program nie zd*yá jeszcze
pobraü od u*ytkownika *adnej liczby? Jak mo*na porównywaü wartoü zmiennej nLiczba,
która na samym pocztku jest przecie* nieokrelona?… Tajemnica tkwi w fakcie, i* ptla

dokonuje sprawdzenia swojego warunku na kocu ka*dego cyklu – dotyczy to tak*e

pierwszego z nich. Wynika z tego doü oczywisty wniosek:

Ptla

wykona zawsze co najmniej jeden przebieg.

Fakt ten sprawia, *e nadaje si ona znakomicie do uzyskiwania jakich danych od
u*ytkownika przy jednoczesnym sprawdzaniu ich poprawnoci. Naturalnie, w
prawdziwym programie nale*aáoby zapewniü swobod zakoczenia aplikacji bez
wpisywania czegokolwiek. Nasz obrazowy przykáad jest jednak wolny od takich fanaberii
– to wszak tylko kod pomocny w nauce, wic piszc go nie musimy przejmowaü si
takimi báahostkami ;))

Podsumowaniem naszego spotkania z ptl

bdzie jej skáadnia:

{

instrukcje

}

while

(warunek)

Wystarczy przyjrzeü si jej choü przez chwil, by odkryü caáy sens. Samo táumaczenie
wyjania wáaciwie wszystko: „Wykonuj (ang.

) instrukcje, dopóki (ang.

while

)

zachodzi warunek”. I to jest wáanie spiritus movens caáej tej konstrukcji.

Ptla

while

Przyszáa pora na poznanie drugiego typu ptli warunkowych, czyli

while

. Sáówko bdce

jej nazw widziaáe ju* wczeniej, przy okazji ptli

– nie jest to bynajmniej przypadek,

gdy* obydwie konstrukcje s do siebie bardzo podobne.
Dziaáanie ptli

while

przeledzimy zatem na poni*szym ciekawym przykáadzie:

// While - druga ptla warunkowa

#include

#include

<ctime>

#include

<conio.h>

void

main()

{

// wylosowanie liczby

srand

((

int

) time(NULL));

int

nWylosowana = rand() %

100

;

std::cout

"Wylosowano liczbe z przedzialu 1-100."

<< std::endl;

// pierwsza próba odgadnicia liczby

int

nWprowadzona;

std::cout

"Sprobuj ja odgadnac: "

;

std::cin >> nWprowadzona;

// kolejne próby, a* do skutku - przy u*yciu ptli while

while

(nWprowadzona != nWylosowana)

{

(nWprowadzona < nWylosowana)

std::cout

"Liczba jest zbyt mala."

;

else

std::cout

"Za duza liczba."

;

Dziaáanie programu

std::cout

" Sprobuj jeszcze raz: "

;

std::cin >> nWprowadzona;

}

std::cout

"Celny strzal :) Brawo!"

<< std::endl;

getch();
}

Jest to nic innego, jak prosta… gra :) Twoim zadaniem jest w niej odgadnicie
„pomylanej” przez komputer liczby (z przedziaáu od jednoci do stu). Przy ka*dej próbie
otrzymujesz wskazówk, mówic czy wpisana przez ciebie wartoü jest za du*a, czy za
maáa.

Screen 16. Wystarczyáo tylko 8 prób :)

Tak przedstawia si to w dziaáaniu. Jako programici chcemy jednak zajrzeü do kodu
(

ródáowego i przekonaü si, w jaki sposób mo*na byáo taki efekt osignü. Czym prdzej

wic ziümy te pragnienia :D

Pierwsz czynnoci podjt przez nasz program jest wylosowanie liczby, któr
u*ytkownik bdzie odgadywaá. Zasadniczo odpowiadaj za to dwie pocztkowe linijki:

srand ((

int

) time(NULL));

int

nWylosowana = rand() %

100

;

Nie bdziemy obecnie zagábiaü si w szczegóáy ich funkcjonowania, gdy* te zostan
omówione w nastpnym rozdziale. Teraz mo*esz jedynie zapamitaü, i* pierwszy wiersz,
zawierajcy funkcj srand() (i jej osobliwy parametr), jest czym w rodzaju zakrcenia
koáem ruletki. Jego obecnoü sprawia, *e aplikacja za ka*dym razem losuje nam inn
liczb.
Za samo losowanie odpowiada natomiast wyra*enie z funkcj rand(). Obliczona wartoü
tego* jest od razu przypisywana do zmiennej nWylosowana i to o ni toczy bój
niestrudzony gracz :)

Kolejny pakiet kodu pozwala na wykonanie pierwszej próby odgadnicia wáaciwego
wyniku. Nie widaü tu *adnych nowoci – z podobnymi fragmentami spotykalimy si ju*
wielokrotnie i wyjanilimy je dogábnie. Zauwa*my tylko, *e liczba wpisana przez
u*ytkownika jest zapamitywana w zmiennej nWprowadzona.

O wiele bardziej interesujca jest dla nas ptla

while

, wystpujca dalej. To na niej

spoczywa zadanie wywietlania graczowi wskazówek, umo*liwiania mu kolejnych prób i
sprawdzania wpisanych wartoci.
Podobnie jak w przypadku

, wykonywanie tej ptli uzale*nione jest speánieniem

okrelonego kryterium. Tutaj jest nim niezgodnoü midzy liczb wylosowan na
pocztku (zawart w zmiennej nWylosowana), a wprowadzon przez u*ytkownika

Podstawy programowania

(zmienna nWprowadzona). Zapisujemy to w postaci warunku nWprowadzona !=
nWylosowana. Oczywicie ptla wykonuje si do chwili, w której zaáo*enie to przestaje
byü prawdziwe, a u*ytkownik poda wáaciw liczb.
Wewntrz bloku ptli podejmowane za s dwie czynnoci. Najpierw wywietlana jest
podpowied( dla u*ytkownika. Mówi mu ona, czy wpisana przed chwil liczba jest wiksza
czy mniejsza od szukanej. Gracz otrzymuje nastpnie kolejn szans na odgadnicie
po*danej wartoci.
Gdy wreszcie uda mu si ta sztuka, raczony jest w nagrod odpowiednim
komunikatem :)

Tak oto przedstawia si funkcjonowanie powy*szego programu przykáadowego, którego
witaln czci jest ptla

while

. Wczeniej natomiast zd*ylimy si dowiedzieü i

przekonaü, i* konstrukcja ta bardzo przypomina poznan poprzednio ptl

. Na czym

wic polega ró*nica midzy nimi?…
Jest ni mianowicie moment sprawdzania warunku ptli. Jak pamitamy,

czyni to

na kocu ka*dego cyklu. Analogicznie,

while

dokonuje tego zawsze na pocztku swego

przebiegu. Determinuje to doü oczywiste nastpstwo:

Ptla

while

mo*e nie wykonaü si ani razu, je*eli jej warunek bdzie od pocztku

nieprawdziwy.

W naszym przykáadowym programie odpowiada to sytuacji, gdy gracz od razu trafia we
wáaciw liczb. Naturalnie, jest to bardzo maáo prawdopodobne (rzdu 1%), lecz jednak
mo*liwe. Trzeba zatem przewidzieü i odpowiednio zareagowaü na taki przypadek, za
ptla

while

rozwizuje nam ten problem praktycznie sama :)

Na koniec tradycyjnie ju* przyjrzymy si skáadni omawianej konstrukcji:

while

(warunek)

{

instrukcje

}

Ponownie wynika z niej praktycznie wszystko: „Dopóki (

while

) zachodzi warunek,

wykonuj instrukcje”. Czy* nie jest to wyjtkowo intuicyjne? ;)

***

Tak oto poznalimy dwa typy ptli warunkowych – ich dziaáanie, skáadni i sposób
u*ywania. Tym samym dostaáe do rki narzdzia, które pozwol ci tworzyü lepsze i
bardziej skomplikowane programy.
Jakkolwiek oba te mechanizmy maj bardzo du*e mo*liwoci, korzystanie z nich mo*e
byü w niektórych wypadkach nieco niewygodne. Na podobne okazje obmylono trzeci
rodzaj ptli, z którym wáanie teraz si zaznajomimy.

Ptla krokowa

for

Do tej pory spotykalimy si z sytuacjami, w których nale*aáo wykonywaü okrelony kod
a* do speánienia pewnego warunku. Równie czsto jednak znamy wymagan iloü
„obrotów” ptli jeszcze przed jej rozpoczciem – chcemy j podaü w kodzie explicite
lub obliczyü wczeniej jako wartoü zmiennej.
Co wtedy zrobiü? Mo*emy oczywicie u*yü odpowiednio spreparowanej ptli

while

chocia*by w takiej postaci:

int

nLicznik =

;

Dziaáanie programu

// wypisanie dziesiciu liczb caákowitych w osobnych linijkach

while

(nLicznik <=

)

{

std::cout << nLicznik << std::endl;

nLicznik++;
}

Powy*sze rozwizanie jest z pewnoci poprawne, aczkolwiek istnieje jeszcze lepsze :) W
przypadku, gdy znamy z góry liczb przebiegów ptli, bardziej naturalne staje si u*ycie
instrukcji

for

(‘dla’). Zostaáa ona bowiem stworzona specjalnie na takie okazje

sprawdza si w nich o wiele lepiej ni* uniwersalna

while

. Korzystajcy z niej ekwiwalent

powy*szego kodu mo*e wygldaü na przykáad tak:

for

(

int

i =

; i <=

; i++)

{

std::cout << i << std::endl;

}

Je*eli uwa*nie przyjrzysz si obu jego wersjom, z pewnoci zdoáasz domyleü si
ogólnej zasady dziaáania ptli

for

. Zanim dokáadnie j wyjani, posáu* si bardziej

wyrafinowanym przykáadem do jej ilustracji:

// For - ptla krokowa

int

Suma(

int

nLiczba)

{

int

nSuma =

;

for

(

int

i =

; i <= nLiczba; i++)

nSuma += i;

return

nSuma;

}

void

main()

{

int

nLiczba;

std::cout

"Program oblicza sume od 1 do podanej liczby."

<< std::endl;

std::cout

"Podaj ja: "

;

std::cin >> nLiczba;

std::cout

"Suma liczb od 1 do "

<< nLiczba <<

" wynosi "

<< Suma(nLiczba) <<

"."

;

getch();
}

Mamy zatem kolejny superu*yteczny programik do przeanalizowania ;) Bezzwáocznie
wic przystpmy do wykonania tego po*ytecznego zadania.
Rzut oka na kod tudzie* kompilacja i uruchomienie aplikacji prowadzi do sáusznego
wniosku, i* przeznaczeniem programu jest obliczanie sumy kilku pocztkowych liczb
naturalnych. Zakres dodawania ustala przy tym sam u*ytkownik programu.

Czynnoci sumowania zajmuje si tu odrbna funkcja Suma(), na której skupimy
obecnie caá nasz uwag.

for

nie jest tylko wymysáem twórców C++. Podobne konstrukcje spotkaü mo*na wáaciwie w ka*dym jzyku

programowania, istniej te* nawet bardziej wyspecjalizowane ich odmiany. Trudno wic uznaü t poczciw ptl
za zbdne udziwnienie :)

Podstawy programowania

Pierwsza linijka tej funkcji to znana ju* nam deklaracja zmiennej, poáczona z jej
inicjalizacj wartoci

. Owa zmienna, nSuma, bdzie przechowywaü obliczony wynik

dodawania, który zostanie zwrócony jako rezultat caáej funkcji.
Najbardziej interesujcym fragmentem jest wystpujca dalej ptla

for

(

int

i =

; i <= nLiczba; i++)

nSuma += i;

Wykonuje ona zasadnicze obliczenia: dodaje do zmiennej nSuma kolejne liczby naturalne,
zatrzymujc si na podanym w funkcji parametrze. Caáoü odbywa si w nastpujcy,
doü prosty sposób:

Instrukcja

int

i =

jest wykonywana raz na samym pocztku. Jak widaü, jest to

deklaracja i inicjalizacja zmiennej i. Nazywamy j licznikiem ptli. W kolejnych
cyklach bdzie ona przyjmowaü wartoci

, itd.

Kod nSuma += i; stanowi blok ptli

i jest uruchamiany przy ka*dym jej

przebiegu. Skoro za licznik i jest po kolei ustawiany na nastpujce po sobie
liczby naturalne, ptla

for

staje si odpowiednikiem sekwencji instrukcji nSuma +=

; nSuma +=

; itd.

Warunek i <= nLiczba okrela górn granic sumowania. Jego obecnoü
sprawia, *e ptla jest wykonywana tylko wtedy, gdy licznik i jest mniejszy lub
równy zmiennej nLiczba. Zgadza si to oczywicie z naszym zamysáem.

Wreszcie, na koniec ka*dego cyklu instrukcja i++ powoduje zwikszenie wartoci
licznika o jeden.

Po dáu*szym zastanowieniu nad powy*szym opisem mo*na niewtpliwie dojü do
wniosku, *e nie jest on wcale taki skomplikowany, prawda? :) Zrozumienie go nie
powinno nastrczaü ci zbyt wielu trudnoci. Gdyby jednak tak byáo, przypomnij sobie
podan w tytule nazw ptli

for

– krokowa.

To caákiem trafne okrelenie dla tej konstrukcji. Jej zadaniem jest bowiem przebycie
pewnej „drogi” (u nas s to liczby od

do wartoci zmiennej nLiczba) poprzez seri

maáych kroków i wykonanie po drodze jakich dziaáa. Klarownie przedstawia to ten*e
rysunek:

Schemat 5. "Droga" przykáadowej ptli for

Mam nadziej, *e teraz nie masz ju* *adnych káopotów ze zrozumieniem zasady dziaáania
naszego programu.

Przyszedá czas na zaprezentowanie skáadni omawianej przez nas ptli:

for

([pocztek]; [warunek]; [cykl])

{

instrukcje

}

Jak zapewne pamitasz, jedn linijk w bloku kodu mo*emy zapisaü bez nawiasów klamrowych {} –

dowiedzielimy si tego przy okazji instrukcji

Dziaáanie programu

Na jej podstawie mo*emy dogábnie poznaü funkcjonowanie tego wa*nego tworu
programistycznego. Dowiemy si te*, dlaczego konstrukcja

for

jest uwa*ana za jedn z

mocnych stron jzyka C++.

Zaczniemy od pocztku, czyli komendy oznaczonej jako… pocztek :) Wykonuje si ona
jeden raz, jeszcze przed wejciem we wáaciwy krg ptli. Zazwyczaj umieszczamy tu
instrukcj, która ustawia licznik na wartoü pocztkow (mo*e to byü poáczone z jego
deklaracj).
warunek jest sprawdzany przed ka*dym cyklem instrukcji. Je*eli nie jest on speániony,
ptla natychmiast koczy si. Zwykle wic wpisujemy w jego miejsce kod porównujcy
licznik z wartoci kocow.
W ka*dym przebiegu, po wykonaniu instrukcji, ptla uruchamia jeszcze fragment
zaznaczony jako cykl. Naturaln jego treci bdzie zatem zwikszenie lub zmniejszenie
licznika (w zale*noci od tego, czy liczymy w gór czy w dóá).

Inkrementacja czy dekrementacja nie jest bynajmniej jedyn czynnoci, jak mo*emy

tutaj wykonaü na liczniku. Posáu*enie si choüby mno*eniem, dzieleniem czy nawet

bardziej zaawansowanymi funkcjami jest jak najbardziej dopuszczalne.

Wpisujc na przykáad i *=

otrzymamy kolejne potgi dwójki (2, 4, 8, 16 itd.), i +=

– wielokrotnoci dziesiciu, itp. Jest to znaczna przewaga nad wieloma innymi jzykami

programowania, w których liczniki analogicznych ptli mog si zmieniaü jedynie w

postpie arytmetycznym (o staá wartoü - niekiedy nawet dopuszczalna jest tu wyácznie

jedynka!).

Elastycznoü ptli

for

polega midzy innymi na fakcie, i* *aden z trzech podanych w

nawiasie „parametrów” nie jest obowizkowy! Wprawdzie na pierwszy rzut oka obecnoü
ka*dego wydaje si tu absolutnie niezbdna, jednak*e pominicie którego (czasem
nawet wszystkich) mo*e mieü swoje logiczne uzasadnienie.
Brak pocztku lub cyklu powoduje doü przewidywalny skutek – w chwili, gdy miaáyby
zostaü wykonane, program nie podejmie po prostu *adnych akcji. O ile nieobecnoü
instrukcji ustawiajcej licznik na wartoü pocztkow jest okolicznoci rzadko
spotykan, o tyle pominicie frazy cykl jest konieczne, je*eli nie chcemy zmieniaü
licznika przy ka*dym przebiegu ptli. Mo*emy to osignü, umieszczajc odpowiedni kod
np. wewntrz zagnie*d*onego bloku

Gdy natomiast opucimy warunek, iteracja nie bdzie miaáa czego weryfikowaü przy
ka*dym swym „obrocie”, wic zaptli si w nieskoczonoü. Przerwanie tego bádnego
koáa bdzie mo*liwe tylko poprzez instrukcj

break

, któr ju* za chwil poznamy bli*ej.

***

W ten oto sposób zawarlimy bli*sz znajomoü z ptla krokow

for

. Nie jest to mo*e

atwa konstrukcja, ale do wielu zastosowa zdaje si byü bardzo wygodna. Z tego

wzgldu bdziemy jej czsto u*ywali – tak te* robi wszyscy programici C++.

Instrukcje

break

continue

Z ptlami zwizane s jeszcze dwie instrukcje pomocnicze. Nierzadko uáatwiaj one
rozwizywanie pewnych problemów, a czasem wrcz s do tego niezbdne. Mowa tu o
tytuáowych

break

continue

Z instrukcj

break

(‘przerwij’) spotkalimy si ju* przy okazji konstrukcji

switch

Korzystalimy z niej, aby zagwarantowaü wykonanie kodu odpowiadajcego tylko
jednemu wariantowi

case

break

powodowaáa bowiem przerwanie bloku

switch

przejcie do nastpnej linijki po nim.

Podstawy programowania

Rola tej instrukcji w kontekcie ptli nie zmienia si ani na jot: jej wystpienie wewntrz
bloku

while

lub

for

powoduje dokáadnie ten sam efekt. Bez wzgldu na prawdziwoü

lub nieprawdziwoü warunku ptli jest ona báyskawicznie przerywana, a punkt wykonania
programu przesuwa si do kolejnego wiersza za ni.
Przy pomocy

break

mo*emy teraz nieco poprawiü nasz program demonstrujcy ptl

// Break – przerwanie ptli

void

main()

{

int

nLiczba;

{

std::cout

"Wprowadz liczbe wieksza od 10"

<< std::endl;

std::cout

"lub zero, by zakonczyc program: "

;

std::cin >> nLiczba;

(nLiczba ==

)

break

;

}

while

(nLiczba <=

);

std::cout

"Nacisnij dowolny klawisz."

;

getch();
}

Mankament niemo*noci zakoczenia aplikacji bez speánienia jej proby zostaá tutaj
skutecznie usunity. Mianowicie, gdy wprowadzimy liczb zero, instrukcja

skieruje

program ku komendzie

break

, która natychmiast zakoczy ptl i uwolni u*ytkownika od

irytujcego *dania :)

Podobny skutek (przerwanie ptli po wpisaniu przez u*ytkownika zera) osignlibymy
zmieniajc warunek ptli tak, by stawaá si prawdziwy równie* wtedy, gdy zmienna
nLiczba miaáaby wartoü

. W nastpnym rozdziale dowiemy si, jak poczyniü podobn

modyfikacj.

Instrukcja

continue

jest u*ywana nieco rzadziej. Gdy program natrafi na ni wewntrz

bloku ptli, wtedy automatycznie koczy bie*cy cykl i rozpoczyna nowy przebieg iteracji.
Z instrukcji tej korzystamy najczciej wtedy, kiedy czü (zwykle wikszoü) kodu ptli
ma byü wykonywana tylko pod okrelonym, dodatkowym warunkiem.

***

Zakoczylimy wáanie poznawanie bardzo wa*nych elementów jzyka C++, czyli ptli.
Dowiedzielimy si o zasadach ich dziaáania, skáadni oraz przykáadowych zastosowaniach.
Tych ostatnich bdzie nam systematycznie przybywaáo wraz z postpami w sztuce
programowania, gdy* ptle to bardzo intensywnie wykorzystywany mechanizm – nie
tylko zreszt w C++.

Podsumowanie

Ten dáugi i wa*ny rozdziaá prezentowaá mo*liwoci C++ w zakresie sterowania
przebiegiem aplikacji oraz sposobem jej dziaáania.

Pierwszym zagadnieniem byáo bystrzejsze spojrzenie na funkcje, co obejmowaáo poznanie
ich parametrów oraz zwracanych wartoci. Dalej zerknlimy na instrukcje warunkowe,
które wreszcie dopuszczaáy nam przewidywaü ró*ne ewentualnoci pracy programu. Na

Dziaáanie programu

koniec, ptle daáy nam okazj stworzyü nieco mniej banalne aplikacje ni* zwykle – w tym
i jedn gr! :D
T drog nabylimy przeto umiejtnoü tworzenia programów wykonujcych niemal
dowolne zadania. Pewnie teraz nie jeste o tym szczególnie przekonany, jednak
pamitaj, *e poznanie instrumentów to tylko pierwszy krok do osignicia wirtuozerii.
Niezastpiona jest praktyka w prawdziwym programowaniu, a sposobnoci do niej
bdziesz miaá z pewnoci bez liku - tak*e w niniejszym kursie :)

Pytania i zadania

Tak obszerny i kluczowy rozdziaá nie mo*e si obejü bez sáusznego pakietu zada
domowych ;) Oto i one:

Pytania

Jaka jest rola parametrów funkcji?

Czy iloü parametrów w deklaracji i wywoáaniu funkcji mo*e byü ró*na?
Wskazówka: Poczytaj w

MSDN

o domylnych wartociach parametrów funkcji.

Co si stanie, je*eli nie umiecimy instrukcji

break

po wariancie

case

w bloku

switch

W jakich sytuacjach, oprócz niepodania warunku, ptla

for

bdzie si wykonywaáa

w nieskoczonoü? A kiedy nie wykona si ani razu?
Czy podobnie jest z ptl

while

wiczenia

Stwórz program, który poprosi u*ytkownika o liczb caákowit i przyporzdkuje j
do jednego z czterech przedziaáów: liczb ujemnych, jednocyfrowych,
dwucyfrowych lub pozostaáych.
Która z instrukcji –

czy

switch

– bdzie tu odpowiednia?

Napisz aplikacj wywietlajc list liczb od 1 do 100 z podanymi obok
wartociami ich drugich potg (kwadratów).
Jak ptl –

while

czy

for

– nale*aáoby tu zastosowaü?

Zmodyfikuj program przykáadowy prezentujcy ptl

while

. Niech zlicza on próby

zgadnicia liczby podjte przez gracza i wywietla na kocu ich iloü.

OPERACJE NA ZMIENNYCH

S plusy dodatnie i plusy ujemne.

Lech Waása

W tym rozdziale przyjrzymy si dokáadnie zmiennym i wyra*eniom w jzyku C++. Jak
wiemy, sáu* one do przechowywania wszelkich danych i dokonywania na ró*nego
rodzaju manipulacji. Dziaáania takie s podstaw ka*dej aplikacji, a w záo*onych
algorytmach gier komputerowych maj niebagatelne znaczenie.

Poznamy wic szczegóáowo wikszoü aspektów programowania zwizanych ze
zmiennymi oraz zobaczymy czsto u*ywane operacje na danych liczbowych i tekstowych.

Wnikliwy rzut oka na zmienne

Zmienna to co w rodzaju pojemnika na informacje, mogcego zawieraü okrelone dane.
Wczeniej dowiedzielimy si, i* dla ka*dej zmiennej musimy okreliü typ danych, które
bdziemy w niej przechowywaü, oraz nazw, przez któr bdziemy j identyfikowaü.
Okrelenie takie nazywamy deklaracj zmiennej i stosowalimy je niemal w ka*dym
programie przykáadowym – powinno wic byü ci doskonale znane :)

Nasze aktualne wiadomoci o zmiennych s mimo tego doü skpe i dlatego musimy je
niezwáocznie poszerzyü. Uczynimy to wszak*e w niniejszym podrozdziale.

Zasig zmiennych

Gdy deklarujemy zmienn, podajemy jej typ i nazw – to oczywiste. Mniej dostrzegalny
jest fakt, i* jednoczenie okrelamy te* obszar obowizywania takiej deklaracji. Innymi
sáowy, definiujemy zasig zmiennej.

Zasig (zakres, ang. scope) zmiennej to czü kodu, w ramach której dana zmienna
jest dostpna.

Wyró*niamy kilka rodzajów zasigów. Do wszystkich jednak stosuje si ogólna, naturalna
reguáa: niepoprawne jest jakiekolwiek u*ycie zmiennej przed jej deklaracj. Tak wic
poni*szy kod:

std::cin >> nZmienna;

int

nZmienna;

niechybnie spowoduje bád kompilacji. Sdz, *e jest to doü proste i logiczne – nie
mo*emy przecie* wymagaü od kompilatora znajomoci czego, o czym sami go wczeniej
nie poinformowalimy.

W niektórych jzykach programowania (na przykáad Visual Basicu czy PHP) mo*emy

jednak u*ywaü niezadeklarowanych zmiennych. Wikszoü programistów uwa*a to za

Podstawy programowania

niedogodnoü i przyczyn powstawania trudnych do wykrycia bádów (spowodowanych

choüby literówkami). Ja osobicie caákowicie podzielam ten pogld :D

Na razie poznamy dwa rodzaje zasigów – lokalny i moduáowy.

Zasig lokalny

Zakres lokalny obejmuje pojedynczy blok kodu. Jak pamitasz, takim blokiem
nazywamy fragment listingu zawarty midzy nawiasami klamrowymi { }. Dobrym
przykáadem mog byü tu bloki warunkowe instrukcji

, bloki ptli, a tak*e caáe funkcje.

Otó* ka*da zmienna deklarowana wewntrz takiego bloku ma wáanie zasig lokalny.

Zakres lokalny obejmuje kod od miejsca deklaracji zmiennej a* do koca bloku, wraz z
ewentualnymi blokami zagnie*d*onymi.

Te doü mgliste stwierdzenia bd pewnie bardziej wymowne, je*eli zostan poparte
odpowiednimi przykáadami. Zerknijmy wic na poni*szy kod:

void

main()

{

int

nX;

std::cin >> nX;

(nX >

)

{

std::cout << nX;

getch();

}
}

Jego dziaáanie jest, mam nadziej, zupeánie oczywiste (zreszt nieszczególnie nas teraz
interesuje :)). Przyjrzyjmy si raczej zmiennej nX. Jako *e zadeklarowalimy j wewntrz
bloku kodu – w tym przypadku funkcji main() – posiada ona zasig lokalny. Mo*emy
zatem korzystaü z niej do woli w caáym tym bloku, a wic tak*e w zagnie*d*onej
instrukcji

Dla kontrastu spójrzmy teraz na inny, choü podobny kod:

void

main()

{

int

nX =

;

(nX > 0)

{

int

nY =

;

}

std::cout << nY;

getch();
}

Powinien on wypisaü liczb

, prawda? Có*… niezupeánie :) Sama próba uruchomienia

programu skazana jest na niepowodzenie: kompilator „przyczepi” si do przedostatniego
wiersza, zawierajcego nazw zmiennej nY. Wyda mu si bowiem kompletnie nieznana!
Ale dlaczego?! Przecie* zadeklarowalimy j ledwie dwie linijki wy*ej! Czy* nie mo*emy
wic u*yü jej tutaj?…
Je*eli uwa*nie przeczytaáe poprzednie akapity, to zapewne znasz ju* przyczyn
niezadowolenia kompilatora. Mianowicie, zmienna nY ma zasig lokalny, obejmujcy

Operacje na zmiennych

wyácznie blok

. Reszta funkcji main() nie nale*y ju* do tego bloku, a zatem znajduje

si poza zakresem nY. Nic dziwnego, *e zmienna jest tam traktowana jako obca – poza
swoim zasigiem ona faktycznie nie istnieje, gdy* jest usuwana z pamici w momencie
jego opuszczenia.

Zmiennych o zasigu lokalnym relatywnie najczciej u*ywamy jednak bezporednio we
wntrzu funkcji. Przyjáo si nawet nazywaü je zmiennymi lokalnymi

lub

automatycznymi. Ich rol jest zazwyczaj przechowywanie tymczasowych danych,
wykorzystywanych przez podprogramy, lub czciowych wyników oblicze.
Tak jak poszczególne funkcje w programie, tak i ich zmienne lokalne s od siebie
caákowicie niezale*ne. Istniej w pamici komputera jedynie podczas wykonywania
funkcji i „znikaj” po jej zakoczeniu. Niemo*liwe jest wic odwoáanie do zmiennej
lokalnej spoza jej macierzystej funkcji. Poni*szy przykáad ilustruje ten fakt:

// LocalVariables - zmienne lokalne

void

Funkcja1()

{

int

nX =

;

std::cout

"Zmienna lokalna nX funkcji Funkcja1(): "

<< nX

<< std::endl;

}

void

Funkcja2()

{

int

nX =

;

std::cout

"Zmienna lokalna nX funkcji Funkcja2(): "

<< nX

<< std::endl;

}

void

main()

{

int

nX =

;

Funkcja1();
Funkcja2();
std::cout

"Zmienna lokalna nX funkcji main(): "

<< nX

<< std::endl;

getch();
}

Mimo *e we wszystkich trzech funkcjach (Funkcja1(), Funkcja2() i main()) nazwa
zmiennej jest identyczna (nX), w ka*dym z tych przypadków mamy do czynienia z
zupeánie inn zmienn.

Screen 17. Ta sama nazwa, lecz inne znaczenie. Ka*da z trzech lokalnych zmiennych

jest

caákowicie odrbna i niezale*na od pozostaáych

Nie tylko zreszt w C++. Wprawdzie sporo jzyków jest ubo*szych o mo*liwoü deklarowania zmiennych

wewntrz bloków warunkowych, ptli czy podobnych, ale niemal wszystkie pozwalaj na stosowanie zmiennych
lokalnych. Nazwa ta jest wic obecnie u*ywana w kontekcie dowolnego jzyka programowania.

Podstawy programowania

Mog one wspóáistnieü obok siebie pomimo takich samych nazw, gdy* ich zasigi nie
pokrywaj si. Kompilator sáusznie wic traktuje je jako twory absolutnie niepowizane
ze sob. I tak te* jest w istocie – s one „wewntrznymi sprawami” ka*dej z funkcji, do
których nikt nie ma prawa si mieszaü :)

Takie wyodrbnianie niektórych elementów aplikacji nazywamy hermetyzacj
(ang. encapsulation). Najprostszym jej wariantem s wáanie podprogramy ze zmiennymi
lokalnymi, niedostpnymi dla innych. Dalszym krokiem jest tworzenie klas i obiektów,
które dokáadnie poznamy w dalszej czci kursu.
Zalet takiego dzielenia kodu na mniejsze, zamknite czci jest wiksza áatwoü
modyfikacji oraz niezawodnoü. W du*ych projektach, realizowanych przez wiele osób,
podziaá na odrbne fragmenty jest w zasadzie nieodzowny, aby wspóápraca midzy
programistami przebiegaáa bez problemów.

Ze zmiennymi o zasigu lokalnym spotykalimy si dotychczas nieustannie w naszych
programach przykáadowych. Prawdopodobnie zatem nie bdziesz miaá wikszych
káopotów ze zrozumieniem sensu tego pojcia. Jego precyzyjne wyjanienie byáo jednak
nieodzowne, abym z czystym sumieniem mógá kontynuowaü :D

Zasig moduáowy

Szerszym zasigiem zmiennych jest zakres moduáowy. Posiadajce go zmienne s
widoczne w caáym module kodu. Mo*emy wic korzystaü z nich we wszystkich
funkcjach, które umiecimy w tym*e module.
Je*eli za jest to jedyny plik z kodem programu, to oczywicie zmienne te bd dostpne
dla caáej aplikacji. Nazywamy si je wtedy globalnymi.
Aby zobaczyü, jak „dziaáaj” zmienne moduáowe, przyjrzyj si nastpujcemu
przykáadowi:

// ModularVariables - zmienne moduáowe

int

nX =

;

void

Funkcja()

{
std::cout

"Zmienna nX wewnatrz innej funkcji: "

<< nX

<< std::endl;

}

void

main()

{
std::cout

"Zmienna nX wewnatrz funkcji main(): "

<< nX

<< std::endl;

Funkcja();

getch();
}

Zadeklarowana na pocztku zmienna nX ma wáanie zasig moduáowy. Odwoáujc si do
niej, obie funkcje (main() i Funkcja()) wywietlaj wartoü jednej i tej samej zmiennej.

Screen 18. Zakres moduáowy zmiennej

Operacje na zmiennych

Jak widaü, deklaracj zmiennej moduáowej umieszczamy bezporednio w pliku
(

ródáowym, poza kodem wszystkich funkcji. Wyáczenie jej na zewntrz podprogramów

daje zatem áatwy do przewidzenia skutek: zmienna staje si dostpna w caáym module i
we wszystkich zawartych w nim funkcjach.

Oczywistym zastosowaniem dla takich zmiennych jest przechowywanie danych, z których
korzysta wiele procedur. Najczciej musz byü one zachowane przez wikszoü czasu
dziaáania programu i osigalne z ka*dego miejsca aplikacji. Typowym przykáadem mo*e
byü chocia*by numer aktualnego etapu w grze zrcznociowej czy nazwa pliku otwartego
w edytorze tekstu. Dziki zastosowaniu zmiennych o zasigu moduáowym dostp do
takich kluczowych informacji nie stanowi ju* problemu.

Zakres moduáowy dotyczy tylko jednego pliku z kodem (ródáowym. Jeli nasza aplikacja

jest na tyle du*a, bymy musieli podzieliü j na kilka moduáów, mo*e on wszak*e nie

wystarczaü. Rozwizaniem jest wtedy wyodrbnienie globalnych deklaracji we wáasnym

pliku nagáówkowym i u*ycie dyrektywy

#include

. Bdziemy o tym szerzej mówiü w

niedalekiej przyszáoci :)

Przesáanianie nazw

Gdy u*ywamy zarówno zmiennych o zasigu lokalnym, jak i moduáowym (czyli w
normalnym programowaniu w zasadzie nieustannie), mo*liwa jest sytuacja, w której z
danego miejsca w kodzie dostpne s dwie zmienne o tej samej nazwie, lecz ró*nym
zakresie. Wygldaü to mo*e chocia*by tak:

int

nX =

;

void

main()

{

int

nX =

;

std::cout << nX;

}

Pytanie brzmi: do której zmiennej nX – lokalnej czy moduáowej - odnosi si instrukcja
std::cout? Inaczej mówic, czy program wypisze liczb

czy

? A mo*e w ogóle si

nie skompiluje?…
Zjawisko to nazywamy przesáanianiem nazw (ang. name shadowing), a pojawiáo si
ono wraz ze wprowadzeniem idei zasigu zmiennych. Tego rodzaju kolizja oznacze nie
powoduje w C++

bádu kompilacji, gdy* jest ona rozwizywana w nieco inny sposób:

Konflikt nazw zmiennych o ró*nym zasigu jest rozstrzygany zawsze na korzyü zmiennej
o w*szym zakresie.

Zazwyczaj oznacza to zmienn lokaln i tak te* jest w naszym przypadku. Nie oznacza to
jednak, *e jej moduáowy imiennik jest w funkcji main() niedostpny. Sposób odwoáania
si do niego ilustruje poni*szy przykáadowy program:

// Shadowing - przesáanianie nazw

int

nX =

;

void

main()

{

A tak*e w wikszoci wspóáczesnych jzyków programowania

Podstawy programowania

int

nX =

;

std::cout

"Lokalna zmienna nX: "

<< nX << std::endl;

std::cout

"Modulowa zmienna nX: "

<< ::nX << std::endl;

getch();
}

Pierwsze odniesienie do nX w funkcji main() odnosi si wprawdzie do zmiennej lokalnej,
lecz jednoczenie mo*emy odwoáaü si tak*e do tej moduáowej. Robimy to bowiem w
nastpnej linijce:

std::cout <<

"Modulowa zmienna nX: "

<< ::nX << std::endl;

Poprzedzamy tu nazw zmiennej dwoma znakami dwukropka ::. Jest to tzw. operator
zasigu. Wstawienie go mówi kompilatorowi, aby u*yá zmiennej globalnej zamiast
lokalnej - czyli zrobiá dokáadnie to, o co nam chodzi :)

Operator ten ma te* kilka innych zastosowa, o których powiemy niedáugo (dokáadniej
przy okazji klas).

Chocia* C++ udostpnia nam tego rodzaju mechanizm

, do dobrej praktyki

programistycznej nale*y niestosowanie go. Identyczne nazwy wprowadzaj bowiem
zamt i pogarszaj czytelnoü kodu.
Dlatego te* do nazw zmiennych moduáowych dodaje si zazwyczaj przedrostek

g_ (od

global), co pozwala áatwo odró*niü je od lokalnych. Po zastosowaniu tej reguáy nasz
przykáad wygldaáby mniej wicej tak:

int

g_nX =

;

void

main()

{

int

nX =

;

std::cout

"Lokalna zmienna: "

<< nX << std::endl;

std::cout

"Modulowa zmienna: "

<< g_nX << std::endl;

getch();
}

Nie ma ju* potrzeby stosowania maáo czytelnego operatora :: i caáoü wyglda
przejrzycie i profesjonalnie ;)

***

Zapoznalimy si zatem z nieáatw ide zasigu zmiennych. Jest to jednoczenie bardzo
wa*ne pojcie, które trzeba dobrze znaü, by nie popeániaü trudnych do wykrycia bádów.
Mam nadziej, *e jego opis oraz przykáady byáy na tyle przejrzyste, *e nie miaáe
powa*niejszych káopotów ze zrozumieniem tego aspektu programowania.

Modyfikatory zmiennych

W aktualnym podrozdziale szczególnie upodobalimy sobie deklaracje zmiennych. Oto
bowiem omówimy kolejne zagadnienie z nimi zwizane – tak zwane modyfikatory

Wikszoü jzyków go nie posiada!

Jest to element notacji wgierskiej, aczkolwiek szeroko stosowany przez wielu programistów. Wicej

informacji w Dodatku A.

Operacje na zmiennych

(ang. modifiers). S to mianowicie dodatkowe okrelenia umieszczane w deklaracji
zmiennej, nadajce jej pewne specjalne wáasnoci.

Zajmiemy si dwoma sporód trzech dostpnych w C++ modyfikatorów. Pierwszy –

static

– chroni zmienn przed utrat wartoci po opuszczeniu jej zakresu przez

program. Drugi za – znany nam

const

– oznacza staá, opisan ju* jaki czas temu.

Zmienne statyczne

Kiedy aplikacja opuszcza zakres zmiennej lokalnej, wtedy ta jest usuwana z pamici. To
caákowicie naturalne – po co zachowywaü zmienn, do której i tak nie byáoby dostpu?
Logiczniejsze jest zaoszczdzenie pamici operacyjnej i pozbycie si nieu*ywanej
wartoci, co te* program skrztnie czyni. Z tego powodu przy ponownym wejciu w
porzucony wczeniej zasig wszystkie podlegajce mu zmienne bd ustawione na swe
pocztkowe wartoci.
Niekiedy jest to zachowanie niepo*dane – czasem wolelibymy, aby zmienne lokalne nie
traciáy swoich wartoci w takich sytuacjach. Najlepszym rozwizaniem jest wtedy u*ycie
modyfikatora

static

. Rzuümy okiem na poni*szy przykáad:

// Static - zmienne statyczne

void

Funkcja()

{

static

int

nLicznik =

;

++nLicznik;
std::cout

"Funkcje wywolano po raz "

<< nLicznik << std::endl;

}

void

main()

{
std::string

strWybor;

{

Funkcja();

std::cout

"Wpisz 'q', aby zakonczyc: "

;

std::cin >> strWybor;

}

while

(strWybor !=

"q"

);

}

Ów program jest raczej trywialny i jego jedynym zadaniem jest kilkukrotne uruchomienie
podprogramu Funkcja(), dopóki *yczliwy u*ytkownik na to pozwala :) We wntrzu tej*e
funkcji mamy zadeklarowan zmienn statyczn, która sáu*y tam jako licznik
uruchomie.

Screen 19. Zliczanie wywoáa funkcji przy pomocy zmiennej statycznej

Podstawy programowania

Jego wartoü jest zachowywana pomidzy kolejnymi wywoáaniami funkcji, gdy* istnieje
w pamici przez caáy czas dziaáania aplikacji

. Mo*emy wic ka*dorazowo inkrementowaü

t wartoü i pokazywaü jako iloü uruchomie funkcji. Tak wáanie dziaáaj zmienne
statyczne :)

Deklaracja takiej zmiennej jest, jak widzielimy, nad wyraz prosta:

static

int

nLicznik =

;

Wystarczy poprzedziü oznaczenie jej typu sáówkiem

static

i voila :) Nadal mo*emy

tak*e stosowaü inicjalizacj do ustawienia pocztkowej wartoci zmiennej.

Jest to wrcz konieczne – gdybymy bowiem zastosowali zwykáe przypisanie, odbywaáoby
si ono przy ka*dym wejciu w zasig zmiennej. Wypaczaáoby to caákowicie sens
stosowania modyfikatora

static

Staáe

Staáe omówilimy ju* wczeniej, wic nie s dla ciebie nowoci. Obecnie podkrelimy ich
zwizek ze zmiennymi.
Jak (mam nadziej) pamitasz, aby zadeklarowaü staá nale*y u*yü sáowa

const

, na

przykáad:

const

float

GRAWITACJA =

9.80655

;

const

, podobnie jak

static

, jest modyfikatorem zmiennej. Staáe posiadaj zatem

wszystkie cechy zmiennych, takie jak typ czy zasig. Jedyn ró*nic jest oczywicie
niemo*noü zmiany wartoci staáej.

***

Tak oto uzupeánilimy swe wiadomoci na temat zmiennych o ich zasig oraz
modyfikatory. Uzbrojeni w t now wiedz mo*emy teraz miaáo pod*aü dalej :D

Typy zmiennych

W C++ typ zmiennej jest spraw niezwykle wa*n. Gdy okrelamy go przy deklaracji,
zostaje on trwale „przywizany” do zmiennej na caáy czas dziaáania programu. Nie mo*e
wic zajü sytuacja, w której zmienna zadeklarowana na przykáad jako liczba caákowita
zawiera informacj tekstow czy liczb rzeczywist.

Niektóre jzyki programowania pozwalaj jednak na to. Delphi i Visual Basic s

wyposa*one w specjalny typ Variant, który potrafi przechowywaü zarówno dane

liczbowe, jak i tekstowe. PHP natomiast w ogóle nie wymaga podawania typu zmiennych.

Chocia* wymóg ten wyglda na powa*ny mankament C++, w rzeczywistoci wcale nim
nie jest. Bardzo trudno wskazaü czynnoü, która wymagaáaby zmiennej „uniwersalnego
typu”, mogcej przechowywaü ka*dy rodzaj danych. Je*eli nawet zaszáaby takowa
koniecznoü, mo*liwe jest zastosowanie przynajmniej kilku niemal równowa*nych

Dokáadniej mówic: od momentu deklaracji do zakoczenia programu

Operacje na zmiennych

rozwiza

Generalnie jednak jestemy „skazani” na korzystanie z typów zmiennych, co mimo
wszystko nie powinno nas smuciü :) Na osáod proponuj bli*sze przyjrzenie si im.
Bdziemy mieli okazj zobaczyü, *e ich mo*liwoci, elastycznoü i zastosowania s
niezwykle szerokie.

Modyfikatory typów liczbowych

Dotychczas w swoich programach mielimy okazj u*ywaü gáównie typu

int

reprezentujcego liczb caákowit. Czasem korzystalimy tak*e z

float

, bdcego typem

liczb rzeczywistych.
Dwa sposoby przechowywania wartoci liczbowych to, zdawaáoby si, bardzo niewiele.
Zwa*ywszy, i* spora czü jzyków programowania udostpnia nawet po kilkanacie
takich typów, asortyment C++ mo*e wygldaü tutaj wyjtkowo mizernie.

Domylasz si zapewne, *e jest to tylko záudne wra*enie :) Do ka*dego typu liczbowego
w C++ mo*emy bowiem doáczyü jeden lub kilka modyfikatorów, które istotnie
zmieniaj jego wáasnoci. Spróbujmy dokáadnie przyjrzeü si temu mechanizmowi.

Typy ze znakiem i bez znaku

Typ liczbowy

int

mo*e nam przechowywaü zarówno liczby dodatnie, jak i ujemne. Dosyü

czsto jednak nie potrzebujemy wartoci mniejszych od zera. Przykáadowo, iloü punktów
w wikszoci gier nigdy nie bdzie ujemna; to samo dotyczy liczników upáywajcego
czasu, zmiennych przechowujcych wielkoü plików, dáugoci odcinków, rozmiary
obrazków - i tak dalej.

Mo*emy rzecz jasna zwyczajnie zignorowaü obecnoü liczb ujemnych i korzystaü jedynie
z wartoci dodatnich. Wad tego rozwizania jest marnotrawstwo: tracimy wtedy poáow
miejsca zajmowanego w pamici przez zmienn. Je*eli na przykáad

int

mógáby zawieraü

liczby od -10 000 do +10 000 (czyli 20 000 mo*liwych wartoci

), to ograniczylibymy

ten przedziaá do 0…+10 000 (a wic skromnych 10 000 mo*liwych wartoci).
Nie jest to mo*e karygodna niegospodarnoü w przypadku jednej zmiennej, ale gdy
mówimy o kilku czy kilkunastu tysicach podobnych zmiennych

, iloü zmarnowanej

pamici staje si znaczna.

Nale*aáoby zatem powiedzieü kompilatorowi, *e nie potrzebujemy liczb ujemnych i w
zamian za nie chcemy zwikszenia przedziaáu liczb dodatnich. Czynimy to poprzez
dodanie do typu zmiennej

int

modyfikatora

unsigned

(‘nieoznakowany’, czyli bez znaku;

zawsze dodatni). Deklaracja bdzie wtedy wygldaü na przykáad tak:

unsigned

int

uZmienna;

// przechowuje liczby naturalne

Analogicznie, moglibymy dodaü przeciwstawny modyfikator

signed

(‘oznakowany’, czyli

ze znakiem; dodatni lub ujemny) do typów zmiennych, które maj zawieraü zarówno
liczby dodatnie, jak i ujemne:

signed

int

nZmienna;

// przechowuje liczby caákowite

Mo*na wykorzystaü chocia*by szablony, unie czy wska(niki. O ka*dym z tych elementów C++ powiemy sobie

w dalszej czci kursu, wic cierpliwoci ;)

To oczywicie jedynie przykáad. Na *adnym wspóáczesnym systemie typ

int

nie ma tak maáego zakresu.

Co nie jest wcale niemo*liwe, a przy stosowaniu tablic (opisanych w nastpnym rozdziale) staje caákiem

czste.

Podstawy programowania

Zazwyczaj tego nie robimy, gdy* modyfikator ten jest niejako domylnie tam
umieszczony i nie ma potrzeby jego wyra(nego stosowania.

Jako podsumowanie proponuj diagram obrazujcy dziaáanie poznanych modyfikatorów:

Schemat 6. Przedziaá wartoci typów liczbowych ze znakiem (

signed

) i bez znaku (

unsigned

)

Widzimy, *e zastosowanie

unsigned

powoduje „przeniesienie” ujemnej poáowy przedziaáu

zmiennej bezporednio za jej czü dodatni. Nie mamy wówczas mo*liwoci korzystania
z liczb ujemnych, ale w zamian otrzymujemy dwukrotnie wicej miejsca na wartoci
dodatnie. Tak to ju* jest w programowaniu, *e nie ma nic za darmo :D

Rozmiar typu caákowitego

W poprzednim paragrafie wspominalimy o przedziale dopuszczalnych wartoci zmiennej,
ale nie przygldalimy si bli*ej temu zagadnieniu. Teraz zatrzymamy si na nim troch
dáu*ej i zajmiemy rozmiarem zmiennych caákowitych.

Wiadomo nam doskonale, *e pamiü komputera jest ograniczona, zatem miejsce
zajmowane w tej pamici przez ka*d zmienn jest równie* limitowane. W przypadku
typów liczbowych przejawia si to ograniczonym przedziaáem wartoci, które mog
przyjmowaü zmienne nale*ce do takich typów.

Jak du*y jest to przedziaá? Nie ma uniwersalnej odpowiedzi na to pytanie. Okazuje si
bowiem, *e rozmiar typu

int

jest zale*ny od kompilatora. Wpáyw na t wielkoü ma

porednio system operacyjny oraz procesor komputera.
Nasz kompilator (Visual C++ .NET), podobnie jak wszystkie tego typu narzdzia
pracujce w systemie Windows 95 i wersjach pó(niejszych, jest 32-bitowy. Oznacza to
midzy innymi, *e typ

int

ma u nas wielkoü równ 32 bitom wáanie, a wic w

przeliczeniu

4 bajtom.

Cztery bajty to cztery znaki (na przykáad cyfry) – czy*by zatem najwikszymi i
najmniejszymi mo*liwymi do zapisania wartociami byáy +9999 i -9999?…
Oczywicie, *e nie! Komputer przechowuje liczby w znacznie efektywniejszej postaci
dwójkowej. Wykorzystanie ka*dego bitu sprawia, *e granice przedziaáu wartoci typu

int

to a* ±2

– nieco ponad dwa miliardy!

Wicej informacji na temat sposobu przechowywania danych w pamici operacyjnej

mo*esz znale(ü w Dodatku B, Reprezentacja danych w pamici.

Przedziaá ten sprawdza si dobrze w wielu zastosowaniach. Czasem jednak jest on zbyt
maáy (tak, to mo*liwe :D) lub zwyczajnie zbyt du*y. Daje si to odczuü na przykáad przy
odczytywaniu plików, w których ka*da wartoü zajmuje obszar o cile okrelonym
rozmiarze, nie zawsze równym

int

-owym 4 bajtom (tzw. plików binarnych).

1 bajt to 8 bitów.

Operacje na zmiennych

Dlatego te* C++ udostpnia nam porczny zestaw dwóch modyfikatorów, którymi
mo*emy wpáywaü na wielkoü typu caákowitego. S to:

short

(‘krótki’) oraz

long

(‘dáugi’). U*ywamy ich podobnie jak

signed

unsigned

– poprzedzajc typ

int

którym z

nich:

short

int

nZmienna;

// "krótka" liczba caákowita

long

int

nZmienna;

// "dáuga" liczba caákowita

Có* znacz jednak te, nieco *artobliwe, okrelenia „krótkiej” i „dáugiej” liczby? Chyba
najlepsz odpowiedzi bdzie tu… stosowna tabelka :)

nazwa rozmiar przedziaá wartoci

int

4 bajty

od –2

do +2

- 1

short

int

2 bajty

od -32 768 do +32 767

long

int

4 bajty

od –2

do +2

- 1

Tabela 4. Typy caákowite w 32-bitowym Visual C++ .NET

Niespodziank mo*e byü brak typu o rozmiarze 1 bajta. Jest on jednak obecny w C++ –
to typ…

char

:) Owszem, reprezentuje on znak. Nie zapominajmy jednak, *e komputer

operuje na znakach jak na odpowiadajcym im kodom liczbowym. Dlatego te* typ

char

jest w istocie tak*e typem liczb caákowitych!

Visual C++ udostpnia te* nieco lepszy sposób na okrelenie wielkoci typu liczbowego.
Jest nim u*ycie frazy

__int

n, gdzie n oznacza rozmiar zmiennej w bitach. Oto przykáady:

__int8

nZmienna;

// 8 bitów == 1 bajt, wartoci od -128 do 127

__int16

nZmienna;

// 16 bitów == 2 bajty, wartoci od -32768 do 32767

__int32

nZmienna;

// 32 bity == 4 bajty, wartoci od -2

do 2

– 1

__int64

nZmienna;

// 64 bity == 8 bajtów, wartoci od -2

do 2

– 1

__int8

jest wic równy typowi

char

__int16

–

short

int

, a

__int32

–

int

lub

long

int

. Gigantyczny typ

__int64

nie ma natomiast swojego odpowiednika.

Precyzja typu rzeczywistego

Podobnie jak w przypadku typu caákowitego

int

, typ rzeczywisty

float

posiada

okrelon rozpitoü wartoci, które mo*na zapisaü w zmiennych o tym typie. Poniewa*
jednak jego przeznaczeniem jest przechowywanie wartoci uáamkowych, pojawia si
kwestia precyzji zapisu takich liczb.

Szczegóáowe wyjanienie sposobu, w jaki zmienne rzeczywiste przechowuj wartoci, jest
doü skomplikowane i dlatego je sobie darujemy

:) Najwa*niejsze s dla nas wynikajce

z niego konsekwencje. Otó*:

Precyzja zapisu liczby w zmiennej typu rzeczywistego maleje wraz ze wzrostem
wartoci tej liczby

Przykáadowo, du*a liczba w rodzaju

10000000.0023

zostanie najpewniej zapisana bez

czci uáamkowej. Natomiast maáa wartoü, jak

1.43525667

bdzie przechowana z du*

To zastrze*enie jest konieczne. Wprawdzie

int

zajmuje 4 bajty we wszystkich 32-bitowych kompilatorach,

ale w przypadku pozostaáych typów mo*e byü inaczej! Standard C++ wymaga jedynie, aby

short

int

byá

mniejszy lub równy od

int

-a, a

long

int

wikszy lub równy

int

-owi.

Zainteresowanych odsyáam do Dodatku B.

Podstawy programowania

dokáadnoci, z kilkoma cyframi po przecinku. Ze wzgldu na t wáaciwoü (zmienn
precyzj) typy rzeczywiste nazywamy czsto zmiennoprzecinkowymi.

Zgadza si – typy. Podobnie jak w przypadku liczb caákowitych mo*emy dodaü do typu

float

odpowiednie modyfikatory. I podobnie jak wówczas, ujrzymy je w nale*ytej

tabelce :)

nazwa rozmiar

precyzja

float

4 bajty

6–7 cyfr

double

float

8 bajtów 15-16 cyfr

Tabela 5. Typy zmiennoprzecinkowe w C++

double

(‘podwójny’), zgodnie ze swoj nazw, zwiksza dwukrotnie rozmiar zmiennej

oraz poprawia jej dokáadnoü. Tak zmodyfikowana zmienna jest nazywana czasem liczb
podwójnej precyzji - w odró*nieniu od

float

, która ma tylko pojedyncz precyzj.

Skrócone nazwy

Na koniec warto nadmieniü jeszcze o mo*noci skrócenia nazw typów zawierajcych
modyfikatory. W takich sytuacjach mo*emy bowiem caákowicie pominü sáowa

int

float

Przykáadowe deklaracje:

unsigned

int

uZmienna;

short

int

nZmienna;

unsigned

long

int

nZmienna;

double

float

fZmienna;

mog zatem wygldaü tak:

unsigned

uZmienna;

short

nZmienna;

unsigned

long

nZmienna;

double

fZmienna;

Maáa rzecz, a cieszy ;) Mamy te* kolejny dowód na du* kondensacj skáadni C++.

***

Poznane przed chwil modyfikatory umo*liwiaj nam wiksz kontrol nad zmiennymi w
programie. Pozwalaj bowiem na dokáadne okrelenie, jak zmienn chcemy w danej
chwili zadeklarowaü i nie dopuszczaj, by kompilator mylaá za nas ;D

Pomocne konstrukcje

Zapoznamy si teraz z dwoma elementami jzyka C++, które uáatwiaj nieco prac z
ró*nymi typami zmiennych. Bdzie to instrukcja

typedef

oraz operator

sizeof

Instrukcja

typedef

Wprowadzenie modyfikatorów sprawiáo, *e oto mamy ju* nie kilka, a przynajmniej
kilkanacie typów zmiennych. Nazwy tych*e typów s przy tym dosyü dáugie i wielokrotne
ich wpisywanie mo*e nam zabieraü du*o czasu. Zbyt du*o.

Operacje na zmiennych

Dlatego te* (i nie tylko dlatego) C++ posiada instrukcj

typedef

(ang. type definition –

definicja typu). Mo*emy jej u*yü do nadania nowej nazwy (aliasu) dla ju*
istniejcego typu. Zastosowanie tego mechanizmu mo*e wygldaü choüby tak:

typedef

unsigned

int

UINT;

Powy*sza linijka kodu mówi kompilatorowi, *e od tego momentu typ

unsigned

int

posiada tak*e dodatkow nazw - UINT. Staj si ona dokáadnym synonimem
pierwotnego okrelenia. Odtd bowiem obie deklaracje:

unsigned

int

uZmienna;

oraz

UINT uZmienna;

s w peáni równowa*ne.

U*ycie

typedef

, podobnie jak jej skáadnia, jest bardzo proste:

typedef

typ nazwa;

Skutkiem skorzystania z tej instrukcji jest mo*liwoü wstawiania nowej nazwy tam, gdzie
wczeniej musielimy zadowoliü si jedynie starym typem. Obejmuje to zarówno
deklaracje zmiennych, jak i parametrów funkcji tudzie* zwracanych przez nie wartoci.
Dotyczy wic wszystkich sytuacji, w których moglimy korzystaü ze starego typu –
nowa nazwa nie jest pod tym wzgldem w *aden sposób uáomna.

Jaka jest praktyczna korzyü z definiowania wáasnych okrele dla istniejcych typów?
Pierwsz z nich jest przytoczone wczeniej skracanie nazw, które z pewnoci pozytywnie
wpáynie na stan naszych klawiatur ;)) Oszczdnociowe „przydomki” w rodzaju
zaprezentowanego wy*ej UINT s przy tym na tyle wygodne i szeroko wykorzystywane,
*

e niektóre kompilatory (w tym i nasz Visual C++) nie wymagaj nawet ich jawnego

okrelenia!
Mo*liwoü dowolnego oznaczania typów pozwala równie* na nadawanie im znaczcych
nazw, które obrazuj ich zastosowania w aplikacji. Z przykáadem podobnego
postpowania spotkasz si przy tworzeniu programów okienkowych w Windows. U*ywa
si tam wielu typów o nazwach takich jak HWND, HINSTANCE, WPARAM, LRESULT itp., z
których ka*dy jest jedynie aliasem na 32-bitow liczb caákowit bez znaku. Stosowanie
takiego nazewnictwa powa*nie poprawia czytelnoü kodu – oczywicie pod warunkiem, *e
znamy znaczenie stosowanych nazw :)

Zauwa*my pewien istotny fakt. Mianowicie,

typedef

nie tworzy nam *adnych nowych

typów, a jedynie duplikuje ju* istniejce. Zmiany, które czyni w sposobie
programowania, s wic stricte kosmetyczne, choü na pierwszy rzut oka mog wygldaü
na doü znaczne.
Do kreowania zupeánie nowych typów sáu* inne elementy jzyka C++, z których czü
poznamy w nastpnym rozdziale.

Operator

sizeof

Przy okazji prezentacji ró*nych typów zmiennych podawaáem zawsze iloü bajtów, któr
zajmuje w pamici ka*dy z nich. Przypominaáem te* kilka razy, *e wielkoci te s
prawdziwe jedynie w przypadku kompilatorów 32-bitowych, a niektóre nawet tylko w
Visual C++.

Podstawy programowania

Z tego* powodu mog one szybko staü si po prostu nieaktualne. Przy dzisiejszym
tempie postpu technicznego, szczególnie w informatyce, wszelkie zmiany dokonuj si
w zasadzie nieustannie

. W tej gonitwie tak*e programici nie mog pozostawaü w tyle –

w przeciwnym wypadku przystosowanie ich starych aplikacji do nowych warunków
technologicznych mo*e kosztowaü mnóstwo czasu i wysiáku.
Jednoczenie wiele programów opiera swe dziaáanie na rozmiarze typów podstawowych.
Wystarczy napomknü o tak czstej czynnoci, jak zapisywanie danych do plików albo
przesyáanie ich poprzez sieü. Jeliby ka*dy program musiaá mieü wpisane „na sztywno”
rzeczone wielkoci, wtedy spora czü pracy programistów upáywaáaby na
dostosowywaniu ich do potrzeb nowych platform sprztowych, na których miaáyby dziaáaü
istniejce aplikacje. A co z tworzeniem caákiem nowych produktów?…

Szczliwie twórcy C++ byli na tyle zapobiegliwi, *eby uchroniü nas, koderów, od tej
koszmarnej perspektywy. Wprowadzili bowiem operator

sizeof

(‘rozmiar czego’), który

pozwala na uzyskanie wielkoci zmiennej (lub jej typu) w trakcie dziaáania programu.
Spojrzenie na poni*szy przykáad powinno nam przybli*yü funkcjonowanie tego operatora:

// Sizeof - pobranie rozmiaru zmiennej lub typu

#include

#include

<conio.h>

void

main()

{
std::cout

"Typy liczb calkowitych:"

<< std::endl;

std::cout

"- int: "

sizeof

(

int

) << std::endl;

std::cout

"- short int: "

sizeof

(

short

int

) << std::endl;

std::cout

"- long int: "

sizeof

(

long

int

) << std::endl;

std::cout

"- char: "

sizeof

(

char

) << std::endl;

std::cout << std::endl;

std::cout

"Typy liczb zmiennoprzecinkowych:"

<< std::endl;

std::cout

"- float: "

sizeof

(

float

) << std::endl;

std::cout

"- double: "

sizeof

(

double

) << std::endl;

getch();
}

Uruchomienie programu z listingu powy*ej, jak sáusznie mo*na przypuszczaü, bdzie nam
skutkowaáo krótkim zestawieniem rozmiarów typów podstawowych.

Screen 20.

sizeof

w akcji

W chwili pisania tych sáów – pod koniec roku 2003 – mamy ju* coraz wyra(niejsze widoki na powa*ne

wykorzystanie procesorów 64-bitowych w domowych komputerach. Jednym ze skutków tego „zwikszenia
bitowoci” bdzie zmiana rozmiaru typu liczbowego

int

Operacje na zmiennych

Po uwa*nym zlustrowaniu kodu (ródáowego widaü jak na dáoni dziaáanie oraz sposób
u*ycia operatora

sizeof

. Wystarczy podaü mu typ lub zmienn jako parametr, by

otrzymaü w wyniku jego rozmiar w bajtach

. Potem mo*emy zrobiü z tym rezultatem

dokáadnie to samo, co z ka*d inn liczb caákowit – chocia*by wywietliü j w konsoli
przy u*yciu strumienia wyjcia.

Zastosowanie

sizeof

nie ogranicza si li tylko do typów wbudowanych. Gdy w kolejnych

rozdziaáach nauczymy si tworzyü wáasne typy zmiennych, bdziemy mogli w identyczny
sposób ustalaü ich rozmiary przy pomocy poznanego przed momentem operatora. Nie da
si ukryü, *e bardzo lubimy takie uniwersalne rozwizania :D

Wartoü, któr zwraca operator

sizeof

, nale*y do specjalnego typu size_t. Zazwyczaj

jest on to*samy z

unsigned

int

, czyli liczb bez znaku (bo przecie* rozmiar nie mo*e

byü ujemny). Nale*y wic uwa*aü, aby nie przypisywaü jej do zmiennej, która jest liczb

ze znakiem.

Rzutowanie

Idea typów zmiennych wprowadza nam pewien sposób klasyfikacji wartoci. Niektóre z
nich uznajemy bowiem za liczby caákowite (

, -

itd.), inne za

zmiennoprzecinkowe (

7.189

12.56

, -

1.41

8.0

itd.), jeszcze inne za tekst (

"ABC"

"Hello world!"

itp.) czy pojedyncze znaki

(

'F'

'@'

itd.).

Ka*dy z tych rodzajów odpowiada nam któremu z poznanych typów zmiennych.
Najczciej te* nie s one ze sob kompatybilne – innymi sáowy, „nie pasuj” do siebie,
jak chocia*by tutaj:

int

nX =

;

int

nY =

0.333

* nX;

Wynikiem dziaáania w drugiej linijce bdzie przecie* liczba rzeczywista z czci
uáamkow, któr nijak nie mo*na wpasowaü w ciasne ramy typu

int

, zezwalajcego

jedynie na wartoci caákowite

Oczywicie, w podanym przykáadzie wystarczy zmieniü typ drugiej zmiennej na

float

, by

rozwizaü nurtujcy nas problem. Nie zawsze jednak bdziemy mogli pozwoliü sobie na
podobne kompromisy, gdy* czsto jedynym wyjciem stanie si „wymuszenie” na
kompilatorze zaakceptowania káopotliwego kodu.
Aby to uczyniü, musimy rzutowaü (ang. cast) przypisywan wartoü na docelowy typ –
na przykáad

int

. Rzutowanie dziaáa troch na zasadzie umowy z kompilatorem, która w

naszym przypadku mogáaby brzmieü tak: „Wiem, *e naprawd jest to liczba
zmiennoprzecinkowa, ale wáanie tutaj chc, aby staáa si liczb caákowit typu

int

, bo

musz j przypisaü do zmiennej tego typu”. Takie porozumienie wymaga ustpstw od
obu stron – kompilator musi „pogodziü si” z chwilowym zaprzestaniem kontroli typów, a
programista powinien liczyü si z ewentualn utrat czci danych (w naszym przykáadzie
powicimy cyfry po przecinku).

cilej mówic,

sizeof

podaje nam rozmiar obiektu w stosunku do wielkoci typu

char

. Jednak*e typ ten ma

najczciej wielkoü dokáadnie 1 bajta, zatem utaráo si stwierdzenie, i*

sizeof

zwraca w wyniku iloü bajtów.

Nie ma w zasadzie *adnego powodu, by uznaü to za bád.

Znaki s typu

char

, który jak wiemy jest tak*e typem liczbowym. W C++ kod znaku jest po prostu

jednoznaczny z nim samym, dlatego mo*emy go interpretowaü zarówno jako symbol, jak i wartoü liczbow.

Niektóre kompilatory (w tym i Visual C++) zaakceptuj powy*szy kod, jednak*e nie obejdzie si bez

ostrze*e o mo*liwej (i faktycznej!) utracie danych. Wprawdzie niektórzy nie przejmuj si w ogóle takimi
ostrze*eniami, my jednak nie bdziemy tak krótkowzroczni :D

Podstawy programowania

Proste rzutowanie

Zatem do dzieáa! Zobaczmy, jak w praktyce wygldaj takie „negocjacje” :) Zostawimy
na razie ten trywialny, dwulinijkowy przykáad (wrócimy jeszcze do niego) i zajmiemy si
powa*niejszym programem. Oto i on:

// SimpleCast - proste rzutowanie typów

void

main()

{

for

(

int

i =

; i <

256

; i +=

)

{

std::cout

"| "

<< (

char

) (i) <<

" == "

<< i <<

" | "

;

std::cout << (

char

) (i +

) <<

" == "

<< i +

" | "

;

std::cout << (

char

) (i +

) <<

" == "

<< i +

" | "

;

std::cout << (

char

) (i +

) <<

" == "

<< i +

" |"

;

std::cout << std::endl;

}

getch();
}

Huh, faktycznie nie jest to banalny kod :) Wykonywana przeze czynnoü jest jednak
doü prosta. Aplikacja ta pokazuje nam tablic kolejnych znaków wraz z odpowiadajcymi
im kodami ANSI.

Screen 21. Fragment tabeli ANSI

Najwa*niejsza jest tu dla nas sama operacja rzutowania, ale warto przyjrzeü si
funkcjonowaniu programu jako caáoci.
Zawarta w nim ptla

for

wykonuje si dla co czwartej wartoci licznika z przedziaáu od

255

. Skutkuje to faktem, i* znaki s wywietlane wierszami, po 4 w ka*dym.

Pomijamy znaki o kodach mniejszych od 32 (czyli te z zakresu 0…31), poniewa* s to

specjalne symbole sterujce, zasadniczo nieprzeznaczone do wywietlania na ekranie.

Znajdziemy wród nich na przykáad tabulator (kod 9), znak „powrotu karetki” (kod 13),

koca wiersza (kod 10) czy sygnaá bádu (kod 7).

Operacje na zmiennych

Za prezentacj pojedynczego wiersza odpowiadaj te wielce interesujce instrukcje:

std::cout <<

"| "

<< (

char

) (i) <<

" == "

<< i <<

" | "

;

std::cout << (

char

) (i +

) <<

" == "

<< i +

" | "

;

std::cout << (

char

) (i +

) <<

" == "

<< i +

" | "

;

std::cout << (

char

) (i +

) <<

" == "

<< i +

" |"

;

Sdzc po widocznym ich efekcie, ka*da z nich wywietla nam jeden znak oraz
odpowiadajcy mu kod ANSI. Przygldajc si bli*ej temu listingowi, widzimy, *e
zarówno pokazanie znaku, jak i przynale*nej mu wartoci liczbowej odbywa si zawsze
przy pomocy tego samego wyra*enia. Jest nim odpowiednio i, i +

, i +

lub i +

Jak to si dzieje, *e raz jest ono interpretowane jako znak, a innym razem jako liczba?
Domylasz si zapewne niebagatelnej roli rzutowania w dziaáaniu tej „magii” :) Istotnie,
jest ono konieczne. Jako *e licznik i jest zmienn typu

int

, zacytowane wy*ej cztery

wyra*enia tak*e nale* do tego typu. Przesáanie ich do strumienia wyjcia w
niezmienionej postaci powoduje wywietlenie ich wartoci w formie liczb. W ten sposób
pokazujemy kody ANSI kolejnych znaków.
Aby wywietliü same symbole musimy jednak oszukaü nieco nasz strumie std::cout,
rzutujc wspomniane wartoci liczbowe na typ

char

. Dziki temu zostan one

potraktowane jako znaki i tako* wywietlone w konsoli.

Zobaczmy, w jaki sposób realizujemy tutaj to osáawione rzutowanie. Spójrzmy
mianowicie na jeden z czterech podobnych kawaáków kodu:

(

char

) (i +

)

Ten niepozorny fragment wykonuje caá wa*k operacj, któr nazywamy rzutowaniem.
Zapisanie w nawiasach nazwy typu

char

przed wyra*eniem i +

(dla jasnoci

umieszczonym równie* w nawiasach) powoduje bowiem, i* wynik tak ujtego dziaáania
zostaje uznany jako podpadajcy pod typ

char

. Tak jest te* traktowany przez strumie

wyjcia, dziki czemu mo*emy go ogldaü jako znak, a nie liczb.

Zatem, aby rzutowaü jakie wyra*enie na wybrany typ, musimy u*yü niezwykle prostej
konstrukcji:

(typ) wyra*enie

wyra*enie mo*e byü przy tym ujte w nawias lub nie; zazwyczaj jednak stosuje si
nawiasy, by uniknü potencjalnych káopotów z kolejnoci operatorów.

Mo*na tak*e u*yü skáadni typ(wyra*enie). Stosuje si j rzadziej, gdy* przypomina

wywoáanie funkcji i mo*e byü przez to przyczyn pomyáek.

Wróümy teraz do naszego pierwotnego przykáadu. Rozwizanie problemu, który wczeniej
przedstawiaá, powinno byü ju* banalne:

int

nX =

;

int

nY = (

int

) (

0.333

* nX);

Po takich manipulacjach zmienna nY bdzie przechowywaáa czü caákowit z wyniku
podanego mno*enia. Oczywicie tracimy w ten sposób dokáadnoü oblicze, co jest
jednak nieuniknion cen kompromisu towarzyszcego rzutowaniu :)

Podstawy programowania

Operator

static_cast

Umiemy ju* dokonywaü rzutowania, poprzedzajc wyra*enie nazw typu napisan w
nawiasach. Taki sposób postpowania wywodzi si jeszcze z zamierzcháych czasów jzyka
C

, poprzednika C++. Czy*by miaáo to znaczyü, *e jest on záy?…

Powiedzmy, *e nie jest wystarczajco dobry :) Nie przecz, *e na pocztku mo*e
wydawaü si wietnym rozwizaniem – klarownym, prostym, niewymagajcym wiele
pisania etc. Jednak im dalej w las, tym wicej mieci: ju* teraz dokáadniejsze spojrzenie
ujawnia nam wiele mankamentów, a w miar zwikszania si twoich umiejtnoci i
wiedzy dostrze*esz ich jeszcze wicej.

Spójrzmy choüby na sam skáadni. Oprócz swojej niewtpliwej prostoty posiada dwie
zdecydowanie nieprzyjemne cechy.
Po pierwsze, zwiksza nam iloü nawiasów w wyra*eniach, które zawieraj rzutowanie. A
przecie* nawet i bez niego potrafi one byü dostatecznie skomplikowane. Czste przecie*
u*ycie kilku operatorów, kilku funkcji (z których ka*da ma pewnie po kilka parametrów)
oraz kilku dodatkowych nawiasów (aby nie káopotaü si kolejnoci dziaáa) gmatwa
nasze wyra*enia w dostatecznym ju* stopniu. Je*eli dodamy do tego jeszcze par
rzutowa, mo*e nam wyjü co w tym rodzaju:

int

nX = (

int

) (((

* nY) / (

float

) (nZ +

)) – (

int

) Funkcja(nY *

));

Konwersje w formie (typ) wyra*enie z pewnoci nie poprawiaj tu czytelnoci kodu.
Drugim problemem jest znowu* kolejnoü dziaáa. Pytanie za piü punktów: jak wartoü
ma zmienna nY w poni*szym fragmencie?

float

fX =

0.75

;

int

nY = (

int

) fX *

;

Zatem?… Je*eli obecne w drugiej linijce rzutowanie na

int

dotyczy jedynie zmiennej fX,

to jej wartoü (

0.75

) zostanie zaokrglona do zera, zatem nY bdzie przypisane równie*

zero. Jeli jednak konwersji na

int

zostanie poddane caáe wyra*enie (

0.75

, czyli

2.25

), to nY przyjmie wartoü

Wybrnicie z tego dylematu to… kolejna para nawiasów, obejmujca t czü wyra*enia,
któr faktycznie chcemy rzutowaü. Wyglda wic na to, *e nie opdzimy si od czstego
stosowania znaków ( i ).

Skáadnia to jednak nie jedyny káopot. Tak naprawd o wiele wa*niejsze s kwestie
zwizane ze sposobem, w jaki jest realizowane samo rzutowanie. Niestety, na razie
jeste w niezbyt komfortowej sytuacji, gdy* musisz zaakceptowaü pewien fakt bez
uzasadnienia („na wiar” :D). Brzmi on nastpujco:

Rzutowanie w formie (typ) wyra*enie, zwane te* rzutowaniem w stylu C, nie jest
zalecane do stosowania w C++.

Dokáadnie przyczyny takiego stanu rzeczy poznasz przy okazji omawiania klas i
programowania obiektowego

Nazywa si go nawet rzutowaniem w stylu C.

Dla szczególnie dociekliwych mam wszak*e wyjanienie czciowe. Mianowicie, rzutowanie w stylu C nie

rozró*nia nam tzw. bezpiecznych i niebezpiecznych konwersji. Za bezpieczn mo*emy uznaü zamian jednego
typu liczbowego na drugi czy wska(nika szczegóáowego na wska(nik bardziej ogólny (np.

int

* na

void

* - o

wska(nikach powiemy sobie szerzej, gdy ju* uporamy si z podstawami :)). Niebezpieczne rzutowanie to
konwersja midzy niezwizanymi ze sob typami, na przykáad liczb i tekstem; w zasadzie nie powinno si
takich rzeczy robiü.

Operacje na zmiennych

No dobrze, zaáó*my, *e uznajemy t odgórn rad

i zobowizujemy si nie stosowaü

rzutowania „nawiasowego” w swoich programach. Czy to znaczy, *e w ogóle tracimy
mo*liwoü konwersji zmiennych jednego typu na inne?!
Rzeczywistoü na szczcie nie jest a* tak straszna :) C++ posiada bowiem a* cztery
operatory rzutowania, które s najlepszym sposobem na realizacj zamiany typów w
tym jzyku. Bdziemy sukcesywnie poznawaü je wszystkie, a zaczniemy od najczciej
stosowanego – tytuáowego

static_cast

(‘rzutowanie statyczne’) nie ma nic wspólnego z modyfikatorem

static

zmiennymi statycznymi. Operator ten sáu*y do przeprowadzania najbardziej pospolitych
konwersji, które jednak s spotykane najczciej. Mo*emy go stosowaü wszdzie, gdzie
sposób zamiany jest oczywisty – zarówno dla nas, jak i kompilatora ;)

Najlepiej po prostu zawsze u*ywaü

static_cast

, uciekajc si do innych rodków, gdy

ten zawodzi i nie jest akceptowany przez kompilator (albo wi*e si z pokazaniem
ostrze*enia).

W szczególnoci, mo*emy i powinnimy korzystaü ze

static_cast

przy rzutowaniu

midzy typami podstawowymi. Zobaczmy zreszt, jak wygldaáoby ono dla naszego
ostatniego przykáadu:

float

fX =

0.75

;

int

nY =

static_cast

int

>(fX *

;

Widzimy, *e u*ycie tego operatora od razu likwiduje nam niejednoznacznoü, na któr
poprzednio zwrócilimy uwag. Wyra*enie poddawane rzutowaniu musimy bowiem ujü
w nawiasy okrgáe.
Ciekawy jest sposób zapisu nazwy typu, na który rzutujemy. Znaki < i >, oprócz tego *e
s operatorami mniejszoci i wikszoci, tworz par nawiasów ostrych. Pomidzy nimi
wpisujemy okrelenie docelowego typu.

Peána skáadnia operatora

static_cast

wyglda wic nastpujco:

static_cast

<typ>(wyra*enie)

Byü mo*e jest ona bardziej skomplikowana od „zwykáego” rzutowania, ale u*ywajc jej
osigamy wiele korzyci, o których mogáe si naocznie przekonaü :)

Warto te* wspomnieü, *e trzy pozostaáe operatory rzutowania maj identyczn postaü –
oczywicie z wyjtkiem sáowa

static_cast

, które jest zastpione innym.

***

T uwag koczymy omawianie ró*nych aspektów zwizanych z typami zmiennych w
jzyku C++. Wreszcie zajmiemy si tytuáowymi zagadnieniami tego rozdziaáu, czyli
czynnociach, które mo*emy wykonywaü na zmiennych.

Problem z rzutowaniem w stylu C polega na tym, i* zupeánie nie rozró*nia tych dwóch rodzajów zamiany.
Pozostaje tak samo niewzruszone na niewinn konwersj z

float

int

oraz, powiedzmy, na zupeánie

nienaturaln zmian std::string na

bool

. Nietrudno domyleü si, *e zwiksza to prawdopodobiestwo

wystpowania ró*nego rodzaju bádów.

Jak wszystko, co dotyczy fundamentów jzyka C++, pochodzi ona od jego Komitetu Standaryzacyjnego.

Podstawy programowania

Kalkulacje na liczbach

Poznamy teraz kilka standardowych operacji, które mo*emy wykonywaü na danych
liczbowych. Najpierw bd to odpowiednie funkcje, których dostarcza nam C++, a
nastpnie uzupeánienie wiadomoci o operatorach arytmetycznych. Zaczynajmy wic :)

Przydatne funkcje

C++ udostpnia nam wiele funkcji matematycznych, dziki którym mo*emy
przeprowadzaü proste i nieco bardziej záo*one obliczenia. Prawie wszystkie s zawarte w
pliku nagáówkowym cmath, dlatego te* musimy doáczyü ten plik do ka*dego programu,
w którym chcemy korzystaü z tych funkcji. Robimy to analogicznie jak w przypadku
innych nagáówków – umieszczajc na pocztku naszego kodu dyrektyw:

#include

<cmath>

Po dopeánieniu tej drobnej formalnoci mo*emy korzystaü z caáego bogactwa narzdzi
matematycznych, jakie zapewnia nam C++. Spójrzmy wic, jak si one przedstawiaj.

Funkcje potgowe

W przeciwiestwie do niektórych jzyków programowania, C++ nie posiada oddzielnego
operatora potgowania

. Zamiast niego mamy natomiast funkcj pow() (ang. power –

potga), która prezentuje si nastpujco:

double

pow(

double

base,

double

exponent);

Jak widaü, bierze ona dwa parametry. Pierwszym (base) jest podstawa potgi, a drugim
(exponent) jej wykáadnik. W wyniku zwracany jest oczywicie wynik potgowania (a wic
wartoü wyra*enia base

exponent

Podobn do powy*szej deklaracj funkcji, przedstawiajc jej nazw, iloü i typy
parametrów oraz typ zwracanej wartoci, nazywamy prototypem.

Oto kilka przykáadów wykorzystania funkcji pow():

double

fX;

fX = pow(

);

// ósma potga dwójki, czyli 256

fX = pow(

);

// czwarta potga trójki, czyli 81

fX = pow(

, -

);

// odwrotnoü pitki, czyli 0.2

Inn równie czsto wykonywan czynnoci jest pierwiastkowanie. Realizuje j midzy
innymi funkcja sqrt() (ang. square root – pierwiastek kwadratowy):

double

sqrt(

double

x);

Jej jedyny parametr to oczywicie liczba, która chcemy pierwiastkowaü. U*ycie tej funkcji
jest zatem niezwykle intuicyjne:

fX = sqrt(

);

// 8 (bo 8*8 == 64)

fX = sqrt(

);

// okoáo 1.414213562373

Znak ^, który sáu*y w nich do wykonywania tego dziaáania, jest w C++ zarezerwowany dla jednej z operacji

bitowych – ró*nicy symetrycznej. Wicej informacji na ten temat mo*esz znale(ü w Dodatku B, Reprezentacja
danych w pamici.

Operacje na zmiennych

fX = sqrt(pow(fY,

));

// fY

Nie ma natomiast wbudowanej formuáy, która obliczaáaby pierwiastek dowolnego
stopnia z danej liczby. Mo*emy jednak áatwo napisaü j sami, korzystajc z prostej
wáasnoci:

Po przeáo*eniu tego równania na C++ uzyskujemy nastpujc funkcj:

double

root(

double

{

return

pow(x,

/ a); }

Zapisanie jej definicji w jednej linijce jest caákowicie dopuszczalne i, jak widaü, bardzo
wygodne. Elastycznoü skáadni C++ pozwala wic na zupeánie dowoln organizacj kodu.

Dokáadny opis poznanych funkcji

pow()

sqrt()

znajdziesz w MSDN.

Funkcje wykáadnicze i logarytmiczne

Najczciej stosowan w matematyce funkcj wykáadnicz jest

, niekiedy oznaczana

tak*e jako

)

exp(x

. Tak te* form ma ona w C++:

double

exp(

double

x);

Zwraca ona wartoü staáej e

podniesionej do potgi x. Popatrzmy na kilka przykáadów:

fX = exp(

);

// 1

fX = exp(

);

// e

fX = exp(

2.302585093

);

// 10.000000

Natomiast funkcj wykáadnicz o dowolnej podstawie uzyskujemy, stosujc omówion ju*
wczeniej formuá pow().

Przeciwstawne do funkcji wykáadniczych s logarytmy. Tutaj mamy a* dwie odpowiednie
funkcje :) Pierwsza z nich to log():

double

log(

double

x);

Jest to logarytm naturalny (o podstawie e), a wic funkcja dokáadnie do odwrotna do
poprzedniej exp(). Otó* dla danej liczby x zwraca nam wartoü wykáadnika, do którego
musielibymy podnieü e, by otrzymaü x. Dla peánej jasnoci zerknijmy na poni*sze
przykáady:

fX = log(

);

// 0

fX = log(

);

// 2.302585093

fX = log(exp(x));

// x

Drug funkcj jest log10(), czyli logarytm dziesitny (o podstawie 10):

double

log10(

double

x);

Tak zwanej staáej Nepera, podstawy logarytmów naturalnych - równej w przybli*eniu

2.71828182845904

Podstawy programowania

Analogicznie, funkcja ta zwraca wykáadnik, do którego nale*aáoby podnieü dziesitk,
aby otrzymaü podan liczb x, na przykáad:

fX = log10(

1000

);

// 3 (bo 10

== 1000)

fX = log10(

);

// 0

fX = log10(pow(

, x));

// x

Niestety, znowu (podobnie jak w przypadku pierwiastków) nie mamy bardziej
uniwersalnego odpowiednika tych dwóch funkcji, czyli logarytmu o dowolnej podstawie.
Ponownie jednak mo*emy skorzystaü z odpowiedniej to*samoci matematycznej

log

Nasza wáasna funkcja mo*e wic wygldaü tak:

double

log_a(

double

{

return

log(x) / log(a); }

Oczywicie u*ycie log10() w miejsce log() jest równie* poprawne.

Zainteresowanych ponownie odsyáam do MSDN celem poznania dokáadnego opisu funkcji

exp()

oraz

log() i log10()

Funkcje trygonometryczne

Dla nas, (przyszáych) programistów gier, funkcje trygonometryczne s szczególnie
przydatne, gdy* bdziemy korzystaü z nich niezwykle czsto – choüby przy ró*norakich
obrotach. Wypadaáoby zatem dobrze znaü ich odpowiedniki w jzyku C++.

Na pocztek przypomnijmy sobie (znane, mam nadziej :D) okrelenia funkcji
trygonometrycznych. Posáu*y nam do tego poni*szy rysunek:

Rysunek 1. Definicje funkcji trygonometrycznych dowolnego kta

Znanej jako zmiana podstawy logarytmu.

Operacje na zmiennych

Zwróümy uwag, *e trzy ostatnie funkcje s okrelone jako odwrotnoci trzech
pierwszych. Wynika std fakt, i* potrzebujemy do szczcia jedynie sinusa, cosinusa i
tangensa – reszt funkcji i tak bdziemy mogli áatwo uzyskaü.
C++ posiada oczywicie odpowiednie funkcje:

double

sin(

double

alfa);

// sinus

double

cos(

double

alfa);

// cosinus

double

tan(

double

alfa);

// tangens

Dziaáaj one identycznie do swoich geometrycznych odpowiedników. Jako jedyny
parametr przyjmuj miar kta w radianach i zwracaj wyniki, których bez wtpienia
mo*na si spodziewaü :)
Je*eli chodzi o trzy brakujce funkcje, to ich definicje s, jak sdz, oczywiste:

double

cot(

double

alfa)

{

return

/ tan(alfa); }

// cotangens

double

sec(

double

alfa)

{

return

/ cos(alfa); }

// secant

double

csc(

double

alfa)

{

return

/ sin(alfa); }

// cosecant

Gdy pracujemy z ktami i funkcjami trygonometrycznymi, nierzadko pojawia si
koniecznoü zamiany miary kta ze stopni na radiany lub odwrotnie. Niestety, nie
znajdziemy w C++ odpowiednich funkcji, które realizowaáyby to zadanie. Byü mo*e
dlatego, *e sami mo*emy je áatwo napisaü:

const

double

PI =

3.1415923865

;

double

degtorad(

double

alfa)

{

return

alfa * PI /

180

; }

double

radtodeg(

double

alfa)

{

return

alfa *

180

/ PI; }

Pamitajmy te*, aby nie myliü tych dwóch miar któw i zdawaü sobie spraw, i* funkcje
trygonometryczne w C++ u*ywaj radianów. Pomyáki w tej kwestii s doü czste i
powoduj nieprzyjemne rezultaty, dlatego nale*y si ich wystrzegaü :)

Jak zwykle, wicej informacji o funkcjach

sin()

cos()

tan()

znajdziesz w MSDN.

Mo*esz tam równie* zapoznaü si z funkcjami odwrotnymi do trygonometrycznych –

asin()

acos()

oraz

atan() i atan2()

Liczby pseudolosowe

Zostawmy ju* te zdecydowanie zbyt matematyczne dywagacje i zajmijmy si czym, co
bardziej zainteresuje przecitnego zjadacza komputerowego i programistycznego
chleba :) Mam tu na myli generowanie wartoci losowych.
Liczby losowe znajduj zastosowanie w bardzo wielu programach. W przypadku gier
mog sáu*yü na przykáad do tworzenia realistycznych efektów ognia, deszczu czy niegu.
U*ywajc ich mo*emy równie* kreowaü za ka*dym inn map w grze strategicznej czy
zapewniü pojawianie si wrogów w przypadkowych miejscach w grach zrcznociowych.
Przydatnoü liczb losowych jest wic bardzo szeroka.

Uzyskanie losowej wartoci jest w C++ caákiem proste. W tym celu korzystamy z funkcji
rand() (ang. random – losowy):

int

rand();

Jak mo*naby przypuszczaü, zwraca nam ona przypadkow liczb dodatni

. Najczciej

jednak potrzebujemy wartoci z okrelonego przedziaáu – na przykáad w programie

Liczba ta nale*y do przedziaáu <

RAND_MAX>, gdzie RAND_MAX jest staá zdefiniowan przez kompilator (w

Visual C++ .NET ma ona wartoü

32767

Podstawy programowania

ilustrujcym dziaáanie ptli

while

losowalimy liczb z zakresu od

100

. Osignlimy

to w doü prosty sposób:

int

nWylosowana = rand() %

100

;

Wykorzystanie operatora reszty z dzielenia sprawia, *e nasza dowolna wartoü (zwrócona
przez rand()) zostaje odpowiednio „przycita” – w tym przypadku do przedziaáu <

;

(poniewa* reszt z dzielenia przez sto mo*e byü

, …,

). Dodanie jedynki

zmienia ten zakres do po*danego <

;

100

W podobny sposób mo*emy uzyskaü losow liczb z jakiegokolwiek przedziaáu. Nie od
rzeczy bdzie nawet napisanie odpowiedniej funkcji:

int

random(

int

nMin,

int

nMax)

{

return

rand() % (nMax - nMin +

) + nMin; }

U*ywajc jej, potrafimy bez trudu stworzyü chocia*by symulator rzutu kostk do gry:

void

main()

{
std::cout

"Wylosowano "

<< random(

) <<

" oczek."

;

getch();
}

Zdaje si jednak, *e co jest nie caákiem w porzdku… Uruchamiajc parokrotnie
powy*szy program, za ka*dym razem zobaczymy jedn i t sam liczb! Gdzie jest wic
ta obiecywana losowoü?!

Có*, nie ma w tym nic dziwnego. Komputer to tylko wielkie liczydáo, które dziaáa w
zaprogramowany i przewidywalny sposób. Dotyczy to tak*e funkcji rand(), której
dziaáanie opiera si na raz ustalonym i niezmiennym algorytmie. Jej wynik nie jest zatem
w *aden sposób losowany, lecz wyliczany na podstawie formuá matematycznych.
Dlatego te* liczby uzyskane w ten sposób nazywamy pseudolosowymi, poniewa* tylko
udaj prawdziw przypadkowoü.
Wydawaü by si mogáo, *e fakt ten czyni je caákowicie nieprzydatnymi. Na szczcie nie
jest to prawd: liczby pseudolosowe mo*na z powodzeniem wykorzystywaü we
wáaciwym im celu – pod warunkiem, *e robimy to poprawnie.

Musimy bowiem pamitaü, aby przed pierwszym u*yciem rand() wywoáaü inn funkcj –
srand():

void

srand(

unsigned int

seed);

Jej parametr seed to tak zwane ziarno. Jest to liczba, która inicjuje generator wartoci
pseudolosowych. Dla ka*dego mo*liwego ziarna funkcja rand() oblicza nam inny cig
liczb. Zatem, logicznie wnioskujc, powinnimy dbaü o to, by przy ka*dym uruchomieniu
programu wartoü ziarna byáa inna.
Dochodzimy tym samym do pozornie bádnego koáa – *eby uzyskaü liczb losow,
potrzebujemy… liczby losowej! Jak rozwizaü ten, zdawaáoby si, nierozwizywalny
problem?…

Otó* nale*y znale(ü tak wartoü, która bdzie si zmieniaü miedzy kolejnymi
uruchomieniami programu. Nietrudno j wskazaü – to po prostu czas systemowy.
Jego pobranie jest bardzo áatwe, bowiem C++ udostpnia nam zgrabn funkcj time(),
zwracajca aktualny czas

w sekundach:

Funkcja ta zwraca liczb sekund, jakie upáynáy od póánocy 1 stycznia 1970 roku.

Operacje na zmiennych

time_t time(time_t* timer);

Byü mo*e wyglda ona dziwnie, ale zapewniam ci, *e dziaáa wietnie :) Wymaga jednak,
abymy doáczyli do programu dodatkowy nagáówek ctime:

#include

<ctime>

Teraz mamy ju* wszystko, co potrzebne. Zatem do dzieáa! Nasza prosta aplikacja
powinna obecnie wygldaü tak:

// Random - losowanie liczby

#include

#include

<ctime>

#include

<conio.h>

int

random(

int

nMin,

int

nMax) {

return

rand() % nMax + nMin; }

void

main()

{

// zainicjowanie generatora liczb pseudolosowych aktualnym czasem

srand

(

static_cast

unsigned

int

>(time(NULL)));

// wylosowanie i pokazanie liczby

std::cout

"Wylosowana liczba to "

<< random(

) << std::endl;

getch();
}

Kompilacja i kilkukrotne uruchomienie powy*szego kodu utwierdzi nas w przekonaniu, i*
tym razem wszystko funkcjonuje poprawnie.

Screen 22. Przykáadowy rezultat „rzutu kostk”

Dzieje si tak naturalnie za spraw tej linijki:

srand (

static_cast

unsigned

int

>(time(NULL)));

Wywoáuje ona funkcj srand(), podajc jej ziarno uzyskane poprzez time(). Ze wzgldu
na to, i* time() zwraca wartoü nale*c do specjalnego typu time_t, potrzebne jest
rzutowanie jej na typ

unsigned int

Wyjanienia wymaga jeszcze parametr funkcji time(). NULL to tak zwany wska(nik
zerowy, niereprezentujcy *adnej przydatnej wartoci. U*ywamy go tutaj, gdy* nie
mamy nic konkretnego do przekazania dla funkcji, za ona sama niczego takiego od nas
nie wymaga :)

Kompletny opis funkcji

rand()

srand()

time()

znajdziesz, jak poprzednio, w MSDN.

Zaokrglanie liczb rzeczywistych

Gdy poznawalimy rzutowanie typów, podaáem jako przykáad konwersj wartoci

float

int

. Wspomniaáem te*, *e zastosowane w tym przypadku zaokrglenie liczby

rzeczywistej polega na zwyczajnym odrzuceniu jej czci uáamkowej.

Podstawy programowania

Nie jest to wszak*e jedyny sposób dokonywania podobnej zamiany, gdy* C++ posiada
te* dwie specjalnie do tego przeznaczone funkcje. Dziaáaj one w inaczej ni* zwykáe
rzutowanie, co samo w sobie stanowi dobry pretekst do ich poznania :D

Owe dwie funkcje s sobie wzajemnie przeciwstawne – jedna zaokrgla liczb w gór
(wynik jest zawsze wikszy lub równy podanej wartoci), za druga w dóá (rezultat jest
mniejszy lub równy). wietne obrazuj to ich nazwy, odpowiednio: ceil() (ang. ceiling –
sufit) oraz floor() (‘podáoga’).
Przyjrzyjmy si teraz nagáówkom tych funkcji:

double

ceil(

double

x);

double

floor(

double

x);

Nie ma tu *adnych niespodzianek – no, mo*e poza typem zwracanego wyniku. Dlaczego
nie jest to

int

? Otó* typ

double

ma po prostu wiksz rozpitoü przedziaáu wartoci,

jakie mo*e przechowywaü. Poniewa* argument funkcji tak*e nale*y do tego typu,
zastosowanie

int

spowodowaáoby otrzymywanie bádnych rezultatów dla bardzo du*ych

liczb (takich, jakie „nie zmieciáyby si” do

int

-a).

Na koniec mamy jeszcze kilka przykáadów, ilustrujcych dziaáanie poznanych przed chwil
funkcji:

fX = ceil(

6.2

);

// 7.0

fX = ceil(-

5.6

);

// -5.0

fX = ceil(

);

// 14.0

fX = floor(

1.7

);

// 1.0

fX = floor(-

2.1

);

// -3.0

Szczególnie dociekliwych czeka kolejna wycieczka wgáb MSDN po dokáadny opis funkcji

ceil()

floor()

Inne funkcje

Ostatnie dwie formuáy trudno przyporzdkowaü do jakiej konkretnej grupy. Nie znaczy
to jednak, *e s one mniej wa*ne ni* pozostaáe.

Pierwsz z nich jest abs() (ang. absolute value), obliczajca wartoü bezwzgldn
(moduá) danej liczby. Jak pamitamy z matematyki, wartoü ta jest t sam liczb, lecz
bez znaku – zawsze dodatni.
Ciekawa jest deklaracja funkcji abs(). Istnieje bowiem kilka jej wariantów, po jednym
dla ka*dego typu liczbowego:

int

abs(

int

n);

float

abs(

float

n);

double

abs(

double

n);

Jest to jak najbardziej mo*liwe i w peáni poprawne. Zabieg taki nazywamy
przeci*aniem (ang. overloading) funkcji.

Przeci*anie funkcji (ang. function overloading) to obecnoü kilku deklaracji funkcji o
tej samej nazwie, lecz posiadajcych ró*ne listy parametrów i/lub typy zwracanej
wartoci.

Gdy wic wywoáujemy funkcj abs(), kompilator stara si wydedukowaü, który z jej
wariantów powinien zostaü uruchomiony. Czyni to przede wszystkim na podstawie
przekazanego do parametru. Je*eli byáaby to liczba caákowita, zostaáaby wywoáana

Operacje na zmiennych

wersja przyjmujca i zwracajca typ

int

. Je*eli natomiast podalibymy liczb

zmiennoprzecinkow, wtedy do akcji wkroczyáby inny wariant funkcji.
Zatem dziki mechanizmowi przeci*ania funkcja abs() mo*e operowaü na ró*nych
typach liczb:

int

nX = abs(-

);

// 45

float

fX = abs(

7.5

);

// 7.5

double

fX = abs(-

27.8

);

// 27.8

Druga funkcja to fmod(). Dziaáa ona podobnie do operatora %, gdy* tak*e oblicza reszt z
dzielenia dwóch liczb. Jednak w przeciwiestwie do niego nie ogranicza si jedynie do
liczb caákowitych, bowiem potrafi operowaü tak*e na wartociach rzeczywistych. Widaü to
po jej nagáówku:

double

fmod(

double

y);

Funkcja ta wykonuje dzielenie x przez y i zwraca pozostaá ze reszt, co oczywicie
á

atwo wydedukowaü z jej nagáówka :) Dla porzdku zerknijmy jeszcze na par

przykáadów:

fX = fmod(

);

// 2

fX = fmod(

2.75

0.5

);

// 0.25

fX = fmod(-

);

// -1

Wielbiciele MSDN mog zacieraü rce, gdy* z pewnoci znajd w niej szczegóáowe opisy

funkcji

abs()

fmod()

;)

***

Zakoczylimy w ten sposób przegld asortymentu funkcji liczbowych, oferowanego
przez C++. Przyswoiwszy sobie wiadomoci o tych formuáach bdziesz mógá robiü z
liczbami niemal wszystko, co tylko sobie zamarzysz :)

Znane i nieznane operatory

Dobrze wiemy, *e funkcje to nie jedyne rodki sáu*ce do manipulacji wartociami
liczbowymi. Od pocztku u*ywalimy do tego przede wszystkim operatorów, które
odpowiadaáy doskonale nam znanym podstawowym dziaáaniom matematycznym.
Nadarza si dobra okazja, aby przypomnieü sobie o tych elementach jzyka C++, przy
okazji poszerzajc swoje informacje o nich.

Dwa rodzaje

Operatory w C++ mo*emy podzieliü na dwie grupy ze wzgldu na liczb „parametrów”,
na których dziaáaj. Wyró*niamy wic operatory unarne – wymagajce jednego
„parametru” oraz binarne – potrzebujce dwóch.

Do pierwszej grupy nale* na przykáad symbole + oraz -, gdy stawiamy je przed jakim
wyra*eniem. Wtedy bowiem nie peáni roli operatorów dodawania i odejmowania, lecz
zachowania lub zmiany znaku. Mo*e brzmi to doü skomplikowanie, ale naprawd jest
bardzo proste:

int

nX =

;

Standardowo doáczona do Visual Studio .NET biblioteka MSDN posiada lekko nieaktualny opis tej funkcji –

nie s tam wymienione jej wersje przeci*ane dla typów

float

double

Podstawy programowania

int

nY = +nX;

// nY == 5

nY = -nX;

// nY == -5

Operator + zachowuje nam znak wyra*enia (czyli praktycznie nie robi nic, dlatego zwykle
si go nie stosuje), za – zmienia go na przeciwny (neguje wyra*enie). Operatory te
maj identyczn funkcj w matematyce, dlatego, jak sdz, nie powinny sprawiü ci
wikszego káopotu :)
Do grupy operatorów unarnych zaliczamy równie* ++ oraz --, odpowiadajce za
inkrementacj i dekrementacj. Za chwil przyjrzymy im si bli*ej.

Drugi zestaw to operatory binarne; dla nich konieczne s dwa argumenty. Do tej grupy
nale* wszystkie poznane wczeniej operatory arytmetyczne, a wic + (dodawanie), -
(odejmowanie), * (mno*enie), / (dzielenie) oraz % (reszta z dzielenia).
Poniewa* swego czasu powicilimy im sporo uwagi, nie bdziemy teraz dogábnie
wnikaü w dziaáanie ka*dego z nich. Wicej miejsca przeznaczymy tylko na operator
dzielenia.

Sekrety inkrementacji i dekrementacji

Operatorów ++ i -- u*ywamy, aby dodaü do zmiennej lub odjü od niej jedynk. Taki
zapis jest najkrótszy i najwygodniejszy, a poza tym najszybszy. U*ywamy go szczególnie
czsto w ptlach

for

Jednak mo*e byü on tak*e czci záo*onych wyra*e. Poni*sze fragmenty kodu s
absolutnie poprawne i w dodatku nierzadko spotykane:

int

nA =

;

int

nB = ++nA;

int

nC =

;

int

nD = nC++;

Od tej pory bd mówiá jedynie o operatorze inkrementacji, jednak wszystkie
przedstawione tu wáasnoci dotycz tak*e jego dekrementujcego brata.

Nasuwa si naturalne pytanie: jakie wartoci bd miaáy zmienne nA, nB, nC i nD po
wykonaniu tych czterech linijek kodu?

Je*eli chodzi o nA i nC, to sprawa jest oczywista. Ka*da z tych zmiennych zostaáa
jednokrotnie poddana inkrementacji, zatem ich wartoci s o jeden wiksze ni* na
pocztku. Wynosz odpowiednio

Pozostaáe zmienne s ju* twardszym orzechem do zgryzienia. Skupmy si wic chwilowo
na nB. Jej wartoü na pewno ma co wspólnego z wartoci nA - mo*e to byü albo

(liczba przed inkrementacj), albo

(ju* po inkrementacji). Analogicznie, nD mo*e byü

równa

(czyli wartoci nC przed inkrementacj) lub

(po inkrementacji).

Jak jest w istocie? Sam si przekonaj! Stwórz nowy program, wpisz do jego funkcji
main() powy*sze wiersze kodu i dodaj instrukcje pokazujce wartoci zmiennych…

Có* widzimy? Zmienna nB jest równa

, a wic zostaáa jej przypisana wartoü nA ju* po

inkrementacji. Natomiast nD równa si

- tyle, co nC przed inkrementacj.

Przyczyn tego faktu jest rzecz jasna rozmieszczenie plusów. Gdy napisalimy je przed
inkrementowan zmienn, dostalimy w wyniku wartoü zwikszon o 1. Kiedy za
umiecilimy je za t zmienn, otrzymalimy jeszcze stary rezultat.
Jak zatem moglimy si przekonaü, odpowiednie zapisanie operatorów ++ i -- ma
caákiem spore znaczenie.

Operacje na zmiennych

Umieszczenie operatora ++ (--) przed wyra*eniem nazywamy preinkrementacj
(predekrementacj). W takiej sytuacji najpierw dokonywane jest zwikszenie
(zmniejszenie) jego wartoci o 1. Nowa wartoü jest potem zwracana jako wynik.

Kiedy napiszemy operator ++ (--) po wyra*eniu, mamy do czynienia z
postinkrementacj (postdekrementacj). W tym przypadku najpierw nastpuje
zwrócenie wartoci, która dopiero potem jest zwikszana (zmniejszana) o jeden

Czy*by trzeba byáo tych reguáek uczyü si na pamiü? Oczywicie, *e nie :) Jak wikszoü
rzeczy w programowaniu, mo*emy je traktowaü intuicyjnie.
Kiedy napiszemy plusy (lub minusy) przed zmienn, wtedy najpierw „zadziaáaj”
wáanie one. A skutkiem ich dziaáania bdzie inkrementacja lub dekrementacja wartoci
zmiennej, a wic otrzymamy w rezultacie ju* zmodyfikowan liczb.
Gdy za umiecimy je za nazw zmiennej, ustpi jej pierwszestwa i pozwol, aby jej
stara wartoü zostaáa zwrócona. Dopiero potem wykonaj swoj prac, czyli
in/dekrementacj.

Je*eli mamy mo*liwoü dokonania wyboru midzy dwoma poáo*eniami operatora ++ (lub

--), powinnimy zawsze u*ywaü wariantu prefiksowego (przed zmienn). Wersja

postfiksowa musi bowiem utworzyü w pamici kopi zmiennej, *eby móc zwróciü jej star

wartoü po in/dekrementacji. Cierpi na tym zarówno szybkoü programu, jak i jego

wymagania pamiciowe (chocia* w przypadku typów liczbowych jest to niezauwa*alna

ró*nica).

Sáówko o dzieleniu

W programowaniu mamy do czynienia z dwoma rodzajami dzielenia liczb:
caákowitoliczbowym oraz zmiennoprzecinkowym. Oba zwracaj te same rezultaty w
przypadku podzielnych przez siebie liczb caákowitych, ale w innych sytuacjach zachowuj
si odmiennie.
Dzielenie caákowitoliczbowe podaje jedynie caákowit czü wyniku, odrzucajc cyfry po
przecinku. Z tego powodu wynik takiego dzielenia mo*e byü bezporednio przypisany do
zmiennej typu caákowitego. Wtedy jednak traci si dokáadnoü ilorazu.
Dzielenie zmiennoprzecinkowe pozwala uzyskaü precyzyjny rezultat, gdy* zwraca liczb
rzeczywist wraz z jej czci uáamkow. Ów wynik musi byü wtedy zachowany w
zmiennej typu rzeczywistego.

Wiksza czü jzyków programowania rozró*nia te dwa typy dzielenia poprzez
wprowadzenie dwóch odrbnych operatorów dla ka*dego z nich

. C++ jest tu swego

rodzaju wyjtkiem, poniewa* posiada tylko jeden operator dzielcy, /. Jednak*e
posáugujc si nim odpowiednio, mo*emy uzyskaü oba rodzaje ilorazów.

Zasady, na podstawie których wyró*niane s w C++ te dwa typy dzielenia, s ci ju*
dobrze znane. Przedstawilimy je sobie podczas pierwszego spotkania z operatorami
arytmetycznymi. Poniewa* jednak powtórze nigdy doü, wymienimy je sobie
ponownie :)

Je*eli obydwa argumenty operatora / (dzielna i dzielnik) s liczbami caákowitymi, wtedy
wykonywane jest dzielenie caákowitoliczbowe.

To uproszczone wyjanienie, bo przecie* zwrócenie wartoci koczyáoby dziaáanie operatora. Naprawd wic

wartoü wyra*enia jest tymczasowo zapisywana i zwracana po dokonaniu in/dekrementacji.

W Visual Basicu jest to \ dla dzielenia caákowitoliczbowego i / dla zmiennoprzecinkowego. W Delphi

odpowiednio div i /.

Podstawy programowania

W przypadku, gdy chocia* jedna z liczb biorcych udziaá w dzieleniu jest typu
rzeczywistego, mamy do czynienia z dzieleniem zmiennoprzecinkowym.

Od chwili, w której poznalimy rzutowanie, mamy wiksz kontrol nad dzieleniem.
Mo*emy bowiem áatwo zmieniü typ jednej z liczb i w ten sposób spowodowaü, by zostaá
wykonany inny rodzaj dzielenia. Mo*liwe staje si na przykáad uzyskanie dokáadnego
ilorazu dwóch wartoci caákowitych:

int

nX =

;

int

nY =

;

float

fIloraz = nX /

static_cast

float

>(nY);

Tutaj uzyskamy precyzyjny rezultat

2.4

, gdy* kompilator przeprowadzi dzielenie

zmiennoprzecinkowe. Zrobi tak, bo drugi argument operatora /, mimo *e ma wartoü
caákowit, jest traktowany jako wyra*enie typu

float

. Dzieje si tak naturalnie dziki

rzutowaniu.
Gdybymy go nie zastosowali i wpisali po prostu nX / nY, wykonaáoby si dzielenie
caákowitoliczbowe i uáamkowa czü wyniku zostaáaby obcita. Ten okrojony rezultat
zmieniáby nastpnie typ na

float

(poniewa* przypisalibymy go do zmiennej

rzeczywistej), co byáoby zupeánie zbdne, gdy* i tak w wyniku dzielenia dokáadnoü
zostaáa stracona.

Prosty wniosek brzmi: uwa*ajmy, jak i co tak naprawd dzielimy, a w razie wtpliwoci
korzystajmy z rzutowania.

***

Koczcy si wáanie podrozdziaá prezentowaá podstawowe instrumentarium operacyjne
wartoci liczbowych w C++. Poznajc je zyskaáe potencjaá do tworzenia aplikacji
wykorzystujcych záo*one obliczenia, do których niewtpliwie nale* tak*e gry.

Je*eli czujesz si przytáoczony nadmiarem matematyki, to mam dla ciebie dobr
wiadomoü: nasza uwaga skupi si teraz na zupeánie innym, lecz równie* wa*nym typie
danych - tekcie.

acuchy znaków

Cigi znaków (ang. strings) stanowi drugi, po liczbach, wa*ny rodzaj informacji
przetwarzanych przez programy. Chocia* zajmuj wicej miejsca w pamici ni* dane
binarne, a operacje na nich trwaj dáu*ej, maj wiele znaczcych zalet. Jedn z nich jest
fakt, i* s bardziej zrozumiaáe dla czáowieka ni* zwykáe sekwencje bitów. W czasie, gdy
moce komputerów rosn bardzo szybko, wymienione wczeniej wady nie s natomiast a*
tak dotkliwe. Wszystko to powoduje, *e dane tekstowe s coraz powszechniej spotykane
we wspóáczesnych aplikacjach.

Du*a jest w tym tak*e rola Internetu. Takie standardy jak HTML czy XML s przecie*
formatami tekstowymi.

Dla programistów napisy byáy od zawsze przyczyn czstych bólów gáowy. W
przeciwiestwie bowiem do typów liczbowych, maj one zmienny rozmiar, który nie
mo*e byü ustalony raz podczas uruchamiania programu. Iloü pamici operacyjnej, któr
zajmuje ka*dy napis musi byü dostosowywana do jego dáugoci (liczby znaków) i
zmieniaü si podczas dziaáania aplikacji. Wymaga to dodatkowego czasu (od programisty

Operacje na zmiennych

i od komputera), uwagi oraz dokáadnego przemylenia (przez programist, nie
komputer ;D) mechanizmów zarzdzania pamici.
Zwykli u*ytkownicy pecetów - szczególnie ci, którzy pamitaj jeszcze zamierzcháe czasy
DOSa - tak*e nie maj dobrych wspomnie zwizanych z danymi tekstowymi. Odwieczne
káopoty z polskimi „ogonkami” nadal daj o sobie znaü, choü na szczcie coraz rzadziej
musimy ogldaü na ekranie dziwne „krzaczki” zamiast znajomych liter w rodzaju ‘’, ‘ü’,
‘’ czy ‘(’.

Wydaje si wic, *e przed koderem piszcym programy przetwarzajce tekst pitrz si
niebotyczne wrcz trudnoci. Problemy s jednak po to, aby je rozwizywaü (lub by inni
rozwizywali je za nas ;)), wic oba wymienione dylematy doczekaáy si ju* wielu bardzo
dobrych pomysáów.
Rozszerzajce si wykorzystanie standardu Unicode ograniczyáo ju* znacznie káopoty
zwizane ze znakami specyficznymi dla niektórych jzyków. Kwesti czasu zdaje si
chwila, gdy znikn one zupeánie.
Powstaáo te* mnóstwo sposobów na efektywne skáadowanie napisów o zmiennej dáugoci
w pamici komputera. Wprawdzie w tym przypadku nie ma jednego, wiodcego trendu
zapewniajcego przenonoü midzy wszystkimi platformami sprztowymi lub chocia*
aplikacjami, jednak i tak sytuacja jest znacznie lepsza ni* jeszcze kilka lat temu

Koderzy mog wic sobie pozwoliü na uzasadniony optymizm :)

Wsparci tymi pokrzepiajcymi faktami mo*emy teraz przystpiü do poznawania
elementów jzyka C++, które sáu* do pracy z áacuchami znaków.

Napisy wedáug C++

Trudno w to uwierzyü, ale poprzednik C++ - jzyk C - w ogóle nie posiadaá odrbnego
typu zmiennych, mogcego przechowywaü napisy. Aby móc operowaü danymi
tekstowymi, trzeba byáo u*ywaü maáo porcznych tablic znaków (typu

char

) i samemu

dbaü o zagadnienia zwizane z przydzielaniem i zwalnianiem pamici.
Nam, programistom C++, nic takiego na szczcie nie grozi :) Nasz ulubiony jzyk jest
bowiem wyposa*ony w kilka bardzo przydatnych i áatwych w obsáudze mechanizmów,
które udostpniaj mo*liwoü manipulacji tekstem.

Rozwizania, o których bdzie mowa poni*ej, s czci Biblioteki Standardowej jzyka

C++. Jako *e jest ona dostpna w ka*dym kompilatorze tego jzyka, sposoby te s

najbardziej uniwersalne i przenone, a jednoczenie wydajne. Korzystanie z nich jest

tak*e bardzo wygodne i áatwe.

Oprócz nich istniej równie* inne metody obsáugi áacuchów znaków. Na przykáad

biblioteki MFC i VCL (wspomagajce programowanie w Windows) posiadaj wáasne

narzdzia, sáu*ce temu wáanie celowi

. Nawet je*eli skorzystasz kiedy z tych

bibliotek, bdziesz mógá wci* u*ywaü opisanych tutaj mechanizmów standardowych.

Aby móc z nich skorzystaü, nale*y przede wszystkim wáczyü do swojego kodu plik
nagáówkowy string:

#include

Po tym zabiegu zyskujemy dostp do caáego arsenaáu rodków programistycznych,
sáu*cych operacjom tekstowym.

Du* zasáug ma w tym ustandaryzowanie jzyka C++, w którym powstaje ponad poáowa wspóáczesnych

aplikacji. W przyszáoci znaczc rol mog odegraü tak*e rozwizania zawarte w platformie .NET.

MFC (Microsoft Foundation Classes) zawiera przeznaczon do tego klas CString, za VCL (Visual Component

Library) posiada typ String, który jest czci kompilatora C++ firmy Borland.

Podstawy programowania

100

Typy zmiennych tekstowych

Istniej dwa typy zmiennych tekstowych, które ró*ni si rozmiarem pojedynczego
znaku. Ujmuje je poni*sza tabelka:

nazwa

typ znaku rozmiar znaku

zastosowanie

std::string

char

1 bajt

tylko znaki ANSI

std::wstring

wchar_t

2 bajty

znaki ANSI i Unicode

Tabela 6. Typy áacuchów znaków

std::string jest ci ju* dobrze znany, gdy* u*ywalimy go niejednokrotnie. Przechowuje
on dowoln (w granicach dostpnej pamici) iloü znaków, z których ka*dy jest typu

char

. Zajmuje wic dokáadnie 1 bajt i mo*e reprezentowaü jeden z 256 symboli

zawartych w tablicy ANSI.

Wystarcza to do przechowywania tekstów w jzykach europejskich (choü wymaga
specjalnych zabiegów, tzw. stron kodowych), jednak staje si niedostateczne w
przypadku dialektów o wikszej liczbie znaków (na przykáad wschodnioazjatyckich).
Dlatego wykoncypowano, aby dla pojedynczego symbolu przeznaczaü wiksz iloü
bajtów i w ten sposób stworzono MBCS (Multi-Byte Character Sets - wielobajtowe
zestawy znaków) w rodzaju Unicode.
Nie mamy tu absolutnie czasu ani miejsca na opisywanie tego standardu. Warto jednak
wiedzieü, *e C++ posiada typ áacuchowy, który umo*liwia wspóáprac z nim - jest to
std::wstring (ang. wide string - „szeroki” napis). Ka*dy jego znak jest typu

wchar_t

(ang. wide char - „szeroki” znak) i zajmuje 2 bajty. àatwo policzyü, *e umo*liwia tym
samym przechowywanie jednego z a* 65536 (256

) mo*liwych symboli, co stanowi

znaczny postp w stosunku do ANSI :)
Korzystanie z std::wstring niewiele ró*ni si przy tym od u*ywania jego bardziej
oszczdnego pamiciowo kuzyna. Musimy tylko pamitaü, *eby poprzedzaü literk L
wszystkie wpisane do kodu staáe tekstowe, które maj byü trzymane w zmiennych typu
std::wstring. W ten sposób bowiem mówimy kompilatorowi, *e chcemy zapisaü dany
napis w formacie Unicode. Wyglda to choüby tak:

std::wstring strNapis = L

"To jest tekst napisany znakami dwubajtowymi"

;

Dobra wiadomoü jest taka, *e jeli zapomniaáby o wspomnianej literce L, to powy*szy
kod w ogóle by si nie skompilowaá ;D

Je*eli chciaáby wywietlaü takie „szerokie” napisy w konsoli i umo*liwiü u*ytkownikowi

ich wprowadzanie, musisz u*yü specjalnych wersji strumieni wejcia i wyjcia. S to

odpowiednio std::wcin i std::wcout U*ywa si ich w identyczny sposób, jak poznanych

wczeniej „zwykáych” strumieni std::cin i std::cout.

Manipulowanie áacuchami znaków

OK, gdy ju* znamy dwa typy zmiennych tekstowych, jakie oferuje C++, czas zobaczyü
mo*liwe dziaáania, które mo*emy na nich przeprowadzaü.

Inicjalizacja

Najprostsza deklaracja zmiennej tekstowej wyglda, jak wiemy, mniej wicej tak:

std::string strNapis;

Wyszukiwarka

Podobne podstrony:
Od zera do gier kodera6
Od zera do gier kodera6
Od zera do gier kodera8
Od zera do gier kodera7
Od zera do gier kodera5
Od zera do gier kodera1
Od zera do milionera
od zera do ecedeela cz 2 (2)
od zera do ecedeela cz 7
Od zera do milionera fragment
od zera do ecedeela cz 4
od zera do ecedeela cz 3
inwestycje, OD ZERA DO MILIONERA
M Smyczek i M Kaim Od zera do ECeDeeLa cz 2 Użytkowanie komputerów
Od zera do milionera
od zera do milionera
od zera do ecedeela cz 7
od zera do ecedeela cz 6

więcej podobnych podstron