Instrukcje sterujące
" program  nie zawsze wykonuje kolejne
instrukcje w porządku ich zamieszczenia w
tekście; niekiedy chcemy to zmienić
" aby to było mo\
liwe  wprowadzono instrukcje
sterujące  kierują one przebiegiem program
Przykład: równanie kwadratowe.
Schemat działania programu:
1. Wczytanie parametrów trójmianu a,b,c
2. Czy a=0? Je\
eli tak błąd, koniec
3. Wyliczenie delta
4. Czy delta>0
a. tak  wyliczenie pierwiastków
b. nie  komunikat o ich braku
" potrzeba instrukcji realizującym dobór ście\
ki w
zale\
ności od okoliczności (np. instrukcja
if)oraz wyra\
eń sprawdzających warunki
" wyra\
enia warunkowe w C
o brak specjalnego typu na przechowanie wartości
wyra\
eń logicznych
o Wartości tych wyra\
eń mogą być reprezentowane przez
dowolny typ numeryczny; prawda  wartość ró\
na od 0,
fałsz  wartość równa 0
" wyra\
enia logiczne w C++
o w C++: specjalny typ danych do przechowywania
wartości wyra\
enia logicznego; jest to typ bool, stałe
tego typu to true (numerycznie = 1) oraz false
(numerycznie = 0)
o mo\
liwy jest dawny sposób przechowywania informacji
logicznej
" instrukcja if  składnia:
A) if (wyrazenie)
instrukcja;
B) if (wyrazenie)
instrukcja1;
else
instrukcja2;
" instrukcja if  wykonanie:
A) oblicz wartość wyra\
enia warunkowego
je\
eli warunek spełniony (prawda/wartość ró\
na
od zera  wykonaj instrukcja
je\
eli nie  opuść ją przejdz
do następnej
instrukcji (po if)
B) oblicz wartość wyra\
enia warunkowego
je\
eli prawda/wartość ró\
na od zera  wykonaj
instrukcja1, opuść instrukcja2
je\
eli nie  wykonaj instrukcja2
przejdz
do następnej (po if)
#include
#include
/* Równanie kwadratowe; instrukcje if, return
biblioteka matematyczna */
int main()
{
double a,b,c;
std::cout << "Podaj a, b, c : ";
std::cin >> a >> b >> c;
std::cout << "a = " << a << " b = " << b << " c = " << c << "\n";
if (a==0.0)
{
std::cout << "Blad !!!\ta = "<< a << std::endl;
return 1;
}
double delta,x1,x2;
delta = b*b-4*a*c;
if(delta<0.0)
{
std::cout <<"Brak pierwiastkow rzeczywistych:\n"
<<"\t\tdelta = " << delta << std::endl;
return 0;
}
else
{
x1=(-b-sqrt(delta))/(2*a);
x2=(-b+sqrt(delta))/(2*a);
std::cout<<"Pierwiastki rzeczywiste rownania wynosza:\n"
<<"\tx1 = " << x1
<<"\n\tx2 = " << x2 << std::endl;
}
return 0;
}
Uwagi:
" blok instrukcji (instrukcja zło\
ona)
" instrukcja return
" edycja programu, wcięcia
" funkcja sqrt  biblioteka matematyczna
double exp(double x) exp(x)
double log(double x) ln(x)
double log10(double x) log(x)
double pow(double x, double y) xy
double sqrt(double x) sqrt(x)
double fabs(double x) |x|
double sin(double x) sin(x)
double cos(double x) cos(x)
double tan(double x) tg(x)
double asin(double x) arcsin(x)
double acos(double x) arccos(x)
double atan(double x) arctg(x)
int abs(int k)
|k|
Podstawowe funkcje matematyczne
" u\
ycie funkcji matematycznych wymaga:
o włączenia pliku nagłówkowego cmath
o opcji kompilatora  lm
gcc kwadrat.c  lm  o kwadrat
Konstrukcja else - if
Konstrukcja else  if
" realizuje decyzje wielowariantowe
" składnia:
if (wyra\
enie0)
instrukcja0;
else if (wyra\
enie1)
instrukcja1;
& &
else if (wyra\
enie_k)
instrukcja_k;
else
instukcja_ostatnia;
" wykonanie  wyliczenie kolejnych wyra\
eń,
pierwsze wyra\
enie prawdziwe (ró\
ne od 0)
powoduje wykonanie instrukcji z nią związanej i
zakończenie całej konstrukcji; je\
eli \
aden
warunek nie jest spełnione wykonana jest
instrukcja po ostatnim else
" przykład:
int punkty;
float ocena;
if (punkty>92)
ocena=5.0;
else if (punkty>85)
ocena=4.5;
else if (punkty>78)
ocena=4.0;
else if (punkty>70)
ocena=3.5;
else if (punkty>60)
ocena=3.0;
else
ocena=2.0;
Pętla while
" wykonuje instrukcję (blok) wiele razy
" składnia:
while (wyra\
enie)
instrukcja;
" wykonanie: oblicza wartość wyra\
enia, gdy
prawda/wynik ró\
ny od 0, to wykonuje
instrukcję, a następnie znowu oblicza
wyra\
enie. Ten cykl powtarza się do chwili
gdy wyra\
enie fałszywe (= 0).
" nie ma gwarancji, \
e pętla wykona się choćby
raz
" Przykład:
#include
#include
// przyklad petli while
int main()
{
std::cout << T[F] T[C]\n ;
std::cout << ---------------\n ;
float fahr=0,cels;
while (fahr<=150)
{
cels=5*(fahr-32.0)/9;
std::cout << std::fixed< < fahr=fahr+10;
}
}
 T[F] T[C]
---------------
0.00 -17.78
10.00 -12.22
20.00 -6.67
30.00 -1.11
40.00 4.44
50.00 10.00
60.00 15.56
70.00 21.11
80.00 26.67
90.00 32.22
100.00 37.78
110.00 43.33
120.00 48.89
130.00 54.44
140.00 60.00
150.00 65.56
Pętla for
Inna realizacja powy\
szego programu:
#include
#include
#define T_DOL 0 /* dolna wartosc temp. */
#define T_GORA 150 /* gorna wartosc temp. */
#define T_KROK 10 /* wartosc kroku temp. */
int main()
{
std::cout <<" T[F] T[C]\n";
std::cout <<"---------------\n";
for (int fahr=T_DOL; fahr<=T_GORA; fahr=fahr+T_KROK)
std::cout << std::fixed< << 1.0*fahr << std::setw(7)<< 5*(fahr-32.0)/9
<< std::endl;
return 0;
}
Uwagi:
" dyrektywa define  definicja stałej
symbolicznej
o ułatwia analizę i zmianę parametrów
o konwencja  stałe symboliczne piszemy du\
ymi
literami
o nie dajemy znaku ; na końcu linii #define
" składnia pętli for:
for (instr_ini; warunek; instr_krok)
instrukcja;
gdzie: instr_ini  instrukcja inicjalizująca
warunek  wyra\
enie warunkowe
instr_krok  instrukcja modyfikująca
" instrukcja for równowa\
na sekwencji
instr_ini;
while(warunek)
{
instrukcja;
instr_krok;
}
" elementy instr_ini, warunek, instr_krok 
nie muszą wystąpić (ale średniki oddzielające 
tak)
" nie ma gwarancji, \
e pętla będzie wykonana
chocia\
raz
" for często stosowana  sterowanie pętlą
skupione w jednym miejscu
#include
// Przyklad działania pętli for
int main()
{
int k, s1, s2, s3;
for (k=1, s1=0, s2=0, s3=0; k<=10; k=k+1)
{
s1=s1+k;
s2=s2+k*k;
s3=s3+k*k*k;
}
std::cout <<  Suma liczb =  << s1 << std::endl;
std::cout <<  Suma kwadratow liczb =  << s2 << std::endl;
std::cout <<  Suma szescianow liczb =  << s3 << std::endl;
return 0;
}
" często stosowana konstrukcja  zagnie\
d\
enie
pętli
Przykład: wydrukować w wierszy wydruku, pierwszy ma
zawierać sz gwiazdek, w ka\
dym następnym ma być o 1
gwiazdkę więcej
#include
int main()
{
int w,sz;
std::cout << Podaj ilosc wierszy:  ;
std::cin >> w;
std::cout << Podaj szerokosc pierwszego wiersza:  ;
std::cin >> sz;
for (int k=0; k {
for(int n=0; n<(sz+k); n=n+1)
std::cout<< * ;
std::cout << std::endl;
}
}
Pętla do ... while
" składnia:
do
instrukcja;
while (warunek);
" działanie  podobne do pętli while. Ró\
nica 
odwrócona kolejność wykonywania instrukcji oraz
sprawdzanie warunku
" mamy gwarancję, \
e instrukcja będzie wykonana co
najmniej raz
" rzadziej stosowana ni\
while i for
Przykład:
#include
int main()
{
float tf;
std::cout << "Wejście: w stopniach Fahrenheita\n"
<< "By zakonczyc wpisz liczbe wieksza niz 1000\n"
<< "-------------------------------------------\n";
do
{
std::cout << "Podaj temperature : ";
std::cin >> tf;
std::cout << tf << " w skali Fahrenheita oznacza "
<< 5*(tf-32)/9 << " w skali Celsjusza.\n";
}
while(tf<=1000);
return 0;
}
Instrukcja switch
" realizacja decyzji wielowariantowej; spraw-
dzenie, czy wartość pewnego wyra\
enia pasuje
do jednej z kilku wartości całkowitych
" składnia:
switch (selektor)
{
case wyra\
enie_stałe_1 : ciąg_instr_1;
case wyra\
enie_stałe_2 : ciąg_instr_2;
& & & & & & & & & & & & & & & & & & & & & &
case wyra\
enie_stałe_k : ciąg_instr_k;
default : ciąg_instr_default;
}
" działanie:
o wyliczenie wartości wyra\
enia selektor
o porównanie wyliczonej wartości kolejno do
wartości wyra\
eń_stałych_k  je\
eli zachodzi
równość, to następuje przeskok do ciągu_instr_k,
po czym wykonane są wszystkie instrukcje poni\
ej
o je\
eli \
aden przypadek nie jest zgodny z wartością
selektora, to nastąpi przejście do przypadku
default (o ile występuje);
o przypadek default nie musi być na końcu !!!
" uwaga:
o selektor i wyra\
nia_stałe_k muszą być typu
całkowitego lub znakowego
o gdy chcemy, by dla przypadku k wykonany był
tylko ciąg_instr_k, po jego zakończeniu dajemy
instrukcję break
o break przerywa wykonanie instrukcji switch
o wartości wyra\
eń stałych nie mogą się powtarzać
o wyra\
enia stałe  muszą być mo\
liwe do
wyliczenia w chwili kompilacji
Przykład:
#include
/* Przykład u\
ycia instrukcji switch, break */
int main()
{
int m;
std::cout <<  Podaj numer miesiaca :  ;
std::cin>>m;
switch (m)
{
case 1: case 3: case 5: case 7:
case 8: case 10: case 12:
std::cout <<  Liczba dni: 31\n ;
break;
case 4: case 6: case 9: case 11:
std::cout <<  Liczba dni: 30\n ;
break;
case 2:
std::cout <<  Liczba dni: 28 lub 29\n ;
break;
default:
std::cout <<  Niewlasciwy numer miesiaca\n ;
break;
}
}
switch vs. if & else if
" obie te instrukcje u\
ywane w sytuacji wyboru
wielowariantowego
" konstrukcja if & else if ogólniejsza, bo mo\
e
być stosowna równie\
, gdy:
o obiekt wybierający (selektor) jest typu innego ni\
int
lub char
o wyra\
enie specyfikujące wybór niekonieczne stałe
o decyzja o wyborze niekoniecznie przyrównanie
" switch  bardziej przejrzysta, chętnie stosowana
Instrukcja break
" mo\
e wystąpić tylko we wnętrzu pętli lub
instrukcji switch
" pozwala na wcześniejsze opuszczenie pętli lub
instrukcji switch
" w przypadku zagnie\
d\
onych pętli bądz

instrukcji switch powoduje przerwanie tylko
jednej z nich  najciaśniej ją otaczającej
Przykład:
#include
int main()
{
int suma,k;
for (suma=0, k=1; ; k=k+1)
{
suma=suma+k*k*k;
if (suma>100) break;
}
std::cout << Przekroczenie nastapi dla k =  << k << \n ;
}
Instrukcja continue
" mo\
e wystąpić tylko we wnętrzu pętli
" powoduje przerwanie kroku bie\
ącego i
wykonanie od początku następnego kroku
zawierającej ją pętli
o dla while i do  przejście do sprawdzenia warunku
zatrzymania
o dla for  przekazanie sterowania do instrukcji
przyrostowej pętli
Przykład: wyliczmy sumę pierwszych N liczb całkowitych
z wyłączeniem tych, które są podzielne przez 7,
#include
/* Przykład u\
ycia continue
operatory ! % */
int main()
{
int N;
std::cout <<  Podaj N:  ;
std::cin >> N;
int k,s;
N=N+1;
for (s=0, k=1; k {
if (!(k%7)) continue;
s=s+k;
}
std::cout << Suma wynosi:  << s<}
Podaj N: 200
Suma wynosi: 17258
Instrukcja skoku, etykiety
" składnia:
goto etykieta;
....
etykieta:
" działanie: powoduje bezwarunkowe
przekazanie sterowanie do instrukcji opatrzonej
etykietą
" etykieta  dowolna dozwolona w C/C++ nazwa;
nie wymaga deklaracji
" etykieta mo\
e być umieszczona w dowolnym
miejscu w treści funkcji, z której jest wywołana
" instrukcja skoku nie powinna być nadu\
ywana;
najczęściej stosowana przy wyjściach z
zagnie\
d\
onych pętli
for ( ... )
{
for ( )
{
....
if (niepowodzenie)
goto error; /* wyjście z wszystkich pętli */
....
}
}
....
error: // napraw błąd lub wypisz komunikat