Tematyka zajęć Zintegrowane środowisko programistyczne i proces tworzenia programu Identyfikatory, słowa kluczowe, zmienne, typy danych – typy proste Instrukcja złożona, instrukcja wyrażenie, instrukcja warunkowa Instrukcja switch, pętla while Pętla do-while, pętla for, instrukcja break Instrukcja continue, instrukcja return, instrukcja skoku Etykiety, instrukcje puste Wskaźniki Tablice Struktury Unie Typy wyliczeniowe Definiowanie typów Funkcje Przekazywanie parametrów do funkcji przez wartość Zasięg zmiennych Operatory arytmetyczne, logiczne i operatory binarne Dyrektywy preprocesora Funkcje ze standardowych bibliotek języka C

Programowanie komputerów Cel przedmiotu: algorytmizacja problemów programowanie proceduralne Platforma programistyczna IDE: DevC++ CodeBlockS

Literatura: http://cpp0x.pl/kursy/ Kernighan, Ritchie: ,,Język ANSI C'' (w serii Klasyka Informatyki), WNT, (1987), 1994, 2007 Brain W. Kernigham, Denis M. Ritche Jezyk C Bjarne Stroustrup Jezyk C++ David Vandevoorde Język C++ ćwiczenia i rozwiązania Jerzy Grębosz Symfonia C++ Bruce Eckel Thinking in C++ edycja polska. http://cpp0x.pl/kursy/ http://main.edu.pl/pl/user.phtml?op=show&page=cpp&c=70000

Wymagania: Laboratorium: Zaliczenie: Udział w zajęciach i wykonanie bieżących ćwiczeń; Zaliczenie: Wykonanie na każdych ćwiczeniach indywidualnych programów za które otrzymuje się punkty;

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/C++ #include <stdio.h> #include <stdlib.h> int main() { return 0; } Program który robi nic!!!

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 < stdio.h > wówczas kompilator przed przystąpieniem do pracy nad dalszą częścią programu wstawi w tym miejscu tzw. plik nagłówkowy stdio.h

Kilka drobnych uwag: ( program L_FLOAT.CPP ) http://home.agh.edu.pl/~o_iwona/lab-strona-exe/teksty/c.html Źródłem tego wyniku jest różnica w rozwinięciu dziesiętnym i binarnym ułamka 0.1.

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 III zestaw danych: a = 2e35 b = 2e35 c = 2e30 Wynik: 4e35 - I+ 2.00002e35 - II+ 2.00002e35 - III + Wynik: 4e35 - I+ 2e35 - II- 2e35 - III - Wynik: 4e35 - I+ 2e35 - II- 2e35 - III -

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

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 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ść 26 stóp - to jest 7.8 metrów

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.

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

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 if: if ( wyrażenie ) instrukcja_1; lub if ( wyrażenie ) instrukcja_1; else instrukcja_2; { instr_1; instr_2; instr_3; } blok:

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

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

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.

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

while (wyrażenie) instrukcja; 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.

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

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.

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

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.

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: 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; } Podaj N, (0<=N <= 7): 7 Silnia z 7 równa się: 5040

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

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.

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; Podaj liczbę punktów (0 <= lp <= 100): 84 Twoja ocena: 4.5

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.

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: ***** Kontynuujemy zewnętrzną pętlę for dla i = 0 #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;

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.

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

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.

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; Ab AAAAAAAAAA

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