OOPC++ - wstêp w zakresie C1 C++ Bjarne Stroustrup AT&T Bell-Laboratories Historia –1980 - dodanie do C klas itp., jako punkt wyjścia przyjęto język Simula.

Prezentacja na temat: "OOPC++ - wstêp w zakresie C1 C++ Bjarne Stroustrup AT&T Bell-Laboratories Historia –1980 - dodanie do C klas itp., jako punkt wyjścia przyjęto język Simula."— Zapis prezentacji:

1 OOPC++ - wstêp w zakresie C1 C++ Bjarne Stroustrup AT&T Bell-Laboratories Historia –1980 - dodanie do C klas itp., jako punkt wyjścia przyjęto język Simula 67 (C z klasami) –1983/84 - powstanie C++ –1989 C++ wesja 2 (CFront 2.0, m.in. wielodziedziczenie) –1998 - Standard C++ (ISO/IEC 14882:1998). –2003 - tech. korekty (ISO/IEC 14882:2003) Zalety –Bazuje na bardzo popularnym C –efektywność połączona z obiektowością –możliwość tworzenia dużych systemów ułatwiona przez obiektowość –duża przenaszalność –ciągły rozwój Wady –połączenie mechanizmów niskopoziomowych (z C) z wysokopoziomowymi mechanizmami obiektowymi - w C++ trudno programować dobrze C++ zawiera prawie wszystkie znane mechanizmy obiektowe, a także połączenie tych mechanizmów z innymi, np. przeciążaniem funkcji

2 OOPC++ - wstêp w zakresie C2 Literatura Język C++; Bjarne Stroustrup; WNT 2000; wyd. 5te i zmienione, Język C++, ćwiczenia i rozwiązania; David Vandevoorde; WNT 2001, The C++ Standard: Incorporating Technical Corrigendum No. 1, British Standards Institute 816 pages, December 2003, Podstawy języka C++; Stanley B. Lippman, Josee Lajoie; WNT 2001, Podstawy języka C++, ćwiczenia i rozwiązania; Clovis L. Tondo; WNT 2001, C++ Biblioteka standardowa, podręcznik programisty; Nicolai M. Josuttis; Helion 2003, Projektowanie i rozwój języka C++, Bjarne Stroustrup, WNT 1996, C++ zadania i odpowiedzi, Tony L. Hansen, WNT 1994, Internet (draft proposed International Standard for Information Systems – Programming language C++, X3J16/96-0225, 2 XII 1996; 699 stron w tym 370 język, 329 biblioteki).

3 OOPC++ - wstêp w zakresie C3 Komentarze /* wielowierszowy */ // jednowierszowy Deklaracje zmiennych int x; // zmienna x typu integer int y = 3;// zmienna y z określoną wartością początkową 3 int z = y;// zmienna z określoną wartością pocz. y (czyli 3) char * p;// zmienna p typu wskaźnik do znaku T y;// zmienna y typu T // T może być typem pierwotnym, klasą, strukturą // lub unią float tab [100];// 100-elementowa tablica liczb rzeczywistych int* tablica;// zapewne tablica liczb całkowitych // rozmiar zostanie określony przez new char ** str;// zapewne tablica wskaźników do znaków (czyli // napisów), rozmiar zostanie określony przez new int (*arr) [10];// wskaźnik do 10-elementowej tablicy liczb int p[ ] = {4, 7, 8};// 3-elementowa tablica zawierająca liczby 4, 7, 8 Uwaga: nazwa tablicy jest utożsamiana ze stałym wskaźnikiem do pierwszego elementu tablicy. Elementy tablicy są zawsze indeksowane od 0. int tab1 [100 ];jest prawie równoważne int * tab2; tab1 [10 ] = 123; *(tab2 + 10) = 123; *(tab1 + 10) = 123; tab2 [10 ] = 123; a nawet10[tab1] = 123; ALE tab1 jest zainicjowane a tab2 NIE !!!

4 OOPC++ - wstêp w zakresie C4 Stałe (tylko C++) const int x = 145;// nie można zmienić wartości x const int *p;// nie można zmien. liczb wsk. przez p const int V[ ] = {1, 2, 3, 4};// nie można zmienić eltów tablicy V const char * napis = abcdef; char * const nap = abcdef; const char* const nap3 = "abcdef"; Specyfikacja const stwierdza, że nie można zmienić obiektu w ten sposób zadeklarowanego. V [ 3 ] = 10;// nielegalne V = new int;// ok napis [ 3 ] = 0;// nielegalne napis = xyz;// ok nap [ 3 ] = 0;// ok nap = xyz;// nielegalne Często używa się deklaracji const dla parametru funkcji aby podkreślić, że funkcja tego parametru nie może zmienić (read only). char * strcpy (char * p, const char * q); // *q nie może być zmieniane Typy (Niektóre) typy pierwotne: char, short, int, long, float, double Typy wyprowadzane (derived types): *wskaźnik &referencja [ ]tablica ( )funkcja Typy wyliczeniowe: enum kolor { czerowny, bialy, czarny, zielony }; // wprowadza już nazwę typu - kolor

5 OOPC++ - wstêp w zakresie C5 Wyrażenia Instrukcja przypisania jest wyrażeniem (z efektami ubocznymi). x = 23; x++wartością wyrażenia jest x po wykonaniu wyrażenia x ma wartość zwiększoną o 1 ++xwartością wyrażenia jest x+1 po wykonaniu wyrażenia x ma wartość zwiększoną o 1 x----xpodobnie x += w;// x = x + w; Zamiast + może wystąpić inny operator, np. *, - &&koniunkcja||alternatywa !negacja ==porównanie!= różne int *p; int x; *pobiekt wskazywany przez p &xadres obiektu x; użycie: p = &x; Konwersja typów: (stare) (char *) w float (29) (nowe) static_cast (3) typ voidpusty typ

6 OOPC++ - wstêp w zakresie C6 Referencje T - typ, T& - typ referencja do T Referencja jest inną nazwą obiektu (aliasem). int i = 1; int& r = i; // wartością i oraz r jest ten sam obiekt (liczba) // zmienna typu referencyjnego musi być zainicjowana r = 5; // teraz także i == 5 Referencje są używane przy parametrach funkcji do przekazywania parametrów przez referencję (tak, jak przez zmienną w Pascalu). Nie może być wskaźników do referencji (ani tablic referencji). Ale referencja do wskaźnika jest poprawna. Referencja to nie jest wskaźnik !!! Przykład: Funkcja zamieniająca wartości dwóch zmiennych. (1) za pomocą wskaźników void swap (int * a, int * b) { int temp; temp = *a; *a = *b; *b = temp; } wywołanie:swap (&x, &y );// tu & oznacza adres (2) za pomocą referencji swap (int& a, int& b) // parametrem aktualnym musi być zmienna { int temp; temp = a; a = b; b = temp; } wywołanie: swap (x, y); Referencji używamy najczęściej wtedy, gdy jako parametr funkcji chcemy przekazać obiekt, a nie jego kopię.

7 OOPC++ - wstêp w zakresie C7 Instrukcje Wyrażenie zakończone ; jest instrukcją. np. x++; { lista instrukcji } if (wyrażenie) instrukcja if (wyrażenie) instrukcja1 else instrukcja2 if (x < 0) x++; while (wyrażenie) instrukcja do instrukcja while (wyrażenie); while (i < n && tab [ i ] != x)// n - rozmiar tablicy i++; do x = x - y; while (x > y); {char *nap1 = 123456789; char nap2 [100] ; char * p, * q; p = nap1; q = nap2; while ( *p != 0) * q ++ = *p ++; } f or (instr_start wyr_końcowe; wyr) instrukcja2; instr_start; while (wyr_końcowe) { instrukcja2; wyr; } for (i=0; i < n ; i++) tab [ i ] = 100;

8 OOPC++ - wstêp w zakresie C8 break; // przerywa wykonanie pętli lub instrukcji switch return wyrażenie; // powrót z funkcji switch (wyr) { case const1: instr1; instr2;..... break;// powoduje wyjście z instrukcji switch case const2:instr1;...... default:instr1; instr2;.... } Funkcje float pow (float x, int n) { float y = 0; if (n < 0) error ( ujemny wykładnik); else switch ( n ) { case 0: y = 1; break; case 1: y = x; break; dafault: y = x * pow ( x, n-1 ); } return(y); }

9 OOPC++ - wstêp w zakresie C9 void main ( ) {...... // główna funkcja } Przekazywanie parametrów przez wartość tylko (normalny sposób w C) ALE może być typ referencyjny (tylko C++) void zamien (int &x, int &y) // zamienia wartości zmiennych x i y; { int pom; pom = x; x = y; y = pom; } void main ( ) { int a = 13; int b = 3445; zamien (a, b);... }

10 OOPC++ - wstêp w zakresie C10 Deklaracja funkcji: określa jej nagłówek (nazwę, typ, liczbę i typy argumentów) int zamien (int &x, int &y); Definicja funkcji: definiuje treść funkcji int zamien (int &x, int &y) {.... } Każda funkcja musi być zadeklarowana przed użyciem. Argumenty domyślne (tylko C++) void f (int i, float x = 1.0);// argumenty domyślne muszą być na końcu możliwe wywołania: f (2, 3.0); f ( 5); Argument domyślny jest obliczany w momencie wywołania funkcji. Funkcje wstawiane (inline) (tylko C++) inline int max (int x, int y) { return x > y ? x : y; } Przeciążanie funkcji (tylko C++) Deklaracja kilku funkcji o tej samej nazwie, lecz o różnej liczbie lub różnych typach argumentów. void print (char * s); // będzie wykonana dla wywołania print (aaa) void print (int n); // będzie wykonana dla wywołania print (10)

11 OOPC++ - wstêp w zakresie C11 Typy - c.d. (w C++) Struktury i unie struct para { char * nazwa; int wartość; }; para p, kolor k; struct entry { char * nazwa; char typ;// n - dla napisu, l - dla liczby union { char * wartość_napis;// używana, gdy typ == n int wartość_liczba;// używana, gdy typ == l }; entry en;... if (en.typ == n) cout << en.wartość_napis else cout << en.wartość.liczba; Tworzenie i niszczenie obiektów char * s = new char [10];// napis 9-cio znakowy int * wsk = new int; wsk = new int;// wskaźnik do nowego obiektu - liczby delete wsk;// zwalnia pamięć wskazywaną przez wsk delete[] s;// zwalnia 10-cio elementową tablicę s

12 OOPC++ - wstêp w zakresie C12 Wejście/wyjście (strumienie) (tylko C++) operatory > wynikiem zastosowania tych operatorów jest strumień. standardowe strumienie cin, cout, cerr cout << Podaj wartości dla i oraz j: ; cin >> i >> j; cout << Sumą i oraz j jest << i + j << \n; Są też funkcje: get(c)f.get(c) put (c)f.put (c) eof ()f.eof () cout, cin, f - to są obiekty klasy iostream. Klasa fstream obsługuje pliki dyskowe (jest podklasą klasy iostream). Obiekty klas ifstream i ofstream są plikami otwieranymi domyślnie do czytania i pisania. ifstream input (dane.txt);// tworzy strumień związany // z plikiem dane.txt // otwartym do czytania ofstream output (wynik.txt);// do pisania

13 OOPC++ - wstêp w zakresie C13 Struktura programu i widoczność nazw Program jest ciągiem deklaracji typów, stałych, zmiennych i funkcji. Program może być wieloplikowy. Plik pełni rolę czegoś w rodzaju modułu (grupuje deklaracje typów, zmiennych i funkcji na nich działających). Nie ma zagnieżdżania funkcji. Wykonanie programu zaczyna się od wykonania funkcji main. Wszystkie typy i funkcje są nazwami zewnętrznymi. Nazwy globalne: zadeklarowane na poziomie pliku. Każda nazwa globalna jest widoczna od momentu jej zadeklarowania do końca pliku. Nazwa zmiennej lokalnej w funkcji jest widoczna od momentu jej zadeklarowania do końca funkcji. Nazwa zmiennej lokalnej w bloku jest widoczna od momentu jej zadeklarowania do końca bloku. Deklaracja funkcji: int f (int x);// tylko nagłówek extern char * g ( );// Definicja funkcji: int f (int x) {......// treść funkcji } Plik nagłówkowy: zawiera deklaracje, które mają być wspólne dla wielu plików. #include // włączenie standardowego pliku nagłówkowego #include "mojplik.h" // włączenie własnego pliku nagłówkowego

14 OOPC++ - wstêp w zakresie C14 Liczymy liczbę wystąpień słów kluczowych na pliku #include char *słowa [ ] = { begin, end, if, while, record }; const n = 5; int licznik [ n ]; char * daj_słowo ( ifstream str);// deklaracja funkcji // daje następne słowo ze strumienia; NULL - jeśli nie ma już słowa void wypisz_wynik ( ) // wypisuje wynik - słowa i liczbę wystąpień { for ( int i = 0; i < n; i++) cout << słowa [ i ] << \t << licznik [ i ] << \n; } void policz (char * slowo ) // dla danego słowa zwiększa licznik o 1 jeśli jest to sł. kluczowe { int i = 0; while ( i < n && strcmp (slowo, slowa [ i ]) != 0) i++; if ( i < n ) licznik [ i ] ++; } void main ( ) { char * s; fstream str (... ); //.związanie strumienia str z plikiem while ((s = daj_slowo( str )) != NULL) policz (s ); wypisz_wynik (); }

15 OOPC++ - wstêp w zakresie C15 Liczymy, ile jest różnych słów na pliku. Przez słowo rozumiemy ciąg znaków nie zawierających białych znaków. W wyniku wypisujemy słowa i liczbę ich wystapień w kolejności alfabetycznej. Plik o nazwie czyt.h #include // funkcja czyta słowo (ciąg znaków różnych "białych" znaków extern char * daj_slowo (ifstream & f); Plik o nazwie tree.h // typy danych określające strukturę do przechowywania słów #include struct wezel { char * slowo; int ile; wezel* lewy; // wskaźnik do lewego poddrzewa wezel* prawy; // wskaźnik do prawego poddrzewa }; typedef wezel* drzewo; extern void wstaw(char * s, drzewo & D); // wstawia słowo do drzewa extern void wypisz(drzewo D, ofstream & wy); // obchodzi drzewo Plik o nazwie slowa.h #include // <> dla bibliotek standardowych #include "tree.h" // " " dla bibliotek prywatnych extern void pisz_wyniki( ofstream & wynik); // wypisuje wynik extern void licz (ifstream & dane); // czyta i liczy słowa

16 OOPC++ - wstêp w zakresie C16 Plik zawierający treść funkcji czytającej słowo #include #include "czyt.h" static const MAX = 50; // maksymalna długość słowa static char buf[MAX]; // bufor do przechowywania słowa static inline int BIALE (char c) { return (c == ' ' || c == '\t' || c == '\n'); } // funkcja zwraca wskaźnik do przeczytanego słowa lub NULL, // jeśli słowa już nie było char * daj_slowo (istream & f) { int i; char c; char * s; c = ; while (!f.get(c).eof() && BIALE (c)); // pomijanie spacji if (BIALE (c) || f.eof () ) return(NULL); // nie ma kolejnego slowa // czytaj słowo do bufora i = 0; do buf [i++] = c; while ( !f.get(c).eof () && (! BIALE (c)) && (i < MAX-1)); // zwracamy przeczytane słowo buf[i] = '\0'; s = new char [i+1]; strcpy (s, buf); return(s); }

17 OOPC++ - wstêp w zakresie C17 Plik zawierający operacje na drzewie BST #include #include "tree.h" // funkcja wstawia słowo s do drzewa D, zwiększa licznik void wstaw(char * s, drzewo & D) // parametr przekazany przez ref. { int b; if (D == NULL) { // nie bylo jeszcze tego słowa D = new wezel; D -> slowo = s; D -> ile = 1; D -> lewy = D -> prawy = NULL; } else { b = strcmp (D -> slowo, s); if (b > 0) // idziemy w lewo wstaw(s, D -> lewy); else if (b < 0) // idziemy w prawo wstaw(s, D -> prawy); else { (D -> ile)++; return; } } // koniec funkcji // wypisanie słów z drzewa D na plik wy void wypisz(drzewo D, ofstream & wy) { if (D == NULL) return; wypisz (D -> lewy, wy); wy slowo ile << "\n"; wypisz (D -> prawy, wy); }

18 OOPC++ - wstêp w zakresie C18 Plik zawierający treści funkcji liczących liczbę słów #include #include "czyt.h" #include "tree.h" #include slowa.h static drzewo Slowa = NULL; // drzewo slow // funkcja wypisuje częstości wystśpień słów w porządku alfabetycznym // na plik wy void pisz_wyniki( ofstream & wynik) { wypisz(Slowa, wynik); } // funkcja liczy częstotliwość występowania słów na pliku we */ void licz (ifstream & dane) { char * s; while ((s = daj_slowo(dane)) != NULL) wstaw (s, Slowa); } Program główny #include #include slowa.h void main ( int argc, char * argv [ ] ) { // utworzenie obiektów dane i wynik ifstream dane (argv [1]); ofstream wynik (argv[2]); licz (dane ) ; pisz_wyniki (wynik); }