Praktyka Programowania

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: SymfoniaC++. ProgramowaniewjęzykuC++orientowaneobiektowo, wyd.KallimachKrakó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 Ja’far 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. 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.

10. Pierwszy program w języku C++: #include <iostream.h> #include <conio.h> 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

11. w każdym programie w językuC++musi być specjalna funkcja o nazwiemain; • 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ęzykaC++; • 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 < iostream.h > • wówczas kompilator przed przystąpieniem do pracy nad dalszą częścią programu wstawi w tym miejscu tzw.plik nagłówkowy iostream.h.

12. 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; };

13. 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;

14. 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;

15. 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!!!

16. /*-------------------------------------------------------------------------------------/*------------------------------------------------------------------------------------- Program przelicza wysokość podaną w stopach na wysokość podaną w metrach. Ćwiczymy operacje wczytywania z klawiatury i wypisywania na ekranie. ----------------------------------------------------------------------------------------*/ #include <iostream.h> #include <conio.h> main () { int stopy; // wysokość podana w stopach float metry; // wysokość w metrach float przelicznik = 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ść26stóp - to jest7.8metrów

17. 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 zadeklarowanymtypem zmiennej. • W przytoczonym powyżej przykładzie pojawiły się definicje zmiennych: • int stopy; • float metry; • Zmiennym nadano nazwystopy oraz metry. • w językuC++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.

18. Instrukcje Instrukcja przypisania: Zmienna = Wyrażenie;

19. 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ęzykuC++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ówna0, czy różna od0. • 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 .

20. Instrukcja warunkowa if: if (wyrażenie ) instrukcja_1; lub if ( wyrażenie) instrukcja_1; elseinstrukcja_2; { instr_1; instr_2; instr_3; } blok:

21. Zagnieżdżona instrukcjaif...else: if ( warunek_1 ) instrukcja_1; else if ( warunek_2 ) instrukcja_2; else if ( warunek_3 ) instrukcja_3; ...................................................; elseinstrukcja_N;

22. Przykład 1: /*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 <iostream.h> #include <math.h> #include <conio.h> cdn.

23. 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 =-2funkcja F(x) =0.2 Podaj wartość x:2 Dla x =2funkcja F(x) =0.7

24. Przykład 2: /*---------------------------------------------------------------------------------*/ /* 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 <iostream.h> #include <conio.h> cdn.

25. 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

26. Instrukcjawhile while (wyrażenie) instrukcja; • najpierw obliczana jest wartość wyrażenia w nawiasach; • jeśli wartość ta jestprawdziwa(niezerowa), to następuje wykonywanieinstrukcjiw 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.

27. 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 <iostream.h> #include <conio.h> cdn

28. 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 main () { int a, l, n, S; clrscr (); cout << "Podaj n: "; cin >> n; cout << "Podaj a: "; cin >> a; l = 0; S = 0; while ((a != 0) && (l < n)) { l = l+1; S = S + a; cout << "Podaj a: "; cin >> a; } cout << endl; cout << "Suma = " << S << endl; cout << "Liczba składników = " << l << endl; return 0; }

29. Instrukcjado ...while doinstrukcjawhile (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.

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

31. Podaj a:25 Podaj a:13 Podaj a:37 Podaj a:48 Suma = 123 Liczba składników = 4 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; }

32. Instrukcjafor 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 warunkowegowyraz_warunkowe.

33. Działanie instrukcjifor: 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.

34. 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.

35. Przykład 5: Podaj N, (0<=N <= 7): 7 Silnia z 7 równa się:5040 /*--------------------------------------------------------------------------------*/ /* Program umożliwia obliczenie silni z N (0<=N<8) */ /*--------------------------------------------------------------------------------*/ #include <iostream.h> #include <conio.h> main () { int i, N, Silnia; clrscr (); cout << "Podaj N, (0 <= N <= 7): "; cin >> 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; }

36. Instrukcjaswitch • switch (wyrażenie) • { • casewart_1 : { instr_1; • break; } • casewart_2 : { instr_2; • break; } • … • casewart_n : { instr_n; • break; } • default : { instr_(n+1); • break; } • }

37. Działanie instrukcjiswitch: • 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.

38. 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 <iostream.h> #include <conio.h> cdn.

39. Podaj liczbę punktów (0 <= lp <= 100): 84 Twoja ocena:4.5 main () { int lp; float stopien; clrscr (); cout << "Podaj liczbę punktów (0 <= lp <= 100): "; cin >> 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; }

40. Instrukcjabreak • 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.

41. Przykład 7: Pętla, i = 7 Pętla, i = 6 Pętla, i = 5 Przerwanie pętli ! #include <iostream.h> #include <conio.h> 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; }

42. Przykład 8: ***** 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 #include <iostream.h> #include <conio.h> 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; }

43. Instrukcjagoto gotoetykieta; • 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.

44. Przykład 9: Matematyka Informatyka #include <iostream.h> #include <conio.h> main () { clrscr (); cout << ”Matematyka \n"; goto a; cout << ”Język polski"; a: cout << ”Informatyka"; return 0; }

45. Instrukcjacontinue 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.

46. Ab Ab AAAAAAAAAA Przykład 10: #include <iostream.h> #include <conio.h> 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; }

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