Содержание

Слайд 2

Cel

Zilustrować sposób postępowania przy układaniu (projektowaniu) algorytmu.

Cel Zilustrować sposób postępowania przy układaniu (projektowaniu) algorytmu.

Слайд 3

Przykład algorytmizacji zadania (metoda intuicyjna)

Zadanie:
Dane są liczby całkowite a i b.

Przykład algorytmizacji zadania (metoda intuicyjna) Zadanie: Dane są liczby całkowite a i
Znajdź ich największy wspólny podzielnik.
Przykład
NWD(21,7)=7
NWD(16,6)=2

Слайд 4

Przykład

Krok I (trywialny) – sformułowanie problemu:
Co jest dane?
Odp. Dane są

Przykład Krok I (trywialny) – sformułowanie problemu: Co jest dane? Odp. Dane
dwie liczby. W razie potrzeby możemy je oznaczyć jako a i b (co nam to daje?).
Co to jest największy wspólny podzielnik.
Odp. Jest to największa liczba całkowita, przez którą dzielą się bez reszty obydwie liczby. NWD zawsze istnieje (liczba 1).

Слайд 5

Przykład - Ogólne sformułowanie problemu znalezienia NWD

Graficznie można problem przedstawić następująco:

P

Znajdź NWD

Przykład - Ogólne sformułowanie problemu znalezienia NWD Graficznie można problem przedstawić następująco:
dwu nieujemnych liczb

K

Слайд 6

Przykład - Dokładniejsze (graficzne) sformułowanie problemu znalezienia NWD

P

Podajemy a,b

K

Znajdź NWD(a,b)

Wypisz NWD(a,b)

Przykład - Dokładniejsze (graficzne) sformułowanie problemu znalezienia NWD P Podajemy a,b K Znajdź NWD(a,b) Wypisz NWD(a,b)

Слайд 7

Przykład - poszukiwania

Krok II (najtrudniejszy): Jak obliczyć NWD.
Pomysły luźne (burza mózgów)

Przykład - poszukiwania Krok II (najtrudniejszy): Jak obliczyć NWD. Pomysły luźne (burza
- Pomysły mogą być różne, np. obydwie liczby dzielimy przez liczby od 1 do a i od 1 do b. Badamy, czy liczby, przez które dzielimy dzielą obydwie liczby bez reszty, jeśli tak to zapisujemy na „boku” ich wartość, a potem znajdujemy maksymalną liczbę – sposób kosztowny.
Poprawę efektywności można uzyskać zauważając, że wystarczy znaleźć minimalną liczbę z a i b i dzielić przez wszystkie liczby do tej liczby (oczywiste, bo nie jest możliwe by była liczba całkowita np. dla a/(a+1)).
Te rozważania pozwalają nam zapoznać się z problemem ale nie jest to systematyczna metoda (o takie metody jest jednak trudno, można mówić jedynie o metodach dla pewnych klas zadań).

Слайд 8

Przykład - studia

Pomysł bardziej systematyczny: Najlepsze metody uzyskuje się korzystając z własności

Przykład - studia Pomysł bardziej systematyczny: Najlepsze metody uzyskuje się korzystając z
tego co chcemy policzyć. Zauważmy, że można pominąć liczby ujemne, bo
nwd(-a,b)=nwd(a,b), dla a,b>0
jest to oczywiste i wynika z definicji nwd.
Dalej, można zauważyć, że
nwd(a,0)=a,
jak również, że
nwd(a,b)=nwd(b,a)
co jest też oczywiste.

Слайд 9

Przykład - wnioski

Gdyby więc udało się nam zmniejszać liczby, dla których szukamy

Przykład - wnioski Gdyby więc udało się nam zmniejszać liczby, dla których
nwd tak, by nie zmieniła się liczba NWD to w końcu doprowadzilibyśmy do sytuacji, że szukalibyśmy NWD(a’,0) lub NWD(0,b’). Intuicyjny algorytm można więc zapisać następująco:
(1) Pod x podstaw a a pod y podstaw b,
(2) Jeśli y<>0 to
zmniejsz y i zmień x w ten sposób, by obie liczby pozostały >= 0 i by wartość NWD nie zmieniła się,
powtórz krok (2),
(3) jeśli y=0 to NWD(x,0)=x.

Слайд 10

Przykład - graficznie

y<>0

Zamień x i zmniejsz y by NWD(x,y) nie zmienił się

NWD(x,y)=NWD(x,0)=x

N

T

Przykład - graficznie y 0 Zamień x i zmniejsz y by NWD(x,y)

Слайд 11

Przykład

Wszystkie czynności poza krokiem (a) są proste. Ale zauważmy, że (to jest

Przykład Wszystkie czynności poza krokiem (a) są proste. Ale zauważmy, że (to
nasza wiedza, doświadczenie, intuicja,...), że
x=(x div y)*y+x mod y, (*)
gdzie x div y oznacza dzielenie całkowite, x mod y oznacza resztę z dzielenia (takie operatory występują w j.Pascal).
Np.
dla x=30 y=7 mamy:
30=(30 div 7)*7+30 mod 7=4*7+2=30
a dla x=7 i y=30 mamy
7=(7 div 30)*30+7 mod 30=0*30+7=7.
Z (*) mamy:
x mod y = x-(x div y)*y. (**)
Ten zapis oznacza, że jeśli NWD dzieli x i y to NWD dzieli (wynik będzie liczbą całkowitą) również x-(x div y)*y, bo
(x-(x div y)*y)/NWD=x/NWD-(x div y)*(y/NWD)
jest na pewno liczbą całkowitą. Zachodzi więc (na podstawie **):
NWD(x,y)=NWD(y,x mod y)

Слайд 12

Przykład – krok a

Otrzymaliśmy więc sposób na wykonanie kroku (a). Jest on

Przykład – krok a Otrzymaliśmy więc sposób na wykonanie kroku (a). Jest
postaci:
(a1) Pod r podstaw x mod y,
(a2) Pod x podstaw y,
(a3) Pod y podstaw r.

Слайд 13

Przykład – problem z mod

Jak obliczyć x mod y. Należy zauważyć, że

Przykład – problem z mod Jak obliczyć x mod y. Należy zauważyć,
gdybyśmy dysponowali umiejętnością obliczania x mod y to byłby to już koniec problemu. Tak nie jest, więc nowy problem to: obliczyć x mod y. Można zauważyć, że obliczanie x mod y jest równoważne znalezieniu takiego q i r, że zachodzi: x=q*y+r, gdzie wielkość r jest szukaną liczbą, ma ona następującą własność:
0<=rStąd mamy, że
r=x-q*y.
Tak więc należy od x odjąć r i sprawdzić, czy wynik spełnia warunek 0<=r(a11) Pod q podstaw 0,
(a12) Pod r podstaw x,
(a13) Sprawdź, czy 0<=r(a14) jeśli tak, to została znaleziona reszta,
(a15) jeśli nie, to
(a151) Pod r podstaw r-x,
(a152) Pod q podstaw 1+q
(a153) Wykonaj algorytm od kroku (a13).

Слайд 14

Przykład – graficznie obliczanie mod

Pod r podstaw x

Pod q podstaw 0

r>=y

N

Pod r

Przykład – graficznie obliczanie mod Pod r podstaw x Pod q podstaw
podstaw r-y

Pod q podstaw 1-q

T

{x>=0, y>0}

{x=q*y+r, r>=0}

{x=q*y+r, r>=0}

{x=q*y+r, y>r>=0}

Слайд 15

Przykład – zakończenie

Ponieważ wszystkie operacje są już wykonywane za pomocą elementarnych operacji

Przykład – zakończenie Ponieważ wszystkie operacje są już wykonywane za pomocą elementarnych
(każda maszyna cyfrowa powinna je mieć) to zadanie jest już rozwiązane.
Rozwiązanie należy zapisać w języku programowania. W tym momencie pojawia się problem, czy otrzymany program jest dobry.

Слайд 16

Inne zadanie – trochę inne spojrzenie na problemy algorytmiczne (mniej sformalizowane)
Dany jest

Inne zadanie – trochę inne spojrzenie na problemy algorytmiczne (mniej sformalizowane) Dany
ciąg n-elementowy liczb całkowitych. Napisz program znajdujący liczbę w tym ciągu o maksymalnej sumie cyfr.

Слайд 17

Szkic rozwiązania:

Wstępne rozważania:
Co mamy dane, co poszukujemy. Częsty błąd, to niezrozumienie jak

Szkic rozwiązania: Wstępne rozważania: Co mamy dane, co poszukujemy. Częsty błąd, to
wyglądają dane, np. można wpaść na „genialny” pomysł, że dane to „-23, 45, 33, -23, 321” - to jest tekst, który przetwarza się dużo trudniej, poza tym, nie musimy mieć od razu wszystkich danych, tylko mogą kolejno napływać (np. aplikacje sieciowe, internetowe, programowanie równoległe). Czym jest cyfra, to wiadomo (nie ma cyfr ujemnych!!!!!)
Wczytujemy n,
Ustawiamy wartości początkowe i, max – i oznacza którą liczbę przetwarzamy, max powinno być takie, by pierwsza liczba je poprawiła,
Dla kolejnych danych (jak to zapisać?) wykonujemy
Wczytujemy x, zapamiętujemy x, co z x ujemnymi ?– bo nie ma ujemnych cyfr,
Ustawiamy wartość początkową sumy dla wczytanej liczby,
Dopóki x jest różne od zera (dlaczego??)
„wyciągamy” cyfrę,
Zwiększamy sumę,
Odrzucamy wyciągnięta i dodaną cyfrę,
Poprawiamy max (jak?)
Wypisujemy max

Слайд 18

program

#include
#include
int main()
{
int i,n,x,max,y,xmax,s,c; //i - która liczba, max -

program #include #include int main() { int i,n,x,max,y,xmax,s,c; //i - która liczba,
maksimum, x liczba, c - wydobyta cyfra
cout<<"n=";
cin>>n;
max=-1; //moze by max=0, ale max=-1 lepsze, czemu?
i=1;
while (i<=n)
{
cout<<"x=";
cin>>x;
y=x; //zapamiętujemy x, bo pewnie może się zmieniac
if (x<0) x=-x; //rozwiązujemy problem z ujemnymi liczbami, pierwsza zmiana
s=0;
while (x!=0) // można while (x)
{
c=x%10; //wyciągamy cyfrę
s=s+c;
x=x/10; // można x/=10 odrzucamy dodaną cyfrę
}
if (s>max) //poprawiamy maksimum
{
max=s;
xmax=y;
}
i=i+1; //i++
}
cout<<"xmax="< getch();
return 0;
}

Zwracamy uwagę na komentarze, wcięcia itd..

Слайд 19

Wyniki przykładowego programu

Wyniki przykładowego programu

Слайд 20

Omówienie instrukcji

Omówienie instrukcji

Слайд 21

Lista instrukcji

Instrukcja pusta
Instrukcja przypisania
Instrukcja wywołania funkcji (procedury) – później,
Instrukcja złożona
Instrukcje warunkowe
if
if …

Lista instrukcji Instrukcja pusta Instrukcja przypisania Instrukcja wywołania funkcji (procedury) – później,
else
switch
Instrukcje pętli
for
while
do … while
Instrukcje skoku:
goto,
break,
continue.

Слайд 22

Instrukcja pusta

Najprostszą jest instrukcja pusta, będąca pustym ciągiem znaków, zakończonym średnikiem:
;

Instrukcja pusta Najprostszą jest instrukcja pusta, będąca pustym ciągiem znaków, zakończonym średnikiem:
//instrukcja pusta
Instrukcja pusta jest użyteczna w przypadkach gdy składnia wymaga obecności instrukcji, natomiast nie jest wymagane żadne działanie. Nadmiarowe instrukcje puste nie są traktowane przez kompilator jako błędy syntaktyczne, np. zapis
int i;
składa się z dwóch instrukcji: instrukcji deklaracji int i; oraz instrukcji pustej.
Jest przydatna także przy tworzeniu złożonych programów.
Przykłady:
i=0; while (i>=0); //petla nieskończona, to zły przykład
i=0; while (tablica[i++]>0); //praktyczny przykład, bardzo dobry przykład wykorzystania instrukcji pustej

Слайд 23

Instrukcja złożona

Instrukcją złożoną nazywa się sekwencję instrukcji ujętą w parę nawiasów klamrowych:
{
instrukcja-1;
instrukcja-2;
...
instrukcja-n;
}

Instrukcja złożona Instrukcją złożoną nazywa się sekwencję instrukcji ujętą w parę nawiasów

Слайд 24

Instrukcja złożona

W składni języka taka sekwencja jest traktowana jako jedna instrukcja. Instrukcje

Instrukcja złożona W składni języka taka sekwencja jest traktowana jako jedna instrukcja.
złożone mogą być zagnieżdżane, np.
{
instrukcja-1;
...
instrukcja-i;
{
instrukcja-j;
...
instrukcja-n;
}
}
Jeżeli pomiędzy nawiasami klamrowymi występują instrukcje deklaracji identyfikatorów (nazw), to taką instrukcję złożoną nazywamy blokiem. Każda nazwa zadeklarowana w bloku ma zasięg od punktu deklaracji do zamykającego blok nawiasu klamrowego. Jeżeli nadamy identyczną nazwę identyfikatorowi, który był już wcześniej zadeklarowany, to poprzednia deklaracja zostanie przesłonięta na czas wykonania danego bloku; po opuszczeniu bloku jej ważność zostanie przywrócona.

Слайд 25

Przykład

#include
#include
//-------------------------------------------------------------------------------------------------------
// Program ilustrujący wykorzystanie bloków i zakres działania zmiennych
//--------------------------------------------------------------------------------------------------------
int main()
{

Przykład #include #include //------------------------------------------------------------------------------------------------------- // Program ilustrujący wykorzystanie bloków i zakres działania
int k=0;
{
int i=1;
i=i+2;
{
int j=3;
j=i+3;
cout< cout< }
cout<// cout< }
cout<// cout<// cout< getch();
return 0;
}
//---------------------------------------------------------------------------

Слайд 26

Instrukcja przypisania

Dowolne wyrażenie zakończone średnikiem jest nazywane instrukcją wyrażeniową (ang. expression statement)

Instrukcja przypisania Dowolne wyrażenie zakończone średnikiem jest nazywane instrukcją wyrażeniową (ang. expression
lub krótko instrukcją. Większość używanych instrukcji stanowią instrukcje-wyrażenia.
Jedną z najprostszych jest instrukcja przypisania o postaci:
zmienna = wyrażenie;
gdzie symbol ”=” jest operatorem przypisania.
S

Слайд 27

Instrukcja przypisania

Przykłady instrukcji języka C++:
int liczba;
liczba = 2 + 3;
Pierwsza z nich

Instrukcja przypisania Przykłady instrukcji języka C++: int liczba; liczba = 2 +
jest instrukcją deklaracji; definiuje ona obszar pamięci związany ze zmienną liczba, w którym mogą być przechowywane wartości całkowite. Drugą jest instrukcja przypisania (można powiedzieć, że definiuje zmienną). Umieszcza ona wynik dodawania (wartość wyrażenia) dwóch liczb w obszarze pamięci przeznaczonym na zmienną liczba.
Można napisać krócej:
int liczba=2+3;
Przypisanie jest wyrażeniem, którego wartość jest równa wartości przypisywanej argumentowi z lewej strony operatora przypisania. Instrukcja przypisania powstaje przez dodanie średnika po zapisie przypisania.

Слайд 28

Przykłady instrukcji podstawienia

#include
#include
//------------------------------------------------------------------
// Program ilustrujący działanie instrukcji podstawienia
//------------------------------------------------------------------
int main()
{
int

Przykłady instrukcji podstawienia #include #include //------------------------------------------------------------------ // Program ilustrujący działanie instrukcji podstawienia
a, b=2, c=3, d=7, e=2, f=5;
cout < a = b + c;
cout < a = (b + c)/d;
cout < a = e > f;
cout < a = (e > f && c < d) + 1;
cout < a = a << 3;
cout < getch();
return 0;
}

Слайд 29

Przykład - nieczytelny (?)

Przykład:
a = (b = c + d)/(e = f

Przykład - nieczytelny (?) Przykład: a = (b = c + d)/(e
+ g);
jest raczej mało czytelny, równoważny jest sekwencji instrukcji przypisania
b = c + d;
e = f + g;
a = b/e;
Podobnie:
x1=(-b-sqrt(delta))/(2*a);
Można zapisac jako:
pom1=-b-sqrt(delta);pom2=2*a;
x1=pom1/pom2;
To lepszy sposób, niż stosowanie dużej ilości nawiasów.

Слайд 30

Instrukcje warunkowe

Instrukcje selekcji (wyboru) wykorzystuje się przy podejmowaniu decyzji.
Konieczność ich stosowania

Instrukcje warunkowe Instrukcje selekcji (wyboru) wykorzystuje się przy podejmowaniu decyzji. Konieczność ich
wynika stąd, że kodowane w języku programowania algorytmy tylko w bardzo prostych przypadkach są czysto sekwencyjne.
Najczęściej kolejne kroki algorytmu są zależne od spełnienia pewnego warunku lub kilku warunków. Typowe sytuacje - następny slajd.

Слайд 31

Instrukcje warunkowe

W sytuacji powyższej spełnienie testowanego warunku oznacza wykonanie sekwencji działań

Instrukcje warunkowe W sytuacji powyższej spełnienie testowanego warunku oznacza wykonanie sekwencji działań
S1; przy warunku niespełnionym wykonywana są działania S2 (S1 jest pomijane).
W sytuacji po prawej stronie pozytywny wynik testu oznacza wykonanie sekwencji działań S1, a wynik negatywny pomija te działania.

false

true

B

S1

S2

false

B

S

Слайд 32

Instrukcja if - składnia

Instrukcja if jest implementacją schematów podejmowania decyzji. Ogólny zapis

Instrukcja if - składnia Instrukcja if jest implementacją schematów podejmowania decyzji. Ogólny
jest następujący:
if (B) instrukcja1; else instrukcja2;
lub
if (B) instrukcja;
gdzie wyrażenie logiczne B musi wystąpić w nawiasach okrągłych.

Слайд 33

Instrukcja if – działanie (semantyka)

Wykonanie instrukcji if zaczyna się od obliczenia wartości

Instrukcja if – działanie (semantyka) Wykonanie instrukcji if zaczyna się od obliczenia
wyrażenia B.
Jeżeli wyrażenie ma wartość różną od zera (prawda!!!), to będzie wykonana instrukcja (lub instrukcja1); jeżeli wyrażenie ma wartość zero (fałsz!!!), to w pierwszym przypadku instrukcja jest wykonywana jest instrukcja2, a w drugim przypadku pomijana.
Każda z występujących instrukcji może być instrukcją prostą lub złożoną, bądź instrukcją pustą.

Слайд 34

Przydatna uwaga

Zapis
if(wyrażenie != 0)
Można zastąpić:
if(wyrażenie)
ponieważ test w nawiasach () ma wynik

Przydatna uwaga Zapis if(wyrażenie != 0) Można zastąpić: if(wyrażenie) ponieważ test w
będący wartością numeryczną (liczbową)

Слайд 35

Przykład 1 - najgorsze

#include
#include
//---------------------------------------------------------------------------
// Program ilustrujący działanie instrukcji if
// Wczytaj

Przykład 1 - najgorsze #include #include //--------------------------------------------------------------------------- // Program ilustrujący działanie instrukcji
trzy liczby, wypisz największą
//---------------------------------------------------------------------------
int main()
{
int a,b,c;
cin >>a;
cin>>b;
cin>>c;
if ((a>b) &&(a>c)) cout< if ((b>a) &&(b>c)) cout< if ((c>b) &&(c>a)) cout< getch();
return 0;
}
//---------------------------------------------------------------------------
//Uwaga: To jest złe rozwiązanie!!. Gdzie jest błąd?
//---------------------------------------------------------------------------

Слайд 36

Przykład 2 – lepsze rozwiązanie

#include
#include
//---------------------------------------------------------------------------
// Program ilustrujący działanie instrukcji if
//

Przykład 2 – lepsze rozwiązanie #include #include //--------------------------------------------------------------------------- // Program ilustrujący działanie
Wczytaj trzy liczby, wypisz największą
//---------------------------------------------------------------------------
int main()
{
int a,b,c;
cin >>a;
cin>>b;
cin>>c;
if ((a>b) && (a>c)) cout< else if ((b>a) && (b>c)) cout< cout< getch();
return 0;
}
//---------------------------------------------------------------------------
//Uwaga: To rozwiązanie nie ma błędu
//---------------------------------------------------------------------------

Слайд 37

Uproszczona postać instrukcji if

Niektóre proste konstrukcje if można z powodzeniem zastąpić wyrażeniem

Uproszczona postać instrukcji if Niektóre proste konstrukcje if można z powodzeniem zastąpić
warunkowym, wykorzystującym operator warunkowy "?:" . Np.
if (a > b)
max = a;
else
max = b;
można zastąpić przez
max = (a > b) ? a : b;
Nawiasy okrągłe nie są konieczne; dodano je dla lepszej czytelności.

Слайд 38

Przykład

#include
#include
//---------------------------------------------------------------------------
// Program ilustrujący działanie instrukcji if
// Wczytaj trzy liczby, wypisz

Przykład #include #include //--------------------------------------------------------------------------- // Program ilustrujący działanie instrukcji if // Wczytaj
największą
//---------------------------------------------------------------------------
int main()
{
int a,b,c;
cin >>a;
cin>>b;
cin>>c;
int d=((a>b)&&(a>c))?a:((b>a)&&(b>c))?b:c;
cout< getch();
return 0;
}
//---------------------------------------------------------------------------

Слайд 39

Instrukcja switch -wprowadzenie

Rozważmy problem wypisania liczby dni w miesiącu dla zwykłego roku:
Będzie

Instrukcja switch -wprowadzenie Rozważmy problem wypisania liczby dni w miesiącu dla zwykłego
ona postaci:
cin>>nr_m;
if (nr_m==1) cout <<31;
else if nr_m==2 cout<<28;
else if nr_m==3 cout<<31;
else if nr_m==4 cout<<30;
else if nr_m==5 cout<<31;
else if nr_m==6 cout<<30;
else if nr_m==7 cout<<31;
else if nr_m==8 cout<<31;
else if nr_m==9 cout<<30;
else if nr_m==10 cout<<31;
else if nr_m==11 cout<<30;
else cout<<31;
Jakie są wady takiego tekstu programu?

Слайд 40

Instrukcja switch

Instrukcja switch służy do podejmowania decyzji wielowariantowych, gdy zastosowanie instrukcji if-else

Instrukcja switch Instrukcja switch służy do podejmowania decyzji wielowariantowych, gdy zastosowanie instrukcji
prowadziłoby do zbyt głębokich zagnieżdżeń i ewentualnych niejednoznaczności. Składnia instrukcji jest następująca:
switch (wyrażenie) instrukcja;
gdzie instrukcja jest zwykle instrukcją złożoną (blokiem), której instrukcje składowe są poprzedzane słowem kluczowym case z etykietą; wyrażenie, które musi przyjmować wartości całkowite, spełnia tutaj rolę selektora wyboru.

Слайд 41

Instrukcja switch

W rozwiniętym zapisie
switch (wyrażenie)
{
case etykieta_1 : instrukcje;
...
case etykieta_n :

Instrukcja switch W rozwiniętym zapisie switch (wyrażenie) { case etykieta_1 : instrukcje;
instrukcje;
default : instrukcje;
}

Слайд 42

Instrukcja switch

Etykiety są całkowitymi wartościami stałymi lub wyrażeniami stałymi. Nie może być

Instrukcja switch Etykiety są całkowitymi wartościami stałymi lub wyrażeniami stałymi. Nie może
dwóch identycznych etykiet. Jeżeli jedna z etykiet ma wartość równą wartości wyrażenia wyrażenie, to wykonanie zaczyna się od tego przypadku (ang. case - przypadek) i przebiega aż do końca bloku. Instrukcje po etykiecie default są wykonywane wtedy, gdy żadna z poprzednich etykiet nie ma aktualnej wartości selektora wyboru.
Przypadek z etykietą default jest opcją: jeżeli nie występuje i żadna z pozostałych etykiet nie przyjmuje wartości selektora, to nie jest podejmowane żadne działanie i sterowanie przechodzi do następnej po switch instrukcji programu.

Слайд 43

Instrukcja switch - komentarz

Z opisu wynika, że instrukcja switch jest co najwyżej

Instrukcja switch - komentarz Z opisu wynika, że instrukcja switch jest co
dwualternatywna i mówi: wykonuj wszystkie instrukcje od danej etykiety do końca bloku, albo: wykonuj instrukcje po default do końca bloku (bądź żadnej, jeśli default nie występuje).
Wersja ta nie wychodzi zatem poza możliwości instrukcji if, bądź if-else.
Dla uzyskania wersji z wieloma wzajemnie wykluczającymi się alternatywami musimy odseparować poszczególne przypadki w taki sposób, aby po wykonaniu instrukcji dla wybranego przypadku sterowanie opuściło blok instrukcji switch. Możliwość taką zapewnia instrukcja break.

Слайд 44

Instrukcja switch

Zatem dla selekcji wyłącznie jednego z wielu wariantów składnia instrukcji switch

Instrukcja switch Zatem dla selekcji wyłącznie jednego z wielu wariantów składnia instrukcji
będzie miała postać:
switch(wyrażenie)
{
case etykieta_1 : instrukcje;
break;
...
case etykieta_n : instrukcje;
break;
default : instrukcje;
break;
}

Слайд 45

Instrukcja switch – przykład źle zaprogramowany

#include
#include
using namespace std;
int main(int argc,

Instrukcja switch – przykład źle zaprogramowany #include #include using namespace std; int
char *argv[])
{
cout<<"Wybierz\n";
cout<<"-------\n";
cout<<"1. Kino\n";
cout<<"2. Teatr\n";
cout<<"3. Stadion\n";
cout<<"4. Dom\n";
cout<<"Wybierz:";
int wybor;
cin>>wybor;
switch(wybor)
{
case 1:
cout<<"Idziemy do kina"< case 2:
cout<<"Idziemy do teatru"< case 3:
cout<<"Idziemy na stadion"< case 4:
cout<<"Zostajemy w domu"< }
system("PAUSE");
return EXIT_SUCCESS;
}

Слайд 46

Instrukcja switch – przykład poprawiony

#include
#include
using namespace std;
int main(int argc, char

Instrukcja switch – przykład poprawiony #include #include using namespace std; int main(int
*argv[])
{
cout<<"Wybierz\n";
cout<<"-------\n";
cout<<"1. Kino\n";
cout<<"2. Teatr\n";
cout<<"3. Stadion\n";
cout<<"4. Dom\n";
cout<<"Wybierz:";
int wybor;
cin>>wybor;
switch(wybor)
{
case 1:
cout<<"Idziemy do kina"< break;
case 2:
cout<<"Idziemy do teatru"< break;
case 3:
cout<<"Idziemy na stadion"< break;
case 4:
cout<<"Zostajemy w domu"< break;
default: cout<<"Zły wybor";
}
system("PAUSE");
return EXIT_SUCCESS;
}

Слайд 47

Instrukcje iteracyjne

Instrukcje powtarzania (pętli) lub iteracji pozwalają wykonywać daną instrukcję, prostą lub

Instrukcje iteracyjne Instrukcje powtarzania (pętli) lub iteracji pozwalają wykonywać daną instrukcję, prostą
złożoną, zero lub więcej razy. W języku C++ mamy do dyspozycji trzy instrukcje iteracyjne (pętli):
while,
do-while
for.
Różnią się one przede wszystkim metodą sterowania pętlą. Dla pętli while i for sprawdza się warunek wejścia do pętli, natomiast dla pętli do-while sprawdza się warunek wyjścia z pętli.

Слайд 48

Bardzo ogólna budowa pętli

Nie występuje w żadnym języku programowania,

Operacje przedtestowe

test

Operacje potestowe

Operacje

Bardzo ogólna budowa pętli Nie występuje w żadnym języku programowania, Operacje przedtestowe
przed pętlą

Tak

Nie

Слайд 49

Schemat działania pętli - praktyczne

Schemat działania pętli - praktyczne

Слайд 50

Zagnieżdżanie instrukcji pętli

Instrukcje iteracyjne, podobnie jak instrukcje selekcji i warunkowe, można zagnieżdżać

Zagnieżdżanie instrukcji pętli Instrukcje iteracyjne, podobnie jak instrukcje selekcji i warunkowe, można
do dowolnego poziomu zagnieżdżenia.
Jednak przy wielu poziomach zagnieżdżenia program staje się mało czytelny.
W praktyce nie zaleca się stosować więcej niż trzech poziomów zagnieżdżenia.

Слайд 51

Przykład zagnieżdżenia

#include
#include
//---------------------------------------------------------------------------
int main()
{
//tabliczka mnożenia
for (int i=1;i<=5;i++)
{
for

Przykład zagnieżdżenia #include #include //--------------------------------------------------------------------------- int main() { //tabliczka mnożenia for (int
(int j=1;j<=5;j++)
cout< cout< }
getch();
return 0;
}
//---------------------------------------------------------------------------

Слайд 52

Wynik działania

Wynik działania

Слайд 53

Instrukcja while

Składnia instrukcji while jest następująca:
while (wyrażenie) instrukcja;
gdzie instrukcja może być instrukcją

Instrukcja while Składnia instrukcji while jest następująca: while (wyrażenie) instrukcja; gdzie instrukcja
pustą, instrukcją prostą lub instrukcją złożoną.
Sekwencja działań przy wykonywaniu instrukcji while jest następująca:
Oblicz wartość wyrażenia i sprawdź, czy jest równe zeru (fałsz). Jeżeli tak, to pomiń krok 2; jeżeli nie (prawda), przejdź do kroku 2.
Wykonaj instrukcję i przejdź do kroku 1.
Jeżeli pierwsze wartościowanie wyrażenia wykaże, że ma ono wartość zero, to instrukcja nie zostanie wykonana i sterowanie przejdzie do następnej instrukcji programu.

Слайд 54

Schemat blokowy dla while

Schemat blokowy dla while

Слайд 55

Przykład

#include
#include
#include
//---------------------------------------------------------------------------
// Program ilustrujący działanie instrukcji while
// Funkcja setw(liczba) powoduje

Przykład #include #include #include //--------------------------------------------------------------------------- // Program ilustrujący działanie instrukcji while //
ustawienie kursora w kolumnie o
// podanym numerze i bierzącym wierszu.
//---------------------------------------------------------------------------
int main() {
const int WIERSZ = 5;
const int KOLUMNA = 15;
int j, i = 1;
while(i <= WIERSZ)
{
cout << setw(KOLUMNA - i) << '*';
j = 1;
while( j <= 2*i-2 )
{
cout << '*';
j++;
}
cout << endl;
i++;
}
getch();
return 0;
}

Слайд 56

Komentarz

W programie mamy zagnieżdżoną pętlę while. Pierwsze sprawdzenie wyrażenia j <= 2*i‑2

Komentarz W programie mamy zagnieżdżoną pętlę while. Pierwsze sprawdzenie wyrażenia j W
w pętli wewnętrznej daje wartość 0 (fałsz), zatem w pierwszym obiegu pętla wewnętrzna zostaje pominięta.
W drugim sprawdzeniu pętla wewnętrzna dorysowuje dwie gwiazdki, itd., aż do wyjścia z pętli zewnętrznej.
Nowym elementem programu jest włączenie pliku nagłówkowego iomanip.h, w którym znajduje się deklaracja funkcji setw(int w). Funkcja ta służy do ustawiania miejsca wpisywania znaków (kolumny) w bieżącym wierszu.

Слайд 57

Instrukcja do-while

Składnia instrukcji do-while ma postać:
do instrukcja; while (wyrażenie)
gdzie instrukcja może być

Instrukcja do-while Składnia instrukcji do-while ma postać: do instrukcja; while (wyrażenie) gdzie
instrukcją pustą, instrukcją prostą lub złożoną.
W pętli do-while instrukcja (ciało pętli) zawsze będzie wykonana co najmniej jeden raz, ponieważ test na równość zeru wyrażenia jest przeprowadzany po jej wykonaniu. Pętla kończy się po stwierdzeniu, że wyrażenie jest równe zeru.

Слайд 58

Schemat blokowy do-while

Schemat blokowy do-while

Слайд 59

Przykład

#include
#include
int main() {
char znak;
cout << "Wprowadz dowolny znak;\n*

Przykład #include #include int main() { char znak; cout do { cout
oznacza koniec.\n";
do {
cout << ": ";
cin >> znak;
}
while (znak !='*');
return 0;
}

Слайд 60

Instrukcja for

Jest to, podobnie jak instrukcja while, instrukcja sterująca powtarzaniem ze sprawdzeniem

Instrukcja for Jest to, podobnie jak instrukcja while, instrukcja sterująca powtarzaniem ze
warunku zatrzymania na początku pętli. Stosuje się ją w tych przypadkach, gdy znana jest liczba obiegów pętli. Składnia instrukcji for jest następująca:
for(instrukcja-inicjująca ;wyrażenie1;wyrażenie2) instrukcja;
gdzie instrukcja może być instrukcją pustą, instrukcją prostą lub złożoną.

Слайд 61

Instrukcja for

Algorytm obliczeń dla pętli for jest następujący:
Wykonaj instrukcję o nazwie instrukcja-inicjująca.

Instrukcja for Algorytm obliczeń dla pętli for jest następujący: Wykonaj instrukcję o
Zwykle będzie to zainicjowanie jednego lub kilku liczników pętli (zmiennych sterujących), ewentualnie inicjująca instrukcja deklaracji, np.
for (i = 0; ...
for (i =0, j = 1; ...
for (int i = 0; ...
Instrukcja inicjująca może być również instrukcją pustą, jeżeli zmienna sterująca została już wcześniej zadeklarowana i zainicjowana, np.
int i = 1; for (; ...
Oblicz wartość wyrażenia wyrażenie1 i porównaj ją z zerem. Jeżeli wyrażenie1 ma wartość różną od zera (prawda) przejdź do kroku 3. Jeżeli wyrażenie1 ma wartość zero, opuść pętlę.
Wykonaj instrukcję instrukcja i przejdź do kroku 4.
Oblicz wartość wyrażenia wyrażenie2 (zwykle oznacza to zwiększenie licznika pętli) i przejdź do kroku 2.

Слайд 62

Schemat blokowy instrukcji for for(instrukcja-inicjująca;w;w2) Instrukcja;

Schemat blokowy instrukcji for for(instrukcja-inicjująca;w;w2) Instrukcja;

Слайд 63

Pętla for a while

Instrukcja for jest równoważna następującej instrukcji while:
instrukcja-inicjująca;
while (w)
{
instrukcja;

Pętla for a while Instrukcja for jest równoważna następującej instrukcji while: instrukcja-inicjująca;
w2; }

Слайд 64

Złożone sytuacje dla for

Ważnym elementem składni instrukcji for jest sposób zapisu instrukcji

Złożone sytuacje dla for Ważnym elementem składni instrukcji for jest sposób zapisu
inicjującej oraz wyrażeń składowych, gdy mamy kilka zmiennych sterujących. W takich przypadkach przecinek pomiędzy wyrażeniami pełni rolę operatora. Np. w instrukcji
for ( i = 1, j = 2; i< 5; i++, j++ ) cout <<"i =" << i << " j = " << j << "\n";
instrukcja inicjująca zawiera dwa wyrażenia: i = 1 oraz j = 2 połączone przecinkiem. Operator przecinkowy ',' wiąże te dwa wyrażenia w jedno wyrażenie, wymuszając wartościowanie wyrażeń od lewej do prawej. Tak więc najpierw ii zostaje zainicjowane do 1, a następnie jj zostanie zainicjowane do 2. Podobnie wyrażenie2, które składa się z dwóch wyrażeń i++ oraz j++, połączonych operatorem przecinkowym; po każdym wykonaniu instrukcji cout najpierw zwiększa się o 1 i, a następnie j.

Слайд 65

Przykład

#include
#include
#include
//Program Piramida
//zamiast while mamy for
int main() {
const int

Przykład #include #include #include //Program Piramida //zamiast while mamy for int main()
WIERSZ = 5;
const int KOLUMNA = 15;
for (int i = 1; i <= WIERSZ; i++)
{
cout << setw(KOLUMNA - i) << '*';
for (int j = 1; j <= 2 * i -2; j++)
cout << '*';
cout << endl;
}
getch();
return 0;
}

Слайд 66

Omówienie przykładu

W przykładzie, podobnie jak dla instrukcji while, wykorzystano funkcję setw() z

Omówienie przykładu W przykładzie, podobnie jak dla instrukcji while, wykorzystano funkcję setw()
pliku iomanip.h. Identyczne są również definicje stałych symbolicznych WIERSZ i KOLUMNA.
Taka sama jest również postać wydruku. Natomiast program jest nieco krótszy; wynika to stąd, że instrukcja for jest wygodniejsza od instrukcji while dla znanej z góry liczby obiegów pętli.
Zauważmy też, że w pętli wewnętrznej umieszczono definicję zmiennej j typu int. Zasięg tej zmiennej jest ograniczony: można się nią posługiwać tylko od punktu definicji do końca bloku zawierającego wewnętrzną instrukcję for.

Слайд 67

Szczególny przypadek

Syntaktycznie poprawny jest zapis
for (; ;)
Jest to zdegenerowana postać

Szczególny przypadek Syntaktycznie poprawny jest zapis for (; ;) Jest to zdegenerowana
instrukcji for, równoważna
for(;1;)
lub
while (1)
czyli pętli nieskończonej; np. instrukcja
for(;;) cout << "wiersz\n";
będzie drukować podany tekst aż do zatrzymania programu, lub wymuszenia instrukcją break zatrzymania pętli.

Слайд 68

Podpowiedzi dotyczące stosowania pętli

Jeśli wiemy, ile razy pętla się wykona, to używajmy

Podpowiedzi dotyczące stosowania pętli Jeśli wiemy, ile razy pętla się wykona, to
pętli for, może wykonać się 5 razy, n razy, n2 razy, f(n) razy,
Jeśli nie wiemy ile razy (np. wprowadzaj dane, aż napotkasz ”coś”) to uzywamy petli:
while, gdy warunek testujemy na początku
do .. while, gdy warunek testujemy na końcu
Każda pętla jest równoważna innej w tym sensie, że każdy algorytm zapisany za pomocą jednej pętli może być zapisany za pomocą innej. Być może będą potrzebne dodatkowe instrukcje, ale jest to zawsze możliwe.

Слайд 69

Inne instrukcje

W ciele instrukcji iteracyjnych używa się niekiedy instrukcji continue;. Wykonanie tej

Inne instrukcje W ciele instrukcji iteracyjnych używa się niekiedy instrukcji continue;. Wykonanie
instrukcji przekazuje sterowanie do części testującej wartość wyrażenia w pętlach while i do-while (krok 1), lub do kroku 4 w instrukcji for.
Instrukcję iteracyjną można przerwać za pomocą break;.
W języku C++ istnieje instrukcja skoku bezwarunkowego goto o składni goto etykieta; Jej używanie nie jest zalecane.

Слайд 70

Przykład dla brak i continue

#include
#include
#include
//instrukcja continue i break;
int main()

Przykład dla brak i continue #include #include #include //instrukcja continue i break;
{
cout<<"Użycie continue";
for (int i = 1; i <= 20; i++)
{
if (i%2==0)
{
cout< continue;
} else cout<<'*';
cout<<'@‘< }
cout<<"Użycie break";
for (int i = 1; i <= 20; i++)
if (i>10) break;
else cout< getch();
return 0;
}
Имя файла: wyklada2.pptx
Количество просмотров: 24
Количество скачиваний: 0