Podstawy Informatyki
Instrukcje warunkowe i pętle
w języku C i C++
mgr inż. Piotr Kaczmarek
Podstawy Informatyki
Instrukcje warunkowe i pętle
w języku C i C++
mgr inż. Piotr Kaczmarek
Inkrementacja, przypisanie
●
pre- i post- inkrementacja
int liczba=1;
cout<<i++; //wyświetli: 1 (i jest zwiększane na
końcu wykonywania wyrażenia)
natomiast:
int liczba=1;
cout<<++i; //wyświetli: 2 (i jest zwiększane na
początku wykonywania wyrażenia)
analogicznie: i--; --i;
●
operatory +=,-=,*=, /=
liczba +=2; jest to samo co liczba = liczba+2;
liczba -=2; jest to samo co liczba = liczba-2;
liczba *=2; jest to samo co liczba = liczba*2;
Tablice
●
Tablice służą do przechowywania wielu
elementów tego samego typu. (np
wyników pomiaru itp)
●
Tablica jest zmienną przypominającą
wektor
●
Definicja tablicy:
typ nazwa_tablicy[ilosc_elementow];
np:
int tablica_calkowite[100];
double tablica_zmiennoprzcinkowe[30];
Operacje na tablicach
●
Tablica umożliwia dostęp do swoich elementów
za pomocą operatora [index], gdzie index jest
numerem porządkowym elementu
●
Index pierwszego elementu wynosi 0
●
Index ostatniego elementu N-elementowej
tablicy wynosi N-1.
np
int tab[12];
tab[0]=5;//pierwszy element tablicy
tab[1]=tab[0]+2;
...
tab[11]=tab[10]+2;//ostatni element tablicy
cout<<”trzeci element tablicy:”<<tab[2];
0
1
2
3
4
5
6
7
8
9 10 11
Nr
elementu
Wartość
5
7
9 11 13 15 17 19 21 23 25 27
Operatory logiczne
●
Operatory logiczne tym różnią się od operatorów
arytmetycznych, że jako wynik operacji otrzymujemy 2
wartości 'prawda' lub 'fałsz'
●
Do operatorów zalicza się:
–
operatory dwuargumentowe:
●
==
- czy równy
●
<=,>= - czy mniejszy-, większy-równy
●
<,>
- czy mniejszy, większy
●
!=
- czy różny
–
Operatory sumy i iloczynu
●
|| - suma logiczna
●
&& - iloczyn logiczny
–
Operatory jednoargumentowe
●
! - negacja (nie prawda że)
Operacje logiczne
●
W języku C fałsz oznaczany jest przez 0, natomiast
prawda przez 1.
●
Operacje logiczne mogą być realizowane na liczbach typu
całkowitego lub zmiennoprzecinkowego, oraz na
zmiennych tych typów
Wyrażenie:
(6 <= 6) && (5 < 3)
(6 <= 6) || (5 < 3)
(5 != 6)
(5 < 3) && (6 <= 6) || (5 != 6)
(5 < 3) && ((6 <= 6) || (5 != 6))
!((5 < 3) && ((6 <= 6) || (5 != 6)))
Wynik:
false (0)
true (1)
true (1)
true (1)
false (0)
true (1)
Operacje logiczne a
operacje arytmetyczne
●
Operacja logiczna może być rozpatrywana jako
dwuwartościowa operacja arytmetyczna przekazująca
wynik całkowity 0 lub 1
np.:
int a=3;
int b=a>2;
//zmienna b ma wartość 1;
int c=(a==3)*5; //zmienna c ma wartość 5;
●
Analogiczne wartość całkowita różna od 0 traktowana jest
jako logiczna wartość 'prawda'
Instrukcje warunkowe
rozgałęzienie programu
if(warunek)
//program
if(warunek)
{
//sekcja wykonywana
gdy warunek jest
prawdziwy
}
else
{
//sekcja wykonywana
gdy warunek jest
fałszywy
}
//Dalszy ciąg programu
Sekcja program,
wykonywana gdy
prawda
prawda
Sekcja program,
wykonywana gdy
fałsz
fałsz
Dalszy ciąg programu
Instrukcje warunkowe
przykłady (1)
int a;
cout<<”podaj liczbę 0-100”;
cin>>a;
if(a<0)
{
cout <<”liczba za mala”;
return -1; //wyjscie
}
else
{
if(a<=100)
cout<<”liczba ok”;
else
{
cout<<”liczba za
duza”; return -2;
}
}
//Dalszy ciąg programu
int a;
cout<<”podaj liczbę 0-100”;
cin>>a;
if(a<0||a>100)
{
cout <<”liczba spoza
zakresu”;
return -1; //blad!!
wyjscie
}
else
cout<<”liczba ok”;
//Dalszy ciąg programu
alternatywny zapis warunku:
a<0||a>100
ma postać:
!((a>=0)&&(a<=100))
(na podstawie prawa de Morgana)
Instrukcje warunkowe
przykłady (2)
int a;
cout<<”podaj liczbę
parzystą”;
cin>>a;
if(a%2==1)
{
cout <<”błąd liczba
nieparzysta”;
return -1; //wyjscie
}
//Dalszy ciąg programu
int a;
cout<<”podaj liczbę
parzystą”;
cin>>a;
if(a%2) //krotszy zapis
{
cout <<”błąd liczba
nieparzysta”;
return -1; //wyjscie
}
//Dalszy ciąg programu
Operacja % - modulo – reszta z dzielenia
1%2 ----> 1 (prawda)
2%2 ----> 0 (fałsz)
3%2 ----> 1 (prawda)
4%2 ----> 0 (fałsz)
5%3-----> 2 (prawda)
Instrukcje warunkowe
przykłady (3)
char klawisz;
cout<<”czy chcesz przerwac (t/n)”;
klawisz=_getch();
if(klawisz=='t'||klawisz=='T')
{
cout <<”Zakonczono”<<endl;
return -1; //wyjscie
}
//Dalszy ciąg programu
zmienna klawisz zawiera nr znaku w tablicy ASCII
stąd warunek może również mieć postać:
if(klawisz==0x55||klawisz==0x74)
{
...
}
Warunki złożone
wielokrotne rozgałęzienie
if(a=={wart1, wart2,wart3})
sekcja3
a==wart3
a==wart1
Dalszy ciąg programu
a==wart2
sekcja2
sekcja1
if(a==wart1)
{
//sekcja 1
}
else if(a==wart2)
{
//sekcja 2
}
else if(a==wart3)
{
//sekcja 3
}
else
{
//sekcja 4
}
//Dalszy ciąg programu
sekcja4
a!=wart{1,2,3)
Warunki złożone
switch... case
if(a=={wart1, wart2,wart3})
sekcja3
a==wart3
a==wart1
Dalszy ciąg programu
a==wart2
sekcja2
sekcja1
switch(a)
{
case wart1: {
//sekcja 1
break;
}
case wart2: {
//sekcja 2
break;
}
case wart3: {
//sekcja 3
break;
}
default:{
//sekcja4
}
}
//Dalszy ciąg programu
sekcja4
a!=wart{1,2,3)
Warunki złożone
switch... case
●
wart1,wart2,wart3 oznaczają
możliwe wartości zmiennej a
●
program sprawdza, czy zmienna
przyjmuje którąś z tych wartości,
jeśli tak, wykonywana jest
pierwsza i następne linie za 'case
wartn:'
●
gdy program napotka instrukcję
break, następuje wyjście do
sekcji 'Dalszy ciąg programu'
●
gdy instrukcja break nie zostanie
umieszczona program będzie
wykonywany linia po linii
●
jeśli wartość zmiennej jest różna
od listy wartości, wykonywana
jest sekcja default:
switch(a)
{
case wart1: {
//sekcja 1
break;
}
case wart2: {
//sekcja 2
break;
}
case wart3: {
//sekcja 3
break;
}
default:{
//sekcja4
}
}
//Dalszy ciąg programu
switch... case
Przykłady (1)
cout<<”MENU:”<<endl;
cout<<”1 – zrob cos\n2- zrob cos innego\n x- wyjscie”;
char a=_getch();
switch(a)
{
case '1': {
//zrob cos
break;
}
case '2': {
//zrob cos innego
break;
}
case 'x': case 'X':
{
return 0;
}
}
//Dalszy ciąg programu
switch... case
Przykłady (2)
cout<<”MENU:”<<endl;
cout<<”1 – zrob cos\n2- zrob cos innego\n 3- wyjscie”;
int liczba;
cin>>liczba;
switch(liczba)
{
case 1: {
//zrob cos
break;
}
case 2: {
//zrob cos innego
break;
}
case 3: {
return 0;
}
}
//Dalszy ciąg programu
Alternatywny zapis
instrukcji warunkowych
if(znak=='t')
a*=3;
else
a*=2;
//Dalszy ciąg programu
cout<<”wprowadz liczbe”;
int a;
scanf(„%d”,&a);
printf(„czy chcesz ja pomnozyc *3? (t/n) w innym
przypdku liczba bedzie pomnozona przez 2”);
char znak=getchar();
printf(''liczba wynosi: %d'',a);
a*=(znak=='t')?3:2;
//Dalszy ciąg programu
(warunek) ? wart_prawda : wart_fałsz;
Pętla for
●
Pętla służy do wielokrotnego
wykonania pewnego
fragmentu kodu
●
pętla typu for wykonywana
jest aż warunek_powtórzenia
jest nieprawdziwy
●
kod w polu inicjacji
wykonywany jest raz
●
kod w polu aktualizacja
wykonywany jest na końcu
przy każdym obrocie pętli
for (inicjacja; warunek_powtórzenia ; aktualizacja)
{
//kod sekcja pętli
}
//dalszy ciąg programu
Inicjacja
warunek_powtórzenia
dalszy ciąg programu
fałsz
kod sekcji
pętli
prawda
aktualizacja
Pętla for
for(int i=1; i<7; i++)
{
cout<<i<<”, ”;
}
wyświetli na ekranie:
1, 2, 3, 4, 5, 6,
for(int i=1; i<7; i+=2)
{
cout<<i<<”, ”;
}
wyświetli na ekranie:
1, 3, 5,
Inicjacja
warunek_powtórzenia
dalszy ciąg programu
fałsz
kod sekcji
pętli
prawda
aktualizacja
for (inicjacja; warunek_powtórzenia ; aktualizacja)
{
//kod sekcja pętli
}
//dalszy ciąg programu
Pętla while
int i=1
while(i<7)
{
cout<<i<<”, ”;
i++;
}
jest tym samym co wywołanie:
for(int i=1; i<7; i++)
{
cout<<i<<”, ”;
}
i wyświetli na ekranie:
1, 2, 3, 4, 5, 6,
warunek_powtórzenia
dalszy ciąg programu
fałsz
kod sekcji
pętli
prawda
while
(warunek_powtórzenia)
{
//kod sekcja pętli
}
//dalszy ciąg programu
Pętla do.. while
int i=1
do
{
cout<<i<<”, ”;
i++;
}while(i<7);
jest tym samym co wywołanie:
for(int i=1; i<7; i++)
{
cout<<i<<”, ”;
}
i wyświetli na ekranie:
1, 2, 3, 4, 5, 6,
warunek_powtórzenia
dalszy ciąg programu
fałsz
kod sekcji
pętli
prawda
do
{
//kod sekcja pętli
}while (warunek_powtórzenia);
//dalszy ciąg programu
Różnice pomiędzy
for,while, do.. while
int i=1
int d;
do
{
cout<<i<<”, ”;
i++;
}while(i<d);
for(int i=1; i<d; i++)
{
cout<<i<<”, ”;
}
●
każdą pętlę typu for
można zapisać w
formie pętli while
●
Pętla do..while różni
się od pozostałych,
ponieważ zawsze
wykonywana jest
przynajmniej raz
gdy d<=i np d=1 to pętla
do while wyświetli:
1,
natomiast for nie wyświetli niczego.
Gdy d>1 obie pętle będą działać tak samo
Pętle nieskończone
for(;;)
{
//kod wykonywany bez końca
}
while(1)
{
//kod wykonywany bez końca
}
Pętle: break, continue
●
Umieszczenie w pętli instrukcji break powoduje
wyjście z pętli i przetwarzanie dalszej części
programu
●
Umieszczenie w pętli instrukcji continue, powoduje
skok do końca pętli i realizację kolejnego cyklu
int i, l;
for (;;)
{
printf(''wprowadz liczbe'');
scanf("%d", &l);
if (l < 0)
{
printf(''blad - sproboj jeszcze raz'');
continue;
}
printf("%d! = %d\n", l, silnia(l));
}
int i, l;
for (;;)
{
printf(''wprowadz liczbe'');
scanf("%d", &l);
if (l < 0)
{
printf(''blad - wyjscie'');
break;
}
printf("%d! = %d\n", l, silnia(l));
}
\\dalszy ciag
Pętle i instrukcje
warunkowe - przykłady
●
Wyświetlanie wszystkich liczb z zakresu 100 do 0 bez liczb
podzielnych przez 3 i 5
for(int i=100; i>=0;i--)
{
if((i%3)&&(i%5))
cout<<i<<endl;
}
spowoduje wyświetlenie
100
98
97
94
92
91
...
2
1
Pętle i instrukcje
warunkowe - przykłady
●
Obsługa tablic:
float tab[10];
//wczytanie danych
for(int i=0; i<10;i++)
{
cout<<”Podaj element nr”<<i <<”: '';
scanf(''%f”,&tab[i]);
}
//suma wszystkich elementów
float suma=0;
for(int i=0;i<10;i++) suma+=tab[i];
//wyswietlenie wszystkich elementów
for(int i=0;i<10;i++) printf(''element nr %d:
%f\n”,i,tab[i]);
//wyswietlenie sredniej
cout<<”srednia elementów wynosi”<<suma/10<<endl;
Pętle i instrukcje
warunkowe - przykłady
●
Silnia
Pobierz wartość N
Wynik=1
i=1
N>=0
koniec
NIE
N>0
Wynik=1
NIE
TAK
TAK
i<=N
TAK
Wyświetl Wynik
NIE
Wynik=Wynik*i;
i++;
Stwórz opis słowny tego co widać
5!=1*2*3*4*5
1: Wynik*=1; //(1)
2: Wynik*=2; //(2)
3: Wynik*=3; //(6)
4: Wynik*=4; //(24)
5: Wynik*=5; //(120)
Pętle i instrukcje
warunkowe - przykłady
●
NWD (algorytm Euklidesa)
1. Mamy dwie liczby u i v
2. Jeżeli liczby są równe to NWD(u, v) = u
3a. Jeżeli u > v to u = u - v i idziemy do
punktu 2.
3b. Jeżeli u < v to v = v - u i idziemy do
punktu 2.
●
NWW
NWW=u*v/NWD(u,v)
Stwórz opis graficzny
dla algorytmu Euklidesa
Sortowanie
bąbelkowe
|4|2|5|1|7| -> |2|4|5|1|7| -> |2|4|5|1|7| -> |2|4|1|5|7|
^-^ ^-^ ^-^ ^-^
|2|4|1|5|7| -> |2|4|1|5|7| -> |2|1|4|5|7|
^-^ ^-^ ^-^
|2|1|4|5|7| -> |1|2|4|5|7| ->
^-^ ^-^
|1|2|4|5|7| ->
^-^
Inne algorytmy sortowania:
- bąbelkowy (bubble sort)
- przez wstawianie (insertion sort)
- szybki (quick sort)
- kopcowy (heap sort)
- Shella (shellsort)
Sortowanie bąbelkowe
double tab[5]={4,2,5,1,7};
int rozmiar=5;
double b;
bool przestawiono=true;
while(przestawiono)
{
przestawiono = false;
for(int a=0; a<rozmiar-1;
a++)
{
if(tab[a]>tab[a+1])
{
b=tab[a];
tab[a]=tab[a+1];
tab[a+1]=b;
przestawiono = true;
}
}
}}
Sortowanie przez
wstawianie
●
Jest dwukrotnie szybsze niż sortowanie bąbelkowe
●
Algorytm:
1. Utwórz zbiór elementów posortowanych i przenieś do niego
dowolny element ze zbioru nieposortowanego.
2. Weź dowolny element ze zbioru nieposortowanego.
3. Wyciągnięty element porównuj z kolejnymi elementami
zbioru posortowanego póki nie napotkasz elementu
równego lub elementu większego (jeśli chcemy otrzymać
ciąg niemalejący) lub nie znajdziemy się na początku/końcu
zbioru uporządkowanego.
4. Wyciągnięty element wstaw
w miejsce gdzie skończyłeś
porównywać.
5. Jeśli zbiór elementów
nieuporządkowanych jest
niepusty wróć do punkt 2.
5
7
0
3
4
2
6
1
(0)
5
7
0
3
4
2
6
1
(0)
0
5
7
3
4
2
6
1
(2)
0
3
5
7
4
2
6
1
(2)
0
3
4
5
7
2
6
1
(2)
0
2
3
4
5
7
6
1
(4)
0
2
3
4
5
6
7
1
(1)
0
1
2
3
4
5
6
7
(6)
Zasięg widoczności
zmiennych
●
Zmienna zadeklarowana
w danym miejscu,
istnieje aż do znaku '}'
zamykającego poziom
programu na którym
została zadeklarowana
●
Poza tym poziomem i
poziomami
wewnętrznymi jej nazwa
nie jest rozpoznawana,
●
Poza tym poziomem
można zadeklarować
zmienną o tej samej
nazwie, ale będzie to
inna zmienna.
double tab[5]={4,2,5,1,7};
int rozmiar=5;
bool przestawiono=true;
while(przestawiono)
{
przestawiono = false;
for(int a=0; a<rozmiar-1;a++)
{
if(tab[a]>tab[a+1])
{
double b;
b=tab[a];
tab[a]=tab[a+1];
tab[a+1]=b;
przestawiono = true;
}
}
}
}