Praktyka Programowania Semestr I: –wykład - 1 godz. –laboratorium - 1 godz. –projekt - 1 godz.

Prezentacja na temat: "Praktyka Programowania Semestr I: –wykład - 1 godz. –laboratorium - 1 godz. –projekt - 1 godz."— Zapis prezentacji:

1 Praktyka Programowania Semestr I: –wykład - 1 godz. –laboratorium - 1 godz. –projekt - 1 godz.

2 Programowanie komputerów Cel przedmiotu: –algorytmizacja problemów –programowanie proceduralne –programowanie obiektowe Platforma programowa: –GCC + SPOJ –Visual C++

3 Literatura: J.Grębosz: Symfonia C++. Programowanie w języku C++ orientowane obiektowo, wyd. Kallimach Kraków

4 Wymagania: Laboratorium: –Wykonanie bieżących ćwiczeń; Projekt: –Wykonanie czterech indywidualnych programów; Wykład: –napisanie z wynikiem pozytywnym kolokwiów testowych. Próg każdej części: 30% Próg przedmiotu: W+L+P: 50%

5 Język: C C++ Java C# Java Script

6 Algorytm*: Skończony ciąg sekwencji/reguł, które aplikuje się na skończonej liczbie danych, pozwalający rozwiązywać zbliżone do siebie klasy problemów. Zespół reguł charakterystycznych dla pewnych obliczeń lub czynności informatycznych. ------------------------------ * Dictionaries le Robert - Paryż 1994 * Abu Jafar Mohammed ibn Musa al.-Khowarizmi (Algorismus)

7 Algorytm: posiada dane wejściowe (w ilości większej lub równej zero) pochodzące z dobrze zdefiniowanego zbioru; produkuje pewien wynik, niekoniecznie numeryczny; POWINIEN BYĆ precyzyjnie zdefiniowany - każdy krok algorytmu musi być jednoznacznie zdefiniowany; POWINIEN BYĆ skończony - wynik algorytmu musi być kiedyś dostarczony.

8 Cykl wytwarzania oprogramowania: sformułowanie problemu skonstruowanie algorytmu zakodowanie algorytmu kompilacja programu łączenie uruchamianie i testowanie programu

9

10

11

12 szybkość działania algorytmów : N Algorytm1 wszystkie i Algorytm2 2 oraz wszystkie nieparzyste i < N Algorytm3 2 oraz wszystkie nieparzyste i <sqrt(N) 10852 10098505 100099850016

13 Maksymy programistyczne Wybieraj starannie algorytm rozwiązania; Dbaj o uniwersalność programu; Najpierw algorytm, potem kodowanie; Dobry algorytm - to warunek konieczny, ale nie dostateczny napisania dobrego programu.

14 Pierwszy program w języku C++: #include main () { clrscr ();// czyszczenie ekranu cout << "\n";// nowa linia cout << "Witam na I wykładzie!\n"; cout << "Przedmiot: " << Praktyka programowania\n"; cout << "Kierunek:" << " Informatyka,\n " << "\t\t Wydział ETI\n"; return 0; } Witam na I wykładzie! Przedmiot: Programowanie Komputerów Kierunek: Informatyka, Wydział ETI

15 w każdym programie w języku C++ musi być specjalna funkcja o nazwie main; od tej funkcji zaczyna się wykonywanie programu; instrukcje wykonywane w ramach tej funkcji zawarte są między dwoma nawiasami klamrowymi { } ; operacje wejścia/wyjścia nie są częścią definicji języka C++; podprogramy odpowiedzialne za te operacje znajdują się w jednej ze standardowych bibliotek; jeżeli chcemy skorzystać w programie z takiej biblioteki, musimy na początku programu umieścić wiersz: #include wówczas kompilator przed przystąpieniem do pracy nad dalszą częścią programu wstawi w tym miejscu tzw. plik nagłówkowy iostream.h.

16 Sum_Dod = 0; Licz_Dod = 0; Sum_Poz = 0; Licz_Poz = 0; for (i = 1; i <= N; i = i+1) if (a[i] > 0) { Sum_Dod = Sum_Dod + a[i]; Licz_Dod = Licz_Dod + 1; } else { Sum_Poz = Sum_Poz + a[i]; Licz_Poz = Licz_Poz + 1; };

17 Sum_Dod = 0; Licz_Dod = 0; Sum_Poz = 0; Licz_Poz = 0; i = 1; et1:if (a[i] > 0) goto et2; Sum_Poz = Sum_Poz + a[i]; Licz_Poz = Licz_Poz + 1; goto et3; et2:Sum_Dod = Sum_Dod + a[i]; Licz_Dod = Licz_Dod + 1; et3:i = i + 1; if (i <= N) goto et1;

18 Sum_Dod = 0; Licz_Dod = 0; Sum_Poz = 0; Licz_Poz = 0; i = 1; et1: if (a[i] > 0) goto et2; Sum_Poz = Sum_Poz + a[i]; Licz_Poz = Licz_Poz + 1; goto et3; et2: Sum_Dod = Sum_Dod + a[i]; Licz_Dod = Licz_Dod + 1; et3: i = i + 1;if (i <= N) goto et1;

19 Kilka drobnych uwag: ( program L_FLOAT.CPP ) Wynik programu: x = 1.639128e-8 Źródłem tego wyniku jest różnica w rozwinięciu dziesiętnym i binarnym ułamka 0.1.

20 Kilka drobnych uwag c.d.: ( program WAR_TROJ.CPP ) I zestaw danych: a = 2e35 b = 2e35 c = 2 II zestaw danych: a = 2e35 b = 2e35 c = 2e15 Wynik: 4e35 - I+ 2e35 - II- 2e35 - III - Wynik: 4e35 - I+ 2e35 - II- 2e35 - III - Wynik: 4e35 - I+ 2.00002e35 - II+ 2.00002e35 - III + III zestaw danych: a = 2e35 b = 2e35 c = 2e30

21 Styl programowania: Programy mają być czytane przez ludzi; Stosuj komentarze wstępne; Stosuj komentarze wyjaśniające; Komentarz - to nie parafraza instrukcji; Stosuj odstępy do poprawienia czytelności; Używaj dobrych nazw mnemonicznych; Wystarczy jedna instrukcja w wierszu; Stosuj wcięcia do uwidocznienia struktury programu. PODPROGRAMY!!!

22 /*------------------------------------------------------------------------------------- Program przelicza wysokość podaną w stopach na wysokość podaną w metrach. Ćwiczymy operacje wczytywania z klawiatury i wypisywania na ekranie. ----------------------------------------------------------------------------------------*/ #include main () { intstopy;// wysokość podana w stopach floatmetry;// wysokość w metrach floatprzelicznik = 0.3; // przelicznik: stopy na metry clrscr (); cout << "Podaj wysokość w stopach: "; cin >> stopy; // wczytanie wysokości w stopach // z klawiatury metry = przelicznik * stopy; cout << "\n"; cout << "Wysokość " << stopy << " stóp - to jest: " << metry << " metrów\n"; return 0; } Podaj wysokość w stopach: 26 Wysokość 26 stóp - to jest 7.8 metrów

23 Zmienne zmienną określa się jako pewien obszar pamięci o zadanej symbolicznej nazwie, w którym można przechować wartości; wartości są interpretowane zgodnie z zadeklarowanym typem zmiennej. W przytoczonym powyżej przykładzie pojawiły się definicje zmiennych: int stopy; float metry; Zmiennym nadano nazwy stopy oraz metry. w języku C++ nazwą może być dowolnie długi ciąg liter, cyfr i znaków podkreślenia; małe i wielkie litery są rozróżniane; nazwą nie może być słowo kluczowe.

24 Instrukcje Instrukcja przypisania: Zmienna = Wyrażenie;

25 Instrukcje sterujące: W instrukcjach sterujących podejmowane są decyzje o wykonaniu tych czy innych instrukcji programu. Decyzje te podejmowane są w zależności od spełnienia lub niespełnienia określonego warunku, inaczej mówiąc od prawdziwości lub fałszywości jakiegoś wyrażenia. Początkowo w języku C++ nie było specjalnego typu określającego zmienne logiczne czyli takie, które przyjmują wartości: prawda - fałsz. do przechowywania takiej informacji można było wukorzystać każdy typ. Zasada jest prosta: sprawdza się, czy wartość danego obiektu - np. zmiennej - jest równa 0, czy różna od 0. Wartość 0 - odpowiada stanowi: fałsz. Wartość inna niż 0 - odpowiada stanowi: prawda. W trakcie rozwoju języka dodano do języka typ bool obejmujący 2 wartości true i false.

26 Instrukcja warunkowa if: lub blok: { instr_1; instr_2; instr_3; } if ( wyrażenie ) instrukcja_1; else instrukcja_2;

27 Zagnieżdżona instrukcja if...else: if ( warunek_1 ) instrukcja_1; else if ( warunek_2 ) instrukcja_2; else if ( warunek_3 ) instrukcja_3;...................................................; else instrukcja_N;

28 /* Program oblicza wartość funkcji f(x) w punkcie x. Funkcja zadana jest wzorem: f(x) = 1/(x^2 + 1), dla x <=0 f(x) = ln x, dla x > 0 */ #include cdn. Przykład 1:

29 main () { float x, f; clrscr (); cout << "Podaj wartość x: "; cin >> x; if (x <= 0) f = 1/(pow(x, 2) + 1); else f = log(x); cout << "\nDla x = "; cout.width(4); cout.precision(1); cout << x << " funkcja F(x) = "; cout.width(5); cout << f; return 0; } Podaj wartość x: -2 Dla x = -2 funkcja F(x) = 0.2 Podaj wartość x: 2 Dla x = 2 funkcja F(x) = 0.7

30 /*---------------------------------------------------------------------------------*/ /* Program oblicza stopień na podstawie liczby otrzymanych */ /* punktów. Kryteria: */ /* 0.. 49 pkt. - 2 */ /* 50.. 59 pkt. - 3 */ /* 60.. 69 pkt. - 3.5 */ /* 70.. 79 pkt. - 4 */ /* 80.. 89 pkt. - 4.5 */ /* 90..100 pkt. - 5 */ /*--------------------------------------------------------------------------------*/ #include cdn. Przykład 2:

31 main () { int lp; float stopien; clrscr (); cout << "Podaj liczbę punktów (0 <= lp <= 100): "; cin >> lp; if (lp <= 49) stopien = 2; else if (lp <= 59) stopien = 3; else if (lp <= 69) stopien = 3.5; else if (lp <= 79) stopien = 4; else if (lp <= 89) stopien = 4.5; else stopien = 5; cout << "Twoja ocena: "; cout.width(3); cout.precision(1); cout << stopien << endl; return 0; } Podaj liczbę punktów (0 <= lp <= 100): 79 Twoja ocena: 4

32 Instrukcja while while (wyrażenie) instrukcja; najpierw obliczana jest wartość wyrażenia w nawiasach; jeśli wartość ta jest prawdziwa (niezerowa), to następuje wykonywanie instrukcji w pętli tak długo, aż wyrażenie przyjmie wartość zerową ( fałsz); należy zwrócić uwagę, że wartość wyrażenia jest obliczana przed wykonaniem instrukcji.

33 Przykład 3: /*------------------------------------------------------------------*/ /* Program wykonuje sumowanie n liczb całkowitych. */ /* Jeśli kolejnym sumowanym składnikiem jest 0, to */ /* proces sumowania zostaje zakończony. */ /*------------------------------------------------------------------*/ #include cdn

34 main () { int a, l, n, S; clrscr (); cout > n; cout > a; l = 0; S = 0; while ((a != 0) && (l < n)) { l = l+1; S = S + a; cout > a; } cout << endl; cout << "Suma = " << S << endl; cout << "Liczba składników = " << l << endl; return 0; } Podaj n: 10 Podaj a: 34 Podaj a: 79 Podaj a: -33 Podaj a: 50 Podaj a: 0 Suma = 130 Liczba składników = 4

35 Instrukcja do... while do instrukcja while (wyrażenie); instrukcja jest wykonywana w pętli tak długo póki wyrażenie ma wartość niezerową ( prawda); z chwilą, gdy wyrażenie przyjmie wartość zerową (fałsz), działanie instrukcji zostaje zakończone.

36 Przykład 4: /*------------------------------------------------------------------------------*/ /* Program wykonuje sumowanie liczb całkowitych. */ /* Sumowanie zostaje zakończone, gdy suma */ /* składników przekroczy wartość 100. */ /*------------------------------------------------------------------------------*/ #include cdn.

37 main () { int a, l, S; clrscr (); l = 0; S = 0; do { cout << "Podaj a: "; cin >> a; l = l+1; S = S + a; } while (S < =100); cout << endl; cout << "Suma = " << S << endl; cout << "Liczba składników = " << l << endl; return 0; } Podaj a: 25 Podaj a: 13 Podaj a: 37 Podaj a: 48 Suma = 123 Liczba składników = 4

38 Instrukcja for for (ini; wyraz_warunkowe; krok ) treść_pętli; ini - jest to instrukcja inicjalizująca wykonywanie pętli for; wyraz_warunkowe - jest to wyrażenie obliczane przed każdym obiegiem pętli. Jeśli jest ono różne od zera, to wykonywane zostaną instrukcje będące treścią pętli; krok - jest to instrukcja wykonywana na zakończenie każdego obiegu pętli. Jest to ostatnia instrukcja wykonywana bezpośrednio przed obliczeniem wyrażenia warunkowego wyraz_warunkowe.

39 Działanie instrukcji for : 1.najpierw wykonywana jest instrukcja inicjalizująca pracę pętli; 2.obliczane jest wyrażenie warunkowe; jeśli jest ono równe 0 - praca pętli jest przerywana; 3.jeśli wyrażenie warunkowe jest różne od zera, wówczas wykonywane zostaną instrukcje będące treścią pętli; 4.po wykonaniu treści pętli wykonana zostanie instrukcja krok, po czym następuje powrót do p. 2.

40 Uwagi: 1.instrukcji inicjalizujących ini może być kilka; 2.wówczas muszą być one oddzielone przecinkami; podobnie jest w przypadku instrukcji kroku krok; 3.wyszczególnione elementy: ini, wyraz_warunkowe, krok nie muszą wystąpić; 4.dowolny z nich można opuścić, zachowując jednak średnik oddzielający go od sąsiada. 5.opuszczenie wyrażenia warunkowego jest traktowane tak, jakby stało tam wyrażenie zawsze prawdziwe.

41 Przykład 5: /*--------------------------------------------------------------------------------*/ /* Program umożliwia obliczenie silni z N (0<=N<8) */ /*--------------------------------------------------------------------------------*/ #include main () { int i, N, Silnia; clrscr (); cout > N; Silnia = 1; if (N >= 2) for (i=2; i <= N; i=i + 1) Silnia = Silnia*i; cout << endl; cout << "Silnia z " << N << " równa się: " << Silnia << endl; return 0; } Podaj N, (0<=N <= 7): 7 Silnia z 7 równa się: 5040

42 Instrukcja switch switch (wyrażenie) { case wart_1 : { instr_1; break; } case wart_2 : { instr_2; break; } … case wart_n : { instr_n; break; } default : { instr_(n+1); break; } }

43 Działanie instrukcji switch : obliczane jest wyrażenie umieszczone w nawiasach po słowie switch; jeśli jego wartość odpowiada którejś z wartości podanej w jednej z etykiet case, wówczas wykonywane są instrukcje począwszy od tej etykiety. Wykonywanie ich kończy się po napotkaniu instrukcji break. Działanie instrukcji switch zostaje wówczas zakończone; jeśli wartość wyrażenia nie zgadza się z żadną z wartości podanych w etykietach case, wówczas wykonywane są instrukcje umieszczone po etykiecie default. etykieta default może być umieszczona w dowolnym miejscu instrukcji switch, nawet na samym jej początku. Co więcej, etykiety default może nie być wcale. Wówczas, jeśli w zbiorze etykiet case nie ma żadnej etykiety równej wartości wyrażenia, instrukcja switch nie będzie wykonana. instrukcje występujące po etykiecie case nie muszą kończyć się instrukcją break. Jeśli jej nie umieścimy, to będą wykonywane instrukcje umieszczone pod następną etykietą case.

44 Przykład 6: /*--------------------------------------------------------------------------------*/ /* Program oblicza stopień na podstawie liczby otrzymanych */ /* punktów. Kryteria: */ /* 0.. 49 pkt. - 2 */ /* 50.. 59 pkt. - 3 */ /* 60.. 69 pkt. - 3.5 */ /* 70.. 79 pkt. - 4 */ /* 80.. 89 pkt. - 4.5 */ /* 90..100 pkt. - 5 */ /*--------------------------------------------------------------------------------*/ #include cdn.

45 main () { int lp; float stopien; clrscr (); cout > lp; lp = lp/10; switch (lp) { case 5 : { stopien = 3; break;} case 6 : { stopien = 3.5; break;} case 7 : { stopien = 4; break;} case 8 : { stopien = 4.5; break;} case 9,10 : { stopien = 5; break;} default : { stopien = 2; break;} } cout << "Twoja ocena: "; cout.width(3); cout.precision(1); cout << stopien << endl; return 0; } Podaj liczbę punktów (0 <= lp <= 100): 84 Twoja ocena: 4.5

46 Instrukcja break instrukcja break jest używana również w instrukcjach pętli for, while, do…while; instrukcja break powoduje natychmiastowe przerwanie wykonywania tych pętli; jeśli mamy do czynienia z pętlami zagnieżdżonymi, to instrukcja break powoduje przerwanie tylko tej pętli, w której została bezpośrednio użyta. jest to więc przerwanie z wyjściem o jeden poziom wyżej.

47 Przykład 7: #include main () { int i = 7; clrscr (); while (1) { cout << "Pętla, i = " << i << "\n"; i = i - 1; if (i < 5) { cout << "Przerwanie pętli ! "; break; } return 0; } Pętla, i = 7 Pętla, i = 6 Pętla, i = 5 Przerwanie pętli !

48 Przykład 8: #include main () { int i, m; int dlugosc_linii = 3; clrscr (); for (i =0; i < 4; i = i+1) { for (m = 0; m <10; m = m+1) { cout << "*"; if (m > dlugosc_linii) break; } cout << "\nKontynuujemy zewnętrzną pętlę for" << " dla i =" << i << "\n"; } return 0; } ***** Kontynuujemy zewnętrzną pętlę for dla i = 0 ***** Kontynuujemy zewnętrzną pętlę for dla i = 1 ***** Kontynuujemy zewnętrzną pętlę for dla i = 2 ***** Kontynuujemy zewnętrzną pętlę for dla i = 3

49 Instrukcja goto goto etykieta; instrukcja goto wykonuje skok do instrukcji opatrzonej wyspecyfikowaną etykietą; etykieta jest nazwą, po której występuje dwukropek; w języku C++ nie można wykonać skoku z dowolnego miejsca w programie do dowolnego innego miejsca; etykieta, do której wykonywany jest skok, musi leżeć w obowiązującym w danej chwili zakresie ważności.

50 Przykład 9: #include main () { clrscr (); cout << Matematyka \n"; goto a; cout << Język polski"; a: cout << Informatyka"; return 0; } Matematyka Informatyka

51 Instrukcja continue continue instrukcja continue przydaje się wewnątrz pętli for, while, do...while; powoduje ona zaniechanie realizacji instrukcji będących treścią pętli, jednak (w odróżnieniu od instrukcji break) sama pętla nie zostaje przerwana; instrukcja continue przerywa tylko ten obieg pętli i zaczyna następny, kontynuując pracę pętli.

52 Przykład 10: #include main () { int k; clrscr (); for (k = 0; k < 12; k = k+1) { cout << "A"; if (k > 1) continue; cout << "b \n"; } cout << "\n"; return 0; } Ab AAAAAAAAAA

53 Klamry w instrukcjach sterujących while (i < 4) { … } while (i < 4) {... } while (i < 4) { … }