Kurs C++ Od Zera Do Gier Kodera.pdf

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;

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.

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

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

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

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

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 :)

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

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

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 /.

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;