Podstawy Informatyki

Instrukcje warunkowe i pętle

w języku C i C++

mgr inż. Piotr Kaczmarek

[e-mail]

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;

}

}

}

}