Podstawy programowania.
4. Wariantowa realizacja programu (instrukcje warunkowe).
4. Wariantowa realizacja programu (instrukcje warunkowe)
Zagadnienia: Elementy logiki. Instrukcja warunkowa. Operatory relacji - budowa
wyrażeń. Operatory logiczne - budowa wyrażeń. Test na wartość
niezerowÄ…. Operator warunkowy. Instrukcja wyboru.
Elementy logiki
W praktyce projektowania programów bardzo często zachodzi potrzeba warian-
towego wykonywania pewnych czynności (sekwencji instrukcji). To oznacza koniecz-
ność dysponowania mechanizmem umożliwiającym wykonanie programu według
określonej ścieżki przebiegowej zdeterminowanej zaistniałymi uwarunkowaniami (np.
zmianą wartości danych) [16], [22], [17]. Decyzja o zmianie kolejności wykonania se-
kwencji instrukcji podejmowana jest na podstawie analizy wyrażenia (zdania), które w
algebrze Boole a jest oceniane w kategoriach prawdy lub fałszu.
Do określenia wartości logicznej zdania służy aparat logiki [11] zdań i logiki pre-
dykatów.
Logika predykatów dostarcza praw wnioskowania odwołujących się do we-
wnętrznej budowy zdań.
Wyróżnia się:
" predykaty (odpowiednik orzeczenia - co robi, co siÄ™ z nim dzieje, w jakim jest
stanie  w tradycyjnej gramatyce),
" argumenty predykatów (odpowiednik podmiotu - kto, co jest wykonawcą czyn-
ności),
" wyrażenia zwane kwantyfikatorami - te wskazują, że predykat jest odnoszony
bÄ…dz
do wszystkich, bÄ…dz
do niektórych przedmiotów z rozważanej dziedziny.
Najprostszym zdaniem w języku logiki predykatów jest formuła atomowa.
Formułę nazywa się atomową, gdy składa się jedynie z predykatu oraz argumentów.
Przykład: predykat dwuargumentowy X > Y (X jest większe niż Y).
Formę atomową przekształca się w wyrażenie o większym stopniu złożoności,
gdy zostanie poprzedzona kwantyfikatorem.
'"
Kwantyfikator ogólny - - odpowiada wyrażeniu każdy.
("
Kwantyfikator egzystencjalny - - odpowiada słowu niektóry (pewien, ist-
nieje,  dla pewnego X jest tak ...").
Logika zdań - jest teorią zajmującą się formami wnioskowania zbudowanymi
wyłącznie ze zmiennych zdaniowych oraz funktorów prawdziwościowych, będących
pewnego rodzaju spójnikami zdaniowymi (funktory dwuargumentowe łączące dwa
zdania w jedno). Teoria ta stanowi wstępną część logiki formalnej, część zakładaną
przez inne teorie. Zamiast terminu logika używany jest termin rachunek. W klasycz-
nej logice zdań1:
" jedynymi stałymi logicznymi są funktory prawdziwościowe (spójniki zdaniowe są
w logice traktowane jako funktory w funkcjach prawdziwościowych) nie , lub,
oraz, jeżeli to;
" są dwie wartości logiczne: prawda (1) i fałsz (0).
1
Syntaktyczne [11] pojęcie zdania języka J jest definiowane za pomocą reguł formowania języka J. Semantycz-
na definicja zdania przedstawia się następująco: powiemy, że A jest zdaniem języka J jeżeli A jest prawdziwe
lub fałszywe w J (w logice wielowartościowej A może przybierać także inne wartości logiczne).
Tabela 4.2. Funkcje logiczne
wartość lo- funkcja
giczna zdań negacja alternatywa koniunkcja alternatywa wykluczająca
p q ~p
p (" q p '" q p •" q
1 0 0 1 0 1
1 1 0 1 1 0
0 0 1 0 0 0
0 1 1 1 0 1
Zmienna zdaniowa jest literÄ… reprezentujÄ…cÄ… dowolne zdanie lub dowolnÄ…
otwartą formułę2 zdaniową [11]. Zmienna zdaniowa wskazuje wolne miejsce, które
może zostać wypełnione przez dowolne wyrażenie należące do kategorii zdań.
Przykład:
X jest rzekÄ…. Gdy zmienna zdaniowa X zostanie zwiÄ…zana z
nazwą np. Wisła to zdanie będzie prawdziwe.
Góra Y jest największą w Gdy zmienna zdaniowa Y zostanie związana z
Polsce. nazwą np. Wisła to zdanie będzie fałszywe.
Logika zdań dostarcza praw wnioskowania odwołujących się do struktury zdań
złożonych, nie wnikając w budowę zdań będących składnikami owych złożeń.
Na przykład: a '" q (" p prawda lub fałsz.
Instrukcja warunkowa
Instrukcja  jeżeli" sprawdza wartość logiczną zdania (zamiast terminu zdanie
będzie stosowany termin wyrażenie) i w zależności od wyniku umożliwia zmianę w
kolejności wykonywania instrukcji (rys. 4.1).
Składnia:
if ( wyrażenie )
if ( wyrażenie )
instrukcja
instrukcja
else
instrukcja
nie
nie
wyrażenie
wyrażenie
tak tak
instrukcja
instrukcja
instrukcja
Rysunek 4.1. Schematy instrukcji warunku
gdzie:
" Wyrażenie musi być typu skalarnego. Wartość wyrażenia jeden (1) oznacza
logiczną prawdę, zaś zero (0) - fałsz3.
" Instrukcja występująca po zamkniętym w nawiasy wyrażeniu jest wykonywana
2
Termin formuła jest skrótem zwrotu  formuła poprawnie zbudowana . Tak pojęta formuła jest zdaniem albo
tzw. formułą otwartą (forma, matryca, funkcja). Formuła otwarta to wyrażenie zawierające co najmniej jedną
zmienną wolną, która staje się zdaniem albo przez związanie występujących w nim zmiennych wolnych
kwantyfikatorami lub przez podstawienie stałych za zmienne.
3
Dla logicznego typu danych można korzystać ze stałych true, false.
2
jeżeli wartość wyrażenia jest niezerowa, w przeciwnym razie wykonywana jest
Instrukcja występująca po słowie kluczowym else. Instrukcja może być dowol-
ną instrukcją języka (składnia dopuszcza tylko jedną) - również grupującą lub
warunkowÄ….
Instrukcja warunkowa może być zagnieżdżana  wtedy ostatnie słowo kluczowe
else należy do najbliższego mu słowa kluczowego if.
if (...)
instrukcja
else
if (...)
instrukcja
else
instrukcja
Operatory relacji
Wyrażenia budowane są przy pomocy dwuargumentowych operatorów porów-
nania (relacji).
Składnia: Op1 operator relacji Op2
Operatory porównania pozwalają stwierdzić czy między operandami Op1, Op2
zachodzi dana relacja. Operatory porównania należą do grupy 6 i 7:
" operatory grupy 6 [łączność lewostronna]:
Op1 > Op2 Op1 większe niż Op2,
Op1 < Op2 Op1 mniejsze niż Op2,
Op1 >= Op2 Op1 większe równe Op2,
Op1 <= Op2 Op1 mniejsze równe Op2;
" operatory grupy 7 [łączność lewostronna]:
Op1 == Op2 Op1 równe Op2,
Op1 != Op2 Op1 różne od Op2.
Operatory logiczne
Złożone wyrażenia logiczne budowane są z relacji połączonych operatorami lo-
gicznymi. Do operatorów logicznych należą:
" operator negacji4
!Op negacja (nieprawda, że Op);
" operator koniunkcji5
Op1 && Op2 koniunkcja (iloczyn Op1 i Op2);
" operator alternatywy6
Op1 || Op2 alternatywa (suma Op1 lub Op2).
Na przykład:
int a = 10, b = 20, rel1, rel2, rel3;
rel1 = a > b; // rel1 = 0
rel2 = a <= b; // rel2 = 1
rel3 = rel2 || rel1; // rel3 = 1
rel3 = rel1 && rel2; // rel3 = 0
rel3 = !(rel2 || rel1); /* rel3 = 0 */
rel3 = !rel2 || rel1; /* rel3 = 0 */
4
Grupa 2, łączność prawostronna.
5
Grupa 11, łączność lewostronna.
6
Grupa 12, łączność lewostronna.
3
Test na wartość niezerową
Składnia: if ( wyrażenie )
odpowiada sekwencji if ( wyrażenie != 0).
Operator warunkowy7 ?
Składnia: Op1 ? Op2 : Op3;
W pierwszej kolejności obliczana jest wartość logiczna wyrażenia Op1. Jeżeli
wynikiem jest prawda (1) - obliczana jest wartość wyrażenia Op2, natomiast Op3 jest
ignorowane; w przeciwnym razie (Op1 - fałsz) obliczana jest wartość wyrażenia Op3,
natomiast operand Op2 jest pomijany. Odpowiada to sekwencji:
if( Op1 )
Op2;
else
Op3;
Przykłady:
int a = 7, b = 8;
z = ( a > b ) ? a : b; /* z = max(a,b) */
//------------------------------
int a = 8, b, c, d;
d = a < 10 ? b = 20: c = 30;
co odpowiada: if( a < 10 )
{
b = 20;
d = b;
}
else
{
c = 30;
d = c;
}
Przykłady instrukcji warunku:
tak tak
i == 5 j > 6
nie
i <= 7
nie nie
tak
tak
k > 2
nie tak
q > 4
nie
j = 2; k = 4
k = 7
k = 4
j = 6
if( i == 5 && j > 6) || ( k < 2 )
{
if( i <= 7 )
j = 2;
if( q > 4 )
k = 4;
j = 6;
}
else
else
k = 4;
k = 7;
7
Ggrupa 13, łączność prawostronna.
4
nie
tak
i <= 7
i <=7
tak
nie
nie
q > 4
tak
q > 4
tak
nie
j = 6
k = 4
j = 6
a = 5
if( i <= 7 )
{
if( i <= 7)
if( q > 4 )
{
j = 6);
if( q > 4 )
}
j = 6;
else
a = 5;
k = 4;
}
nie
nie
i < 5
i == 5
tak
tak
q = 0
q = 6
q = 6
if( i < 5)
if( i == 5)
q = 6;
q = 6;
else
q = 0;
Instrukcja wyboru
Instrukcja wyboru [16], [22], [17] stosowana jest tam gdzie należy dokonać wy-
boru jednego z kilku wariantów na podstawie pojedynczego wyrażenia całkowitolicz-
bowego, o ograniczonym zakresie wartości.
Składnia: switch ( wyrażenie_sterujące ) instrukcja
Instrukcja switch na podstawie wartości wyrażenia sterującego (rys. 1.7) po-
zwala przenieść sterowanie wykonywaniem programu do wskazanego miejsca. Wy-
rażenie sterujące musi być typu całkowitego, zaś instrukcja jest dowolną instrukcją
języka.
5
Wykonywanie instrukcji wyboru polega na obliczeniu wartości wyrażenia steru-
jÄ…cego W i (przeniesieniu sterowania) kontynuowanie wykonywania kodu poczÄ…wszy
od etykiety8 wyboru, której wyrażenie stałe wi ma wartość równą obliczonej wcześniej
wartości wyrażenia sterującego W. Jeżeli żadne z wyrażeń stałych nie spełnia tej
równości, wówczas wykonywany jest skok do miejsca określonego domyślną (default
- w przeciwnym razie) etykietą wyboru lub jeśli jej nie ma - wykonywanie instrukcji
wyboru ulega zakończeniu.
switch ( W )
{
case W1 : instrukcje // W == W1
break;
Å" Å" Å" Å" Å" Å" Å" Å" Å" Å"
Å" Å" Å" Å" Å" Å" Å" Å" Å" Å"
case Wn : instrukcje // W == Wn
break;
default : instrukcje
break;
}
Po przeniesieniu sterowania (wykonaniu skoku) do etykiety wyboru wykonywa-
ne są kolejne instrukcje bez względu na występujące po drodze etykiety wyboru. Za
pomocą instrukcji break można wymusić zakończenie wykonywania instrukcji wybo-
ru.
Przykład:
int i, j = k = 0;
scanf( %d ,&i);
switch ( i )
{
case 0 : k = k + 1;
break;
case 1 : j = j + 1;
break;
default : j = j - 1;
break;
}
Przykład cw04
Zaprojektować algorytm (rys. 4.2) oraz program obliczający pierwiastki trójmia-
nu kwadratowego.
Opis problemu. Dla określonych wartości współczynników a, b, c będących licz-
bami rzeczywistymi znalez
ć miejsca zerowe równania ax2 + bx + c = 0; założenie a `"
0.
Obliczenia przeprowadza się wykorzystując następujące zależności:
delta = b2 - 4 Å" a Å" c ,
" jeżeli delta e" 0 to
- b Ä… delta
x1,2 = ,
2a
8 W obrębie jednej instrukcji wyboru nie wolno stosować etykiet zawierających wyrażenia stałe o tej samej war-
tości.
6
" w przeciwnym razie (gdy delta < 0) - brak rozwiązań rzeczywistych. Rozwiąza-
nie należy do obszaru liczb zespolonych. Liczba zespolona zawiera część rze-
czywistą re oraz urojoną im. Zapisuje się jako parę z = (re, im). Ujemną wartość
delty można zapisać jako (-1)|delta| stąd
(-1)delta = (-1)Å" delta
oznaczajÄ…c jednostkÄ™ urojonÄ… literÄ… i (i = (-1) )to pierwiastki zespolone okre-
śla wzór
ëÅ‚ öÅ‚
delta
- b
ìÅ‚
z1,2 = , Ä… i÷Å‚ .
ìÅ‚ ÷Å‚
2a 2a
íÅ‚ Å‚Å‚
Interfejs
Opis obiektów
" dane: a, b, c  współczynniki równania - liczby rzeczywiste;
" wyniki: x1, x2, x0, z1, z2 - pierwiastki równania (w zależności od wartości wyróż-
nika);
" robocze: delta - wyróżnik.
7
Algorytm
PoczÄ…tek
1
Wprowadzanie
danych:
a, b, c
2
tak
a = 0
nie
3
delta = b2 - 4Å" a Å"c
5
4
nie tak
- b Ä… delta
delta > 0
x1,2 =
2a
6
7
tak
Wyprowadzenie
delta = 0
wyników:
x1, x2
nie
8
10
ëÅ‚ öÅ‚ - b
delta
- b
ìÅ‚
x0 =
z1,2 = , Ä… i÷Å‚
ìÅ‚ ÷Å‚
2a
2a 2a
íÅ‚ Å‚Å‚
11
9
Wyprowadzenie
Wyprowadzenie
wyników:
wyników:
x0
z1, z2
Koniec
Rysunek 4.2. Algorytm obliczania pierwiastków trójmianu kwadratowego
8
Program
/*T%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%W%
Q% PROGRAM: trójmian v1.0 Q%
Q% ZADANIE: obliczanie miejsc zerowych (pierwiastków) równania Q%
Q% kwadratowego f(x) = ax^2 + bx + c = 0 Q%
Q% wg postępowania: Q%
Q% 1) obliczenie wartości wyróżnika Q%
Q% delta = b^2 - 4ac Q%
Q% 2) jeżeli delta > 0 to: Q%
Q% x1 = (-b + sqrt(delta)/2a Q%
Q% x2 = (-b - sqrt(delta)/2a Q%
Q% 3) jeżeli delta = 0 to Q%
Q% x0 = -b/2a Q%
Q% w przeciwnym razie Q%
Q% z1 = [re1, im1] = [-b/2a, (sqrt(|delta|)/2a)i] Q%
Q% z2 = [re2, im2] = [-b/2a, (-sqrt(|delta|)/2a)i] Q%
Q% DANE: współczynniki: a, b, c - liczby rzeczywiste Q%
Q% WYNIKI: miejsca zerowe równania (x1, x2, x0, z1, z2) Q%
Q% AUTOR: ................... 2002.09.10 Q%
Q% PLIK: cw04.cpp Q%
Z%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%]%*/
#include
#include
#include
main()
{
float a,b,c; // współczynniki
float x0, x1,x2; // pierwiastki rzeczywiste
float re1, im1, re2, im2; // pierwiastki zespolone
double delta; // wyróżnik trójmianu
textbackground(LIGHTGRAY);
textcolor(WHITE);
clrscr();
textcolor(BLACK);
gotoxy(10,2);
cprintf("Pierwiastki trójmianu kwadratowego");
textcolor(WHITE);
gotoxy(5,4); // wprowadzenie współczynnika A
cprintf("Współczynnik A = ");
textbackground(BLACK);
gotoxy(25,4);
cprintf(" ");
gotoxy(26,4);
scanf("%f",&a);
if (a == 0.0)
{
textbackground(LIGHTGRAY);
textcolor(BLUE);
gotoxy(5,6);
cprintf("Niepoprawna wartość współczynnika A!!!");
gotoxy(10,14);
textcolor(GREEN);
cprintf(" Naciśnij klawisz ....");
getch();
return (-1);
}
textbackground(LIGHTGRAY);
gotoxy(5,6); // wprowadz. współczynnika B
cprintf("Współczynnik B = ");
textbackground(BLACK);
gotoxy(25,6);
9
cprintf(" ");
gotoxy(26,6);
scanf("%f",&b);
textbackground(LIGHTGRAY); // wprowadz. wyrazu wolnego C
gotoxy(5,8);
cprintf("Wyraz wolny C = ");
textbackground(BLACK);
gotoxy(25,8);
cprintf(" ");
gotoxy(26,8);
scanf("%f",&c);
delta = b * b - 4 * a * c; // obliczenie wyróżnika
textbackground(LIGHTGRAY);
gotoxy(10,11);
cprintf("***** Wyniki obliczeń *****");
gotoxy(5,13);
cprintf("delta = %10.3f", delta);
if (delta > 0.0)
{ // dwa pierwiastki rzeczywiste
x1 = (-b - sqrt(delta))/(2 * a);
x2 = (-b + sqrt(delta))/(2 * a);
gotoxy(5,15);
cprintf("x1 = %10.3f ",x1);
gotoxy(5,17);
cprintf("x2 = %10.3f ",x2);
}
else
if (delta == 0.0)
{ // pierwiastek podwójny
x0 = -b/(2 * a);
gotoxy(5,15);
cprintf("x0 = %10.3f ",x0);
}
else
{ // pierwiastki zespolone
delta = fabs(delta);
re1 = -b/(2 * a);
im1 = sqrt(delta)/(2 * a);
re2 = -b/(2 * a);
im2 = -sqrt(delta)/(2 * a);
gotoxy(5,15);
cprintf("z1 = (%f, %fi)",re1, im1);
gotoxy(5,17);
cprintf("z2 = (%f, %fi)",re2, im2);
}
gotoxy(10,20);
textcolor(BLACK);
cprintf(" Naciśnij dowolny klawisz");
getch();
}
Przykład cw04a
Zaprojektować algorytm (rys. 4.3) oraz program obliczający (w zakresie czte-
rech podstawowych działań) wartość prostego wyrażenia algebraicznego. Składnia
wyrażenia jest następująca:
arg1 oper arg2
gdzie: arg1, arg2 - operandy - liczby rzeczywiste,
oper - jeden z operatorów dodawania, odejmowania, mnożenia, lub dzielenia
+ | - | * | /
10
W programie należy uwzględnić elementy kontroli poprawności danych.
Interfejs
Opis obiektów
" dane: arg1, arg2 - liczby rzeczywiste (argumenty operatorów algebraicznych),
oper - znaki: + | - | * | / (symbole operatorów algebraicznych);
" wyniki: wynik - rezultat obliczeń;
" robocze: dobrze - 1/0 wskaz
nik powodzenia / niepowodzenia operacji (usta-
wiany na zero jeżeli operator jest nieprawidłowy lub przy próbie dzielenia przez
zero).
Algorytm
PoczÄ…tek
1
dobrze = 1
2
Przygotowanie ekranu
3
Wyświetlenie opisu programu
4
Wyśw. napisu:"Wypisz wyrażenie"
5
Nadanie wartości
obiektom:
arg1, oper, arg2
a
Rysunek 4.3. Algorytm działania prostego kalkulatora (wersja a)
11
a
tak
6 7
oper = '+' wynik = arg1 + arg2
nie
tak
8 9
oper = '-' wynik = arg1 - arg2
nie
tak
10 11
oper = '*' wynik = arg1 * arg2
nie
tak tak
12 13
oper = '/' arg2 <> 0
nie nie
14
15
16
Komunikat: "Dzielenie
wynik = arg1 / arg2
Komunikat: "ZÅ‚y operator"
przez zero"
18
17
dobrze = 0
dobrze = 0
19
nie
dobrze = 1
tak
20
Wyświetlenie napisu "Wynik
obliczeń" oraz zawartości obiektu
wynik
21
Wstrzymanie realizacji programu
Koniec
Rysunek 4.3. Algorytm działania prostego kalkulatora (wersja a)
12
Program
/*T%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%W%
Q% PROGRAM: kalkulator v1a. Q%
Q% ZADANIE: obliczanie prostego wyrażenia arytmetycznego Q%
Q% wg zapisu: argument1 operator argument2 Q%
Q% DANE: arg1 - operand lewy,. Q%
Q% oper - algebraiczny: -|+|*|/ Q%
Q% arg2 - operand prawy. Q%
Q% WYNIKI: wartość wyrażenia. Q%
Q% AUTOR: .......................... 2002.09.10 Q%
Q% PLIK: cw04a.cpp Q%
Z%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%]%*/
#include
#include
#include
#include
# define CZAS 2
main()
{
char oper; // znak operatora algebraicznego
short dobrze = 1; // = 1 to obliczenia wykonane
float arg1,arg2,wynik;
clrscr();
gotoxy(20,4);
cprintf(" KALKULATOR");
gotoxy(20,6);
cprintf(" Oblicza wartość prostego wyrażenia algebraicznego");
gotoxy(20,7);
cprintf(" postaci: e1 oper e2 (np. 3+2)");
gotoxy(20,8);
cprintf(" gdzie: e1, e2 - liczby; oper + | - | * | / ");
gotoxy(25,12);
printf("Napisz wyrażenie: ");
scanf("%f%c%f",&arg1,&oper,&arg2);
gotoxy(25,14);
if (oper == '+')
wynik = arg1 + arg2;
else
if (oper == '-')
wynik = arg1 - arg2;
else
if (oper == '*')
wynik = arg1 * arg2;
else
if (oper == '/')
if (arg2 != 0)
wynik = arg1 / arg2;
else
{
printf("Dzielenie przez zero jest niewykonalne! ");
sleep(CZAS);
dobrze = 0;
}
else
{
printf("Operator \"%c\" nie został rozpoznany", oper);
sleep(CZAS);
dobrze = 0;
}
if (dobrze)
printf("Wynik obliczeń: %10.3f",wynik);
13
gotoxy(10,22);
cprintf("Naciśnij dowolny klawisz");
getch();
}
Przykład cw04b
Zaprojektować algorytm (rys. 4.4) oraz program obliczający (w zakresie czte-
rech podstawowych działań) wartość prostego wyrażenia algebraicznego. Składnia
wyrażenia jest następująca:
arg1 oper arg2
gdzie: arg1, arg2 - operandy - liczby rzeczywiste,
oper - jeden z operatorów dodawania, odejmowania, mnożenia, dzielenia
+ | - | * | /
Algorytm
PoczÄ…tek
1
dobrze = 1
2
Przygotowanie ekranu
3
Wyświetlenie tabelki z metryką
programu
4
Wyśw. napisu:"Wypisz wyrażenie"
5
Nadanie wartości
obiektom:
arg1, oper, arg2
7
6
wynik = arg1 + arg2
'+'
8
'-' wynik = arg1 - arg2
o
9
p
'*'
wynik = arg1 * arg2
e =
r
'/'
w pozostałych
przypadkach
nie
a c b
Rysunek 4.4. Algorytm działania prostego kalkulatora (wersja b)
14
c b
a
10
tak
arg2 <> 0
nie
11
12
Komunikat: "Dzielenie
14
wynik = arg1 / arg2
przez zero"
Komunikat: "ZÅ‚y operator"
13
dobrze = 0
15
dobrze = 0
16
nie
dobrze = 1
tak
17
Wyśw. napisu "Wynik obliczeń"
Wyśw. zawartości obiektu wynik
18
Wstrzymanie realizacji programu
Koniec
Rysunek 4.5. Algorytm działania prostego kalkulatora (wersja b)
Program
/*T%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%W%
Q% PROGRAM: kalkulator v1b. Q%
Q% ZADANIE: obliczanie prostego wyrażenia arytmetycznego Q%
Q% wg zapisu: argument1 operator argument2 Q%
Q% DANE: arg1 - operand lewy,. Q%
Q% oper - algebraiczny: -|+|*|/ Q%
Q% arg2 - operand prawy. Q%
Q% WYNIKI: wartość wyrażenia. Q%
Q% AUTOR: .......................... 2002.09.10 Q%
Q% PLIK: cw04b.cpp Q%
Z%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%]%*/
#include
#include
#include
15
#include
# define CZAS 2
main()
{
char oper; // znak operatora algebraicznego
short dobrze = 1; // = 1 to obliczenia wykonane
float arg1,arg2,wynik;
clrscr();
gotoxy(20,4);
cprintf(" KALKULATOR");
gotoxy(20,6);
cprintf(" Oblicza wartość prostego wyrażenia algebraicznego");
gotoxy(20,7);
cprintf(" postaci: e1 oper e2" (np. 2+3));
gotoxy(20,8);
cprintf(" gdzie: e1, e2 - liczby; oper + | - | * | / ");
gotoxy(25,12);
printf("Napisz wyrażenie: ");
scanf("%f%c%f",&arg1,&oper,&arg2);
gotoxy(25,14);
switch(oper)
{
case '+' : wynik = arg1 + arg2;
break;
case '-' : wynik = arg1 - arg2;
break;
case '*' : wynik = arg1 * arg2;
break;
case '/' : if (arg2 != 0.0)
wynik = arg1 / arg2;
else
{
printf("Dzielenie przez zero jest niewykonalne! ");
sleep(CZAS);
dobrze = 0;
}
break;
default : printf("Operator \"%c\" nie został rozpoznany",oper);
sleep(CZAS);
dobrze = 0;
break;
}
if (dobrze)
printf("\Wynik obliczeń: %10.3f ",wynik);
gotoxy(10,22);
cprintf("Naciśnij dowolny klawisz");
getch();
}
Przykład cw04c
Zaprojektować algorytm (rys. 4.5) oraz program obliczania wartości x według
poniższego przepisu.
b < 0 x = -a - b;
Å„Å‚
a < 0 '"
òÅ‚b e" 0 x = -a + b - 2;
ół
b = 0 x = 0;
Å„Å‚
ôÅ‚
a e" 0 '"
òÅ‚b `" 0 x = a 5;
-
ôÅ‚
ół b
16
Algorytm
PoczÄ…tek
1
Nadanie wartości
obiektom: ,
a b
2
tak
a < 0
nie
tak
3
b < 0
6
tak
b `" 0
nie
nie
7 5
4
x = a/b - 5 x = -a+b - 2
x = -a - b
8
x = 0
Koniec
Rysunek 4.5. Algorytm wyliczania wartości wyrażenia
Opis obiektów
" dane: a, b - liczby rzeczywiste;
" wyniki: x - rezultat obliczeń.
Mapa śledzenia (dla wartości obiektów: a = -1, b = 2)
krok nr bloku a b x a < 0 b < 0
b `" 0
1 1 -1 2
2 2 tak
3 3 nie
4 5 1
Program
#include // obliczanie wartości wyrażenia
#include
main()
{
float a,b,x;
clrscr();
gotoxy(10,5);
cprintf("Śledzenie ścieżek przebiegowych";
gotoxy(15,9);
cprintf("Dla: ");
cprintf("a = ");
scanf("%f",&a);
17
gotoxy(20,10);
cprintf("b = ");
scanf("%f",&b);
gotoxy(15,13);
if ( a < 0 )
if ( b < 0 )
{
x = -a - b;
cprintf("Ścieżka: T-T x = -a - b ");
}
else
{
x = -a + b - 2;
cprintf("Ścieżka: T-N x = -a + b - 2 ");
}
else
if ( b != 0 )
{
x = a/b - 5;
cprintf("Ścieżka: N-T x = a/b - 5 ");
}
else
{
x = 0;
cprintf("Ścieżka: N-N x = 0 ");
}
printf("%5.1f ",x);
gotoxy(10,22);
cprintf("Naciśnij dowolny klawisz");
getch();
}
Przykład cw04d
Zaprojektować algorytm (rys. 4.6) oraz program obliczania wartości wyrażenia a
według poniższego przepisu.
Jeżeli:
1) y < 0 i z > 0 i x `" 0 to a = (y + 2)/x;
2) y e" 0 to a = 1;
3) w pozostałych przypadkach a = 0;
Opis obiektów
" dane: x, y, z - liczby rzeczywiste;
" wyniki: a - rezultat obliczeń.
Mapa śledzenia (dla wartości obiektów: x = -1, y = -8, z= 3)
krok nr blo- x y z a y < 0 z > 0
x `" 0
ku
1 1 -1 -8 3
2 2 0
3 3 tak
4 4 tak
5 5 tak
6 6 6
18
Algorytm
PoczÄ…tek
1
Nadanie wartości
obiektom: x, y, z
2
a = 0
3
tak
y< 0
nie 5
tak
z > 0
nie tak
7 5
a = 1.0
x `" 0
nie
6
a = (y+2)/x
Koniec
Rysunek 4.6. Algorytm wyliczania wartości wyrażenia
Program
#include
#include
main()
{
float x,y,z,a = 0.0;
clrscr();
gotoxy(10,5);
cprintf("Śledzenie ścieżek przebiegowych");
gotoxy(15,9);
cprintf("Dla: ");
cprintf("y = ");
scanf("%f",&y);
gotoxy(20,10);
cprintf("z = ");
scanf("%f",&z);
gotoxy(20,11);
cprintf("x = ");
scanf("%f",&x);
gotoxy(15,14);
if ( y < 0 )
if ( z > 0 )
if ( x != 0 )
{
a = (y + 2)/x;
cprintf("Ścieżka: T-T-T [ a = (y + 2)/x ] ; ");
}
else
cprintf("Ścieżka: T-T-N ");
19
else
cprintf("Ścieżka: T-N ");
else
{
a = 1.0;
cprintf("Ścieżka: N [ a = 1.0 ] ; ");
}
printf("a = %5.1f ",a);
gotoxy(10,22);
cprintf("Naciśnij dowolny klawisz");
getch();
}
Przykład cw04e
Zaprojektować algorytm (rys. 4.7) oraz program identyfikujący znak alfanume-
ryczny (znak wprowadzony jako dana).
znak " {A, B, ..., Z} Ò! wynik = 1,
znak " {a, b, ..., z} Ò! wynik = 1,
znak " {0, 1, ..., 9} Ò! wynik = 1.
Algorytm
PoczÄ…tek
1
Nadanie wartości
obiektowi zn
2
wynik = 0
3
tak
zn >= 'A'
nie nie
4
tak 5
zn <= 'Z' wynik = 1
6
tak
zn >= 'a'
nie
nie
7
tak
8
zn <= 'z'
wynik = 1
9
tak
zn >= '0'
nie tak
10
11
nie
zn <= '9' wynik = 1
Koniec
Rysunek 4.7. Algorytm identyfikacji znaku alfanumerycznego
20
Opis obiektów
" dane: zn  kod znaku;
" wyniki: wynik - 0 / 1 (inny / alfanumeryczny).
Program
#include
#include
main()
{
char zn;
int wynik;
clrscr();
gotoxy(10,5);
cprintf("Klasyfikacja znaków ASCII");
gotoxy(15,9);
gotoxy(20,10);
wynik = 0;
printf("Wprowadz
znak: ");
scanf("%c",&zn);
gotoxy(20,12);
if( zn >= 'A' && zn <= 'Z' )
wynik = 1;
else
if( zn >= 'a' && zn <= 'z' )
wynik = 1;
else
if ( zn >= '0' && zn <= '9' )
wynik = 1;
if( wynik)
printf("Znak \"%c\" jest znakiem alfanumerycznym",zn);
else
printf("\"%c\" nie jest znakiem alfanumerycznym",zn);
gotoxy(10,22);
cprintf("Naciśnij dowolny klawisz");
getch();
}
Program
#include
#include
main()
{
char zn;
int wynik;
gotoxy(10,5);
cprintf("Klasyfikacja znaków ASCII");
gotoxy(15,9);
gotoxy(20,10);
wynik = 0;
printf("Wprowadz
znak: ");
scanf("%c",&zn);
gotoxy(20,12);
wynik = ((zn>='A'&&zn<='Z')||(zn>='a'&&zn<='z')||(zn>='0'&&zn<='9'))?1:0;
printf("\"%c\" %s jest znakiem alfanumerycznym",zn,(wynik ? "" : "nie"));
gotoxy(10,22);
cprintf("Naciśnij dowolny klawisz");
getch();
}
21
Przykład cw04f
Wykorzystując zasadę, że różnica pomiędzy kodem numerycznym ASCII litery
 małej" i odpowiadającej jej litery  dużej" jest stała zaprojektować algorytm (rys. 4.8)
oraz program zamieniający litery  duże" na  małe" oraz  małe" na  duże".
Algorytm
PoczÄ…tek
1
Nadanie wartości
obiektowi zn
2
RÓŻNICA = ('a' - 'A')
3
tak
zn >= 'A'
4 tak
nie nie 5
zn <= 'Z' zn = zn + RÓŻNICA
6
tak
zn >= 'a'
7
nie nie tak 8
zn <= 'z' zn = zn - RÓŻNICA
Koniec
Rysunek 4.8. Algorytm zamiany liter
Opis obiektów:
" dane: zn - kod znaku przed zamianÄ…;
" wyniki: zn - kod znaku po zamianie.
Program
#include
#include
#define ROZNICA ('a' - 'A') // 'a' - 'A' = 32
main() //zamiana liter A -> a lub a -> A
{
char zn;
clrscr();
gotoxy(30,5);
printf("Zamiana znaków");
gotoxy(20,10);
printf("Wprowadz
znak: ");
22
scanf("%c%*c",&zn);
gotoxy(20,10);
printf("Wprowadzony znak \"%c\"",zn);
gotoxy(20,12);
if ( zn >= 'A' && zn <= 'Z' )
zn = zn + ROZNICA;
else
if ( zn >= 'a' && zn <= 'z' )
zn = zn - ROZNICA;
printf("został zamieniony na \"%c\"",zn);
gotoxy(10,22);
cprintf("Naciśnij dowolny klawisz");
getch();
}
Ćwiczenia
1. Instrukcję warunkową rozpoczyna słowo: a) for, b) float c) if.
2. Instrukcję wyboru rozpoczyna słowo: a) switch, b) for c) do.
3. Zdefiniowano zmienne: int a = 10, p; po wykonaniu instrukcji
p = ((2+a) != 12) zmienna p zawierać będzie wartość: a) 0, b) 1, c) 2.
4. Zdefiniowano zmienne: int a = 10, p; po wykonaniu instrukcji
p = ((2+a) == 12) zmienna p zawierać będzie wartość: a) 0, b) 1, c) 2.
5. Zdefiniowano zmienne: int p = 1, c = 19567, b = 16789, d = 3282, q = 7; po wy-
konaniu instrukcji q = (!p)&&((c-b) <=d); zmienna q zawierać będzie wartość:
a) 0, b) 1, c) 7.
6. Zdefiniowano zmienne: int p = 1, c = 19567, b = 16789, d = 3282, q = 7; po wy-
konaniu instrukcji q = p||((c-b/3.14) <=d); zmienna q zawierać będzie wartość:
a) 0, b) 1, c) 7.
7. Zdefiniowano zmienne: int c = 1, p, r = 3, z = 3; po wykonaniu instrukcji
z = (c!=10) ? 1 : 7; zmienna z zawierać będzie wartość: a) 7, b) 1, c) 3.
8. Zdefiniowano zmienne: int a = 10, p, r = 3, c = 1; po wykonaniu instrukcji
z = (c) ? a = r : p = 7; zmienna z zawierać będzie wartość: a) 10, b) 1, c) 3.
9. Poniższe algorytmy zapisz instrukcjami języka C.
PoczÄ…tek
PoczÄ…tek
1 1
tak
a = 0
a < 0
nie
2
tak
2
tak
b < 0
7
y< 0
x = 0 nie
nie
4
tak
z > 0 3
nie
4
x = -a - b
7
nie 6
tak x = -a + b - 2
4
tak
a = 1.0
b `" 0
x `" 0
6
nie 5
a = x/(z+2) 5
nie
x = a / b - 5
a = (y+2)/x
Koniec Koniec
23