Praktyka ProgramowaniaPraktyka Programowania

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

Programowanie Programowanie komputerówkomputerów

• Cel przedmiotu:– algorytmizacja problemów– programowanie proceduralne– programowanie obiektowe

• Platforma programowa:– GCC + SPOJ– Visual C++

Literatura:

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

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%

Język:

•C

•C++

•Java

•C#

•Java Script

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)

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.

Cykl wytwarzania oprogramowania:

• sformułowanie problemu• skonstruowanie algorytmu • zakodowanie algorytmu• kompilacja programu• łączenie• uruchamianie i testowanie programu

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.

Pierwszy program w języku C++:

#include <iostream.h>#include <conio.h>main (){

clrscr (); // czyszczenie ekranucout << "\n"; // nowa liniacout << "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ówKierunek: Informatyka,

Wydział ETI

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

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;

};

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;

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;

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

/*------------------------------------------------------------------------------------- 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 stopachfloat metry; // wysokość w metrachfloat przelicznik = 0.3; // przelicznik: stopy na metry

clrscr ();cout << "Podaj wysokość w stopach: ";cin >> stopy; // wczytanie wysokości w stopach

// z klawiaturymetry = 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

ZmienneZmienne

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.

InstrukcjeInstrukcje

Instrukcja przypisania:Instrukcja przypisania:

Zmienna = Wyrażenie;

Instrukcje sterujące: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 .

Instrukcja warunkowa Instrukcja warunkowa ifif::

lub

blok:

{

instr_1;instr_2;instr_3;

}

if ( wyrażenie ) instrukcja_1;

if ( wyrażenie ) instrukcja_1; else instrukcja_2;

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;

/* Program oblicza wartość funkcji f(x) w punkcie x. Funkcja zadana jest wzorem:

f(x) = 1/(x^2 + 1), dla x <=0f(x) = ln x, dla x > 0

*/#include <iostream.h>#include <math.h>#include <conio.h>

cdn.

Przykład 1:

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

/*---------------------------------------------------------------------------------*//* 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.

Przykład 2:

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

InstrukcjaInstrukcja whilewhile

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.

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

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

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

InstrukcjaInstrukcja do ...do ... whilewhile

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.

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.

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

InstrukcjaInstrukcja forfor

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.

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.

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.

Przykład 5:/*--------------------------------------------------------------------------------*//* 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;}

Podaj N, (0<=N <= 7): 7

Silnia z 7 równa się: 5040

InstrukcjaInstrukcja switchswitch

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

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.

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.

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

Podaj liczbę punktów (0 <= lp <= 100): 84

Twoja ocena: 4.5

InstrukcjaInstrukcja breakbreak

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.

Przykład 7:#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;}

Pętla, i = 7

Pętla, i = 6

Pętla, i = 5

Przerwanie pętli !

Przykład 8:#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;}

***** 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

InstrukcjaInstrukcja gotogoto

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.

Przykład 9:

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

MatematykaInformatyka

InstrukcjaInstrukcja continuecontinue

continuecontinue

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.

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

AbAbAAAAAAAAAA

Klamry w instrukcjach sterujących

while (i < 4){…}

while (i < 4) {...}

while (i < 4){…}