Programowanie obiektowe w C++ Wykład 1

Transkrypt

1 Programowanie obiektowe w C++ Wykład 1 dr Lidia Stępień Akademia im. Jana Długosza w Częstochowie L. Stępień (AJD) POwCPP 1 / 24

2 Literatura Prata Stephen, Szkoła programowania. Język C++. Wydawnictwo Helion, Gliwice Bjarne Stroustrup. Język C++. Kompendium wiedzy. Wydawnictwo Helion, Gliwice Siddhartha Rao. C++. Dla każdego. Wydanie VII. Wydawnictwo Helion, Gliwice Alex Allain. C++. Przewodnik dla początkujących. Wydawnictwo Helion, Gliwice L. Stępień (AJD) POwCPP 2 / 24

3 Krótka historia języka C++ Język C++ powstał w Bell Labs na poczatku lat 80-tych ubiegłego stulecia. Twórcą jest Bjarne Stroustrup. Język C++ został stworzony jako rozszerzenie języka C o takie elementy jak: obiektowość - dodanie klas, programowanie uogólnione - dodanie szablonów. Standard C++: C sierpień 2011, C grudzień 2014, aktualnie trwają prace nad C++17. Kompilacja: g++ -std=c++11 -Wall -pedantic -o plik.cpp plik L. Stępień (AJD) POwCPP 3 / 24

4 Obsługa wejścia i wyjścia #include<iostream> using namespace std; int main(){ int a; cout << "a = "; cin >> a; cout << "a: " << a << endl; } #include<iostream> int main(){ int a; std::cout << "a = "; std::cin >> a; std::cout << "a: " << a << std::endl; } L. Stępień (AJD) POwCPP 4 / 24

5 Obsługa wejścia i wyjścia #include<iostream> using std::cin; using std::cout; using std::endl; int main(){ int a; cout << "a = "; cin >> a; cout << "a: " << a << endl; } L. Stępień (AJD) POwCPP 5 / 24

6 Dane - deklaracja zmiennych wraz z inicjalizacją int a = 12; int tab1[] = {1,2,3,4,5}; char tab2[3] { a, 66, b }; char b { 1 }; //inicjalizacja klamrowa (inicjalizacja listą) float c = {3.14} //inicjalizacja klamrowa; int d {}; //ustawia d na 0 int e = {}; //ustawia e na 0 const int i = 123; //stała symboliczna L. Stępień (AJD) POwCPP 6 / 24

7 Automatyczne deklarowanie typów w C++11 Kompilator określa typ zmiennej na podstawie typu wartości inicjalizacyjnej. auto x = 100; // x typu int auto y = 1.5; // y typu double auto z = 1.3e12L; // z typu long double Typ auto należy stosować ostrożnie, np. mamy zamiar zadeklarować 3 zmienne typu double: auto x = 0.0; double y = 0; auto z = 0; // x typu double, bo 0.0 typu double // y typu double, 0 jest // automatycznie konwertowane do double // z typu int, bo 0 jest typu int L. Stępień (AJD) POwCPP 7 / 24

8 Wczytywanie łańcuchów znakowych wierszami getline() Wczytuje całe wiersze, uznając znak nowego wiersza (ENTER) jako koniec danych. Funkcja ta ma dwa argumenty: pierwszym jest nazwa tablicy, drugim maksymalna liczba wczytanych znaków, np. dla cin.getline(tab, 20); funkcja wczyta maksymalnie 19 znaków do tablicy tab, zostawiając ostatnie miejsce na końcowy znak NUL. Funkcja ta przerywa wczytywanie danych po osiągnięciu ustalonego limitu znaków lub po wczytaniu znaku nowego wiersza. Funkcja getline() odrzuca znak nowego wiersza po sczytaniu go z bufora i zastępuje znakiem NUL. L. Stępień (AJD) POwCPP 8 / 24

9 Przykład getline() #include<iostream> using namespace std; int main(){ const int N = 20; char imie[n], nazwisko[n]; cout << "imie: "; cin.getline(imie, N); cout << "nazwisko: "; cin.getline(nazwisko, N); } cout << imie << " i " << nazwisko << endl; L. Stępień (AJD) POwCPP 9 / 24

10 Wczytywanie łańcuchów znakowych wierszami get() Funkcja pobiera takie same argumenty jak funkcja getline(), tak samo je interpretuje i wczytuje dane do końca wiersza. Różni się tym, że pozostawia znak nowego wiersza w kolejce wejściowej, co przy kilkukrotnym wywołaniu funkcji get(), może sprawiać kłopot, np. cin.get(imie,n); cin.get(nazwisko,n); //problem Rozwiązaniem może być: bezparametrowe wywołanie funkcji cin.get(), która odczytuje pojedynczy znak, np. cin.get(imie,n); cin.get(); cin.get(nazwisko,n); złączenie wywołań dwóch funkcji, np. cin.get(imie,n).get(); L. Stępień (AJD) POwCPP 10 / 24

11 Przykład get() #include<iostream> using namespace std; int main(){ const int N = 20; char imie[n], nazwisko[n]; cout << "imie: "; cin.get(imie, N).get(); cout << "nazwisko: "; cin.get(nazwisko, N).get(); } cout << imie << " i " << nazwisko << endl; L. Stępień (AJD) POwCPP 11 / 24

12 Typy wyliczeniowe Typ wyliczeniowy enum stanowi mechanizm alternatywny do stałych. enum dnitygodnia {pn, wt, sr, czw, pt, so, nd}; dnitygodnia stają się nazwą nowego typu, typu wyliczeniowego. pn, wt,... stają się stałymi symbolicznymi (enumeratorami) odpowiadającymi liczbom od 0 do 6. Domyślnie pierwszy element ma numer 0, drugi jest o 1 większy od poprzedniego, itd. Aby zmienić numery odpowiadające stałym symbolicznym należy użyć przypisania, np. enum dnitygodnia {pn = 1, wt, sr, czw, pt, so, nd}; dnitygodnia dt; Jeśli chcemy używać stałych, ale nie tworzyć zmienne typu wyliczeniowego, możemy pominąć nazwę typu wyliczeniowego, np. enum {pn = 1, wt, sr, czw, pt, so, nd}; L. Stępień (AJD) POwCPP 12 / 24

13 Typy wyliczeniowe Zmiennej wyliczeniowej można przypisać (bez rzutowania typów) tylko enumeratory odpowiedniego typu, np.: dt = pt; // dobrze dt = 2016; // źle Dla typów wyliczeniowych zdefiniowany jest jedynie operator przypisania. ++dt; // źle dt = pn + wt; // źle Typy wyliczeniowe są typami całkowitymi, więc można je rzutować na typ int, ale typy całkowite nie są automatycznie konwertowane na wyliczeniowe, np. int x = wt; // dobrze x = 3 + pn; // dobrze dt = dnitygodnia(3); // dobrze, jawne rzutowanie dt = dnitygodnia(2016) // wynik nieokreślony L. Stępień (AJD) POwCPP 13 / 24

14 Alokacja pamięci - new new - otrzymuje informację na jakie dane potrzebna jest nam pamięć, znajduje odpowiedni blok pamięci i zwraca jego adres, który przypisujemy wskaźnikowi. int * p = new int; *p = 12; double * q = new double; *q = 3.14; cout << "size p: " << sizeof(p) << "size *p: " << sizeof(*p); cout << "size q: " << sizeof(q) << "size *q: " << sizeof(*q); Zmienne statyczne mają wartości przechowywane na stosie (ang. stack), natomiast obszar pamięci przydzielany przez new to obszar tzw. sterty (ang. heap) lub pula wolnej przestrzeni (ang. free store). W sytuacji, gdy nie ma wystarczającego miejsca w pamięci, aby obsłużyć kolejne żądanie operatora new, operator ten zasygnalizuje błąd, zrzucając wyjątek. W starszych implementacjach wywołanie new zwróci 0 (pusty wskaźnik, czyli null). L. Stępień (AJD) POwCPP 14 / 24

15 Zwalnianie pamięci - delete Operatora delete używa się wraz ze wskaźnikiem bloku, który był wcześniej zaalokowany za pomocą new. Po zwolnieniu pamięci wskaźnik można ponownie wykorzystać. Użycie new i delete powinno się bilansować - ile new tyle delete. Nie należy zwalniac pamięci już raz zwolnionej. Wynik takiego działania jest nieokreślony. Można bezpiecznie stosować delete do wskaźników pustych. int * p = new int; int * q= p; delete q; delete p; // niepoprawne; Pamięć została już zwolniona! L. Stępień (AJD) POwCPP 15 / 24

16 Tablice dynamiczne int * tab = new int[100]; for(int i = 0; i < 100; ++i) tab[i] = 2*i; for(int i = 0; i < 100; ++i) cout << *(tab+i) << ", "; delete [] tab; const int N = 10; double **m = new double* [N]; for(int i = 0; i < N; ++i) m[i] = new double [N]; for(int i = 0; i < N; ++i) for(int j = 0; j < N; ++j) m[i][j] = 2*i+j; for(int i = 0; i < N; ++i) for(int j = 0; j < N; ++j) cout << *(*(m + i))+j) << ", "; for(int i = 0; i < N; ++i) delete [] m[i]; delete [] m; L. Stępień (AJD) POwCPP 16 / 24

17 Zmienne referencyjne & - alternatywna nazwa (referencja) dla zadeklarowanej wcześniej zmiennej. int i = 5; int & ri = i; cout << i << " : " << ri << endl; ri *= 5; cout << i << " : " << ri << endl; Obie nazwy i oraz ri odnoszą się do tej samej wartości, położonej w tym samym miejscu w pamięci. Deklarując zmienną referencyjną, należy ją zainicjalizować! Referencja to coś w rodzaju stałego wskaźnika, który raz powiązany ze zmienną, na zawsze z nią pozostaje. int * const pi = &i; L. Stępień (AJD) POwCPP 17 / 24

18 Zmienne referencyjne - referencja do r-wartości W C++11 wprowadzono referencję do r-wartości, która może odnosić się do r-wartości. double && rrf = sqrt(36.0); // niedozwolone dla & double j = 15.0; double && rrj = 3.0*j ; // niedozwolone dla & cout << rrf << endl; cout << rrj << endl; L. Stępień (AJD) POwCPP 18 / 24

19 Zakresowe pętle for (C++11) Służy do przetwarzania każdego z elementów tablicy (lub ogólniej, kazdego z elementów dowolnego kontenera, jak wektor czy array), np. double tab[5] = {4.09, 4.90, 5.08, 5.80, 6.0}; for(double t: tab) cout << t << ", "; Pętla wypisuje wszystkie wartości z zakresu reprezentowanego tablicą. Jęśli w pętli zamierzamy modyfikować wartości tablicy, to: double tab[5] = {4.09, 4.90, 5.08, 5.80, 6.0}; for(double &t: tab) t += 1.14; L. Stępień (AJD) POwCPP 19 / 24

20 Przeciążanie funkcji - polimorfizm Pozwala używać wielu funkcji o takiej samej nazwie. Polimorfizm - posiadanie wielu postaci. Przeciążanie funkcji - możliwość wiązania z jedną nazwą wielu funkcji - czyli nazwa jest przeciążana. Kluczem do przeciążania funkcji jest lista parametrów, czyli sygnatura funkcji. Język C++ umożliwia definiowanie funkcji o takich samych nazwach, ale o różnych sygnaturach. Sygnatury mogą różnić się liczbą parametrów, ich typami lub jednym i drugim. Niektóre sygnatury nie mogą istnieć jednocześnie: L. Stępień (AJD) POwCPP 20 / 24

21 Dopasuj prototyp do wywołania void Pisz(const char*, int); // #1 void Pisz(double, int); // #2 void Pisz(long, int); // #3 void Pisz(int, int); // #4 void Pisz(const char*); // #5 Pisz("Tort", 15); Pisz("Lody"); Pisz(2016.0, 1); Pisz(2016L, 1); Pisz(2016,1); unsigned int j = 2017; Pisz(j,1); L. Stępień (AJD) POwCPP 21 / 24

22 Dopasuj prototyp do wywołania void F1(char *); void F1(const char*); void F2(char*); void F3(const char*); const char t1[20] = "Ale checa!"; char t2[20] = "Co słychać?"; F1(t1); F1(t2); F2(t1); F2(t2); F3(t1); F3(t2); L. Stępień (AJD) POwCPP 22 / 24

23 Czy poniższe deklaracje są zgodne? long F(int, double); double F(int, double); L. Stępień (AJD) POwCPP 23 / 24