STL: kontenery C++: STL: kontenery. STL: kontenery. STL: kontenery. STL: kontenery. Fabryka obiektów. Fabryka obiektów
|
|
- Iwona Ludwika Marciniak
- 6 lat temu
- Przeglądów:
Transkrypt
1 Fabryka obiektów C++: Fabryka obiektów Klasa, której obiekty pośrednicza przy tworzeniu innych obiektów. Pomagają tworzyć obiekty, jeżeli informacja o typie odnosi się do konkretnego typu, znanego w momencie kompilacji, ale forma jest nieodpowiednia dla kompilatora. Fabryka ukrywa przed użytkownikiem mechanizm zamiany identyfikatora na literał dostarczany do operatora new, upraszczając tworzenie obiektów. 2 Klasa bazowa Figure dostarcza identyfikatorów dla klas konkretnych: class Figure { public: enum Type {SQUARE, CIRLCE, TRIANGLE ; virtual void write(ostream& os) const = 0; virtual void read(istream& is) = 0; ; 3 Klasa pochodna nadpisuje metody wirtualne służące do zapisania obiektu do pliku oraz odczytania z pliku: class Square : public Figure { public: void write(ostream& os) const { os << SQUARE; /* zapis pól */ ; void read(istream& is) { /* odczyt pól */ ; ; 4 Podczas odczytu danych z pliku musimy polegać na informacji dostarczanej w trakcie działania, tj. na identyfikatorze obiektu zapisanym w pliku (zapis do pliku zaczyna się od podania identyfikatora, dopiero potem są zapisywane zawartości pól obiektu) Taki identyfikator to nie jest argument dla new. Potrzebny mechanizm, który tworzy obiekty na podstawie identyfikatora.. Figure* createobj(figure::type type) { switch (type) { case Figure::SQUARE: return new Square(); case Figure::CIRCLE: return new Circle(); case Figure::TRIANGLE: return new Triangle(); default: return NULL; ; ; 5 6 1
2 Za pomocą tej funkcji oraz metody read można dostarczyć funkcję, która pozwala odczytywać obiekty ze strumienia: Figure* create(ifstream& is) { Figure::Type type; unsigned int t = 0; if(is >> t) { // odczyt wartości typu int type = static_cast<figure::type>(t); // rzutowanie t na Type Figure* obj = createobj(type); obj->read(is); return obj; else return NULL; ;..i to już, wszystko? 7 To rozwiązanie ma wady: kiedy dodamy nowy typ danych, musimy też zmodyfikować funkcję createobj Brakuje kontroli poprawności wiązania identyfikatora z typem. Zestaw identyfikatorów jest zasobem wspólnym dla całej hierarchii, przy modyfikacji zbioru klas musi też podlegać modyfikacji. Potrzeba czegoś więcej.. 8 Fabryka skalowalna obiektów przykład: Fabryka najpierw rejestruje pary: identyfikatory typu i przypisane im funkcje tworzące. Następnie jest gotowa do tworzenia obiektów na podstawie identyfikatora typu. class FigFactory { public: typedef Figure* (*CreateFig)(); // nowy typ: wskaźnik na funkcję tworzącą void registerfig(int id, CreateFig fun); // rejestruje nowy typ Figure* create(int id); // tworzy obiekt na podstawie identyfikatora private: typedef map<int, CreateFig> Creators; // nowy typ: kontener mapa par Creators creators_; // pole: kontener do przechowywania par ; Fabryka skalowalna obiektów przykład: void FigFactory::registerFig(int id, CreateFig fun) { creators_.insert(map<int,createfig>::value_type(id, fun)); ; // typedef pair<const Key, Type> value_type; Figure* FigFactory::create(int id) { //tworzy obiekt danego typu Creators::const_iterator i = creators_.find(id); if(i!= creators_.end() ) //jeżeli znalazł odpowiedni wpis return (i->second)(); //woła metodę fabryczną return 0L; //zwraca pusty wskaźnik, gdy nieznany identyfikator ; 9 10 Fabryka skalowalna obiektów przykład: Autor klasy konkretnej musi też dostarczyć funkcję tworzącą obiekt danej klasy. Funkcja ta ma sygnaturę zdefiniowaną w fabryce i jest dostarczana do fabryki podczas rejestracji typu. Figure* CreateSquare() { return new Square(); ; Figure* CreateCircle() { return new Circle(); ; Figure* CreateTriangle() { return new Triangle(); ; 11 Jeszcze raz tworzymy funkcję, która pozwala odczytywać obiekty ze strumienia: Figure* create(ifstream& is, FigFactory& factory) { unsigned int t = 0; if(is >> t) { Figure* obj = factory.create(t); obj->read(is); return obj; else return NULL; ; 12..i to już, wszystko? 2
3 Trzeba jeszcze pamiętać, aby na początku programu stworzyć fabrykę i zarejestrować odpowiednie typy int main() { FigFactory factory; factory.registerfig(figure::square, CreateSquare); factory.registerfig(figure::circle, CreateCircle); factory.registerfig(figure::triangle, CreateTriangle); ; /*.. */ To wszystko. Chociaż, może nie.. 13 Fabryka obiektów i wzorzec prototypu: wzorzec prototypu pozwala na tworzenie kopii obiektu, jeżeli mamy dostępny wskaźnik lub referencję do klasy bazowej. Wykorzystuje mechanizm funkcji wirtualnych przenosi odpowiedzialność za tworzenie obiektów do klas konkretnych. Klasa bazowa definiuje tylko czysto wirtualną metodę. 14 Fabryka obiektów i wzorzec prototypu: Dodajemy czysto wirtualną metodę clone do klasy bazowej: class Figure { public: enum Type {SQUARE, CIRCLE, TRIANGLE ; virtual void write(ostream& os) const = 0; virtual void read(istream& is) = 0; virtual Figure* clone() const = 0; ; 15 Fabryka obiektów i wzorzec prototypu: Implementujemy metodę clone w klasach konkretnych: class Square : public Figure { public: void write(ostream& os) const { os << SQUARE; /* zapis pól */ ; void read(istream& is) { /* odczyt pól */ ; Figure* clone() const { return new Square(*this); ; ; Teraz zadaniem fabryki jest przechowywać obiekty wzorcowe, a nie funkcje fabryczne. Można w niej umieścić np. po kilka obiektów tego samego typu, ale w różnym stanie. 16 Fabryka obiektów i wzorzec prototypu: class FigFactory2 { typedef map<int,figure*> Prototypes; Prototypes prototypes_; public: void registerfig(int id, Figure* f){ prototypes_.insert(map<int,figure*>::value_type(id, f)); ; Figure* create(int id){ Prototypes::const_iterator i = prototypes_.find(id); if(i!= prototypes_.end() ) //jeżeli znalazł odpowiedni wpis return (i->second)->clone(); //woła metodę clone return 0L; //zwraca pusty wskaźnik, gdy nieznany identyfikator ; ; Teraz to już naprawdę wszystko o fabrykach obiektów. C++: STL Algorytmy 17 3
4 STL: algorytmy Wprowadzenie W bibliotece STL znajduje się zbiór funkcji globalnych zwanych algorytmami, które ułatwiają działania na kontenerach Algorytmy dzielą się na cztery grupy: 1. niemodyfikujące (for_each, find, count, equal, search, etc.), 2. modyfikujące (copy, swap, transform, replace, fill, generate, remove, unique, reverse, rotate, random_shuffle), 3. sortujące (partition, sort, merge, operacje na zbiorach i na stercie, min, max), 4. inne, m.in. numeryczne. 1. for_each, 2. find, 3. find_first_of, 4. adjacent_find, 5. count, 6. count_if, 7. mismatch, 8. equal, 9. search, 10.find_end, 11.search_n template<typename InputIterator, typename Function> Function for_each( InputIterator _First, InputIterator _Last, Function _Func ); wywołuje podany obiekt funkcyjny na rzecz każdego z obiektów należących do sekwencji określanej przez parę iteratorów. Iterator _Last wskazuje na prawy graniczny element sekwencji pierwszy, z listy zawartej w kontenerze, który do niej nie należy, zwraca kopię obiektu funkcyjnego po jego zastosowaniu. Przykład: Przemnożenie wszystkich elementów w kontenerze przez pewien współczynnik. Obiekt funkcyjny: template <class Type> class MultValue { private: Type Factor; public: MultValue ( const Type& _Val ) : Factor ( _Val ) {; void operator ( ) ( Type& elem ) const { elem *= Factor; ; ; int main( ) { using namespace std; vector <int> v1; vector <int>::iterator Iter1; for ( int i = -4 ; i <= 2 ; i++ ) v1.push_back( i ); for_each ( v1.begin (), v1.end (), MultValue<int> ( -2 ) ); cout << Mnożenie elementów z v1\n " << przez -2 daje:\n" ; for ( Iter1 = v1.begin( ); Iter1!= v1.end( ); Iter1++ ) cout << *Iter1 << " "; cout << endl; template<typename InputIterator, typename Type> InputIterator find( InputIterator _First, InputIterator _Last, const Type& _Val ); w sekwencji [_First,_Last) znajduje położenie pierwszego elementu przechowującego określoną wartość _Val, zwraca iterator wskazujący na znaleziony element, a jeżeli takiego elementu nie znaleziono iterator wskazujący na pierwszy element znajdujący się za ostatnim elementem z sekwencji, tj. iterator _Last. Przykład: Należy znaleźć w kontenerze element o wskazanej wartości. int main( ) { list <int> L; list <int>::iterator Iter; list <int>::iterator result; L.push_back( 40 ); L.push_back( 20 ); L.push_back( 10 ); L.push_back( 40 ); L.push_back( 10 ); result = find( L.begin( ), L.end( ), 10 ); if ( result == L.end( ) ) cout << "Nie ma 10 w liście L." << endl; else result++; cout << "Jest 10 w liście L. Po 10 występuje " << *(result) << "." << endl;
5 template<typename ForwardIterator1, typename ForwardIterator2> ForwardIterator1 find_first_of( ForwardIterator1 _First1, ForwardIterator1 _Last1, ForwardIterator2 _First2, ForwardIterator2 _Last2 ); w sekwencji określanej przez parę iteratorów [_First1,_Last1) poszukuje pierwszego wystąpienia dowolnej z wartości ze zbioru wartości określanego przez parę iteratorów [_First2,_Last2) zwraca iterator wskazujący na znaleziony element, a jeżeli takiego elementu nie znaleziono iterator wskazujący na pierwszy element znajdujący się za ostatnim elementem z sekwencji, tj. iterator _Last1, występuje w dwóch wersjach druga wersja zawiera trzeci argument szablonu reprezentujący obiekt funkcyjny służący do porównań. #include <cctype> // std::find_first_of // std::tolower int mychars[] = {'a','b','c','a','b','c'; std::vector<char> haystack (mychars,mychars+6); std::vector<char>::iterator it; int needle[] = {'A','B','C'; it = find_first_of (haystack.begin(), haystack.end(), needle, needle+3); if (it!=haystack.end()) std::cout << "Pierwszy, który pasuje: " << *it << '\n'; // std::find_first_of #include <cctype> // std::tolower bool comp_case_insensitive (char c1, char c2) { return (std::tolower(c1)==std::tolower(c2)); ; int mychars[] = {'a','b','c','a','b','c'; std::vector<char> haystack (mychars,mychars+6); std::vector<char>::iterator it; int needle[] = {'A','B','C'; it = find_first_of (haystack.begin(), haystack.end(), needle, needle+3, comp_case_insensitive); if (it!=haystack.end()) std::cout << "Pierwszy, który pasuje: " << *it << '\n'; 27 template<typename ForwardIterator> ForwardIterator adjacent_find( ForwardIterator _First, ForwardIterator _Last ); w sekwencji określanej przez parę iteratorów [_First,_Last) poszukuje dwóch sąsiadujących ze sobą elementów, które są sobie równe, zwraca iterator wskazujący na pierwszy ze znalezionej pary elementów, a jeżeli takiej pary nie znaleziono iterator wskazujący na pierwszy element znajdujący się za ostatnim elementem z sekwencji, tj. iterator _Last, występuje w dwóch wersjach druga wersja zawiera trzeci argument szablonu reprezentujący obiekt funkcyjny służący do porównań. 28 // std::adjacent_find int myt[] = {5,20,5,30,30,20,10,10,20; std::vector<int> V (myt,myt+8); std::vector<int>::iterator it; it = std::adjacent_find (V.begin(), V.end()); if (it!=v.end()) std::cout << "Pierwsza para duplikatów: " << *it << '\n'; // std::adjacent_find bool myfunction (int i, int j) { return (i==j); // tu miejsce na nasz własny sposób porównywania ; int myt[] = {5,20,5,30,30,20,10,10,20; std::vector<int> V (myt,myt+8); std::vector<int>::iterator it; it = std::adjacent_find (V.begin(), V.end(), myfunction); if (it!=v.end()) std::cout << "Pierwsza para duplikatów: " << *it << '\n';
6 template<typename InputIterator, typename Type> typename iterator_traits<inputiterator>::difference_type count( InputIterator _First, InputIterator _Last, const Type& _Val ); w sekwencji określanej przez parę iteratorów [_First,_Last) zlicza elementy których wartości są równe wartości podanej w argumencie _Val, zwraca liczbę znalezionych elementów posługując się typem danych zdefiniowanych w cechach (traits) difference_type (który powinien bezbłędnie konwertować się do int). // std::count using namespace std; int main( ) { using namespace std; vector <int> v1; vector <int>::iterator Iter; v1.push_back( 10 ); v1.push_back( 20 ); v1.push_back( 10 ); v1.push_back( 40 ); v1.push_back( 10 ); 31 int result; result = count( v1.begin( ), v1.end( ), 10 ); cout << "Liczba wystąpień wartości 10 wynosi: " << result << "." << endl; 32 template<typename InputIterator, typename Predicate> typename iterator_traits<inputiterator>::difference_type count_if( InputIterator _First, InputIterator _Last, Predicate _Pred ); w sekwencji określanej przez parę iteratorów zlicza elementy, które spełniają warunek określony w predykacie (obiekt funkcyjny, funkcja), zwraca liczbę znalezionych elementów. 33 // std::count_if using namespace std; bool greater10 ( int value ) { return value > 10; // tu miejsce na nasz własny sposób porównywania int main( ) { vector <int> v1; vector <int>::iterator Iter; v1.push_back( 10 ); v1.push_back( 20 ); v1.push_back( 10 ); v1.push_back( 40 ); v1.push_back( 10 ); int result1 = count_if( v1.begin( ), v1.end( ), greater10 ); cout << "Liczba wystąpień wartości większych od 10 w v1 wynosi: " << result1 << "." << endl; UKSW, WMP. SNS, Warszawa 34 template<typename InputIterator1, typename InputIterator2> pair<inputiterator1, InputIterator2> mismatch( InputIterator1 _First1, InputIterator1 _Last1, InputIterator2 _First2 ); porównuje dwie sekwencje elementów wskazywane przez parę iteratorów [_First1,_Last1) - pierwsza sekwencja, oraz przez iterator _First2 druga sekwencja, odpowiednio element po elemencie poszukując pierwszej takiej pary elementów z obydwu sekwencji, dla których operator porównania zwróci wartość false (obiekty przechowywane w sekwencjach muszą mieć zaimplementowany przeciążony operator porównania), Zwraca parę iteratorów wskazującą na pierwszą znalezioną parę różniących się elementów z dwóch sekwencji, lub na parę pierwszych elementów tuż za sekwencjami, jeżeli sekwencje są identyczne, występuje w dwóch wersjach druga z dodatkowym, ostatnim argumentem szablonu reprezentującym obiekt funkcyjny służący do porównań. // std::mismatch #include <utility> // std::pair for (int i=1; i<6; i++) V.push_back (i*10); // V: int myt[] = {10,20,80,320,1024; // myt: std::pair<std::vector<int>::iterator,int*> mypair; mypair = std::mismatch (V.begin(), V.end(), myt); std::cout << " Pierwsza para różnych elementów: " << *mypair.first; std::cout << " oraz " << *mypair.second << '\n';
7 // std::mismatch #include <utility> // std::pair bool mypredicate (int i, int j) { return (i==j); // tu miejsce na nasz własny sposób porównywania ; for (int i=1; i<6; i++) V.push_back (i*10); // V: int myt[] = {10,20,80,320,1024; // myt: std::pair<std::vector<int>::iterator,int*> mypair; mypair = std::mismatch (V.begin(), V.end(), myt, mypredicate); std::cout << " Pierwsza para różnych elementów: " << *mypair.first; std::cout << " oraz " << *mypair.second << '\n'; 37 template<typename InputIterator1, typename InputIterator2> bool equal( InputIterator1 _First1, InputIterator1 _Last1, InputIterator2 _First2 ); porównuje dwie sekwencje elementów wskazywane przez parę iteratorów [_First1,_Last1) pierwsza sekwencja, oraz iterator _First2 druga sekwencja, odpowiednio element po elemencie zwraca wartość true, jeżeli sekwencje są identyczne, lub false wpp, występuje w dwóch wersjach druga z dodatkowym, ostatnim argumentem szablonu reprezentującym obiekt funkcyjny/funkcję służący do porównań. 38 // std::equal int myt[] = {20,40,60,80,100; // myt: std::vector<int>v (myt,myt+5); // V: if ( std::equal (V.begin(), V.end(), myt) ) std::cout << "Sekwencje identyczne.\n"; else std::cout << "Sekwencje różne.\n"; // std::equal bool mypredicate (int i, int j) { return (i==j); // tu miejsce na nasz własny sposób porównywania ; int myt[] = {20,40,60,80,100; // myt: std::vector<int>v (myt,myt+5); // V: if ( std::equal (V.begin(), V.end(), myt, mypredicate) ) std::cout << "Sekwencje identyczne.\n"; else std::cout << "Sekwencje różne.\n"; template<class ForwardIterator1, class ForwardIterator2> ForwardIterator1 search( ForwardIterator1 _First1, ForwardIterator1 _Last1, ForwardIterator2 _First2, ForwardIterator2 _Last2 ); w sekwencji określanej przez parę iteratorów [_First1,_Last1) poszukuje pierwszej pod-sekwencji o wartościach identycznych jak sekwencja określana przez parę iteratorów [_First2,_Last2), zwraca iterator na element w sekwencji określanej przez parę iteratorów [_First1,_Last1), który rozpoczyna znalezioną pod-sekwencję, a jeżeli takiej pod-sekwencji nie znaleziono iterator wskazujący na pierwszy element znajdujący się za ostatnim elementem z sekwencji [_First1,_Last1), tj. iterator _Last1, występuje w dwóch wersjach druga z dodatkowym, ostatnim argumentem szablonu reprezentującym obiekt funkcyjny/funkcję służący do porównań. template<class ForwardIterator1, class ForwardIterator2> ForwardIterator1 find_end( ForwardIterator1 _First1, ForwardIterator1 _Last1, ForwardIterator2 _First2, ForwardIterator2 _Last2 ); w sekwencji określanej przez parę iteratorów [_First1,_Last1) poszukuje ostatniej pod-sekwencji o wartościach identycznych jak sekwencja określana przez parę iteratorów [_First2,_Last2) zwraca iterator na element w sekwencji określanej przez parę iteratorów [_First1,_Last1), który rozpoczyna znalezioną pod-sekwencję, a jeżeli takiej pod-sekwencji nie znaleziono iterator wskazujący na pierwszy element znajdujący się za ostatnim elementem z sekwencji [_First1,_Last1), tj. iterator _Last1, występuje w dwóch wersjach druga z dodatkowym, ostatnim argumentem szablonu reprezentującym obiekt funkcyjny/funkcję służący do porównań
8 // std::search std::vector<int> haystack; // set some values: haystack: for (int i=1; i<10; i++) haystack.push_back(i*10); int needle1[] = {40,50,60,70; std::vector<int>::iterator it; it = std::search (haystack.begin(), haystack.end(), needle1, needle1+4); if (it!=haystack.end()) std::cout << "needle1 found at position " <<(it-haystack.begin())<< '\n'; else std::cout << "needle1 not found\n"; 43 // std::search bool mypredicate (int i, int j) { return (i==j); // tu miejsce na nasz własny sposób porównywania std::vector<int> haystack; // set some values: haystack: for (int i=1; i<10; i++) haystack.push_back(i*10); int needle2[] = {20,30,50; it = std::search (haystack.begin(), haystack.end(), needle2, needle2+3, mypredicate); if (it!=haystack.end()) std::cout << "needle2 found at position " <<(it-haystack.begin())<< '\n'; else std::cout << "needle2 not found\n"; UKSW, WMP. SNS, Warszawa 44 template<class ForwardIterator1, class Diff2, class Type> ForwardIterator1 search_n( ForwardIterator1 _First1, ForwardIterator1 _Last1, Size2 _Count, const Type& _Val ); w sekwencji określanej przez parę iteratorów [_First1,_Last1) szuka pierwszej pod-sekwencji o długości _Count, w której wszystkie elementy mają wartość _Val zwraca iterator na element w sekwencji określanej przez parę iteratorów [_First1,_Last1), który rozpoczyna znalezioną pod-sekwencję, a jeżeli takiej pod-sekwencji nie znaleziono iterator wskazujący na pierwszy element znajdujący się za ostatnim elementem z sekwencji [_First1,_Last1), tj. iteratorem _Last1, występuje w dwóch wersjach druga z dodatkowym, ostatnim argumentem szablonu reprezentującym obiekt funkcyjny/funkcję służący do porównań. 45 // std::search_n int myt[]={10,20,30,30,20,10,10,20; std::vector<int> V (myt,myt+8); std::vector<int>::iterator it; it = std::search_n (V.begin(), V.end(), 2, 30); if (it!=v.end()) std::cout << "two 30s found at position " <<(it-v.begin())<< '\n'; else std::cout << "match not found\n"; 46 // std::search_n bool mypredicate (int i, int j) { return (i==j); // tu miejsce na nasz własny sposób porównywania ; int myt[]={10,20,30,30,20,10,10,20; std::vector<int> V (myt,myt+8); std::vector<int>::iterator it; it = std::search_n (V.begin(), V.end(), 2, 10, mypredicate); if (it!=v.end()) std::cout<<"two 10s found at position "<<int(it-v.begin())<< '\n'; else std::cout << "match not found\n"; Podsumowanie: 1. for_each, 2. find, 3. binary_search, 4. find_first_of, 5. adjacent_find, 6. count, 7. count_if, 8. mismatch, 9. equal, 10.search, 11.find_end, 12.search_n
9 1. fill, 2. fill_n, 3. generate, 4. generate_n, 5. copy, 6. copy_backward, 7. swap, 8. swap_ranges, 9. replace, 10.replace_if, 11.replace_copy, 12.replace_copy_if, 13.unique_copy, 14.reverse, 15.reverse_copy, 16.rotate, 17.rotate_copy, 18.random_shuffle, 19.transform template<typename ForwardIterator, typename Type> void fill( ForwardIterator _First, ForwardIterator _Last, const Type& _Val ); w sekwencji określanej przez parę iteratorów [_First,_Last) zmienia wartości przechowywane w elementach tej sekwencji na wartość podaną w argumencie _Val template<typename OutputIterator, typename Size, typename Type> void fill_n( OutputIterator _First, Size _Count, const Type& _Val ); w pierwszych _Count elementach sekwencji, której pierwszy element jest wskazywany przez iterator _First, zmienia wartości przechowywane w tych elementach na wartość podaną w argumencie _Val. // std::fill std::vector<int> V (8); // V: std::fill (V.begin(),V.begin()+4,5); // V: std::fill (V.begin()+3,3,8); // V: std::cout << V zawiera:"; template<typename ForwardIterator, typename Generator> void generate( ForwardIterator _First, ForwardIterator _Last, Generator _Gen ); w sekwencji określanej przez parę iteratorów [_First,_Last) zmienia wartości przechowywane w elementach tej sekwencji na wartości wygenerowane przez obiekt funkcyjny _Gen. template<class OutputIterator, class Size, class Generator> void generate_n( OutputIterator _First, Size _Count, Generator _Gen ); w pierwszych _Count elementach sekwencji, której pierwszy element jest wskazywany przez iterator _First, zmienia wartości przechowywane w elementach tej sekwencji na wartości wygenerowane przez obiekt funkcyjny _Gen
10 int Fibonacci(void) { static int r; static int f1 = 0; static int f2 = 1; r = f1 + f2 ; f1 = f2 ; f2 = r ; return f1 ; ; // zmienne statyczne // deklarowane są tylko raz int main() { const int VECTOR_SIZE = 8 ; typedef vector<int> IntVector ; typedef IntVector::iterator IntVectorIt ; IntVector Numbers(VECTOR_SIZE) ; IntVectorIt start, end, it ; start = Numbers.begin() ; end = Numbers.end() ; generate(start, end, Fibonacci) ; cout << "Liczby { " ; for(it = start; it!= end; it++) cout << *it << " " ; cout << " \n" << endl ; ; Wyjście: Liczby { template<typename InputIterator, typename OutputIterator> OutputIterator copy( InputIterator _First, InputIterator _Last, OutputIterator _DestBeg ); Przepisuje wartości elementów z sekwencji źródłowej określanej przez parę iteratorów [_First,_Last) do sekwencji docelowej, której pierwszy element wskazywany jest przez iterator _DestBeg Uwaga: przedziały muszą być poprawnie zdefiniowane, w przedziale docelowym musi być dostatecznie dużo elementów; ponieważ algorytm kopiuje sekwencyjnie zaczynając od pierwszego elementu, przedziały mogą się nakładać ważne, aby element wskazywany przez _First nie należał do przedziału docelowego. 56 template< typename BidirectionalIterator1, typename BidirectionalIterator2> BidirectionalIterator2 copy_backward( BidirectionalIterator1 _First, BidirectionalIterator1 _Last, BidirectionalIterator2 _DestEnd ); przepisuje wartości elementów z sekwencji źródłowej określanej przez parę iteratorów [_First,_Last) do sekwencji docelowej, dla której pierwszy element znajdujący się za ostatnim z sekwencji docelowej wskazywany jest przez iterator _DestEnd Uwaga: wszystkie iteratory muszą być dwukierunkowe; przedziały muszą być poprawnie zdefiniowane, w przedziale docelowym musi być dostatecznie dużo elementów; ponieważ algorytm kopiuje sekwencyjnie zaczynając od pierwszego elementu, przedziały mogą się nakładać ważne, aby element wskazywany przez _First UKSW, WMP. nie SNS, należał Warszawado przedziału docelowego. 57 Aby przesunąć sekwencję elementów np. o jeden w lewo należy użyć copy, natomiast o jeden w prawo copy_backward, np.: string s("abcdefghihklmnopqrstuvwxyz"); vector<char> vector1(s.begin(), s.end()); copy(vector1.begin() + 1, vector1.end(), vector1.begin()); copy_backward(vector1.begin(), vector1.end() - 1, vector1.end()); 58 // std::copy_backward template< typename ForwardIterator1, typename ForwardIterator2> void iter_swap( ForwardIterator1 _Left, ForwardIterator2 _Right ); zamienia miejscami dwie wartości wskazywane przez dwa iteratory. for (int i=1; i<=5; i++) V.push_back(i*10); // V: V.resize(V.size()+3); // allocate space for 3 more elements std::copy_backward ( V.begin(), V.begin()+5, V.end() ); std::cout << "V zawiera: "; W oknie konsoli: V zawiera:
11 template< typename ForwardIterator1, typename ForwardIterator2> ForwardIterator2 swap_ranges( ForwardIterator1 _First1, ForwardIterator1 _Last1, ForwardIterator2 _First2 ); zamienia miejscami wartości z dwóch zakresów, jeden wskazywany przez parę iteratorów [_First,_Last), a drugi zaczynający się od elementu wskazywanego przez iterator _First2. #include <deque> // std::swap_ranges // std::deque std::vector <int> v1; std::deque <int> d1; for ( int i = 0 ; i <= 5 ; i++ ) v1.push_back( i ); for ( int ii =4 ; ii <= 9 ; ii++ ) d1.push_back( 6 ); std::swap_ranges ( v1.begin ( ), v1.end ( ), d1.begin ( ) ); template<class ForwardIterator, class Type> void replace( ForwardIterator _First, ForwardIterator _Last, const Type& _OldVal, const Type& _NewVal ); w sekwencji określanej przez parę iteratorów [_First,_Last) zamienia wszystkie wystąpienia wartości _OldVal wartością _NewVal. // std::replace int myt[] = { 10, 20, 30, 30, 20, 10, 10, 20 ; std::vector<int> V(myT, myt+8); // std::replace (V.begin(), V.end(), 20, 99); // template<class ForwardIterator, class Predicate, class Type> void replace_if( ForwardIterator _First, ForwardIterator _Last, Predicate _Pred, const Type& _Val ); w sekwencji określanej przez parę iteratorów [_First,_Last) zamienia wszystkie elementy spełniające predykat _Pred wartością _NewVal. // std::replace_if bool Nieparzysty (int i) { return ((i%2)==1); for (int i=1; i<10; i++) V.push_back(i); // std::replace_if (V.begin(), V.end(), Nieparzysty, 0); //
12 template<class InputIterator, class OutputIterator, class Type> OutputIterator replace_copy( InputIterator _First, InputIterator _Last, OutputIterator _Result, const Type& _OldVal, const Type& _NewVal ); z sekwencji określanej przez parę iteratorów [_First,_Last) kopiuje do sekwencji, której pierwszy element jest wskazywany przez _Result, wszystkie elementy, ale po drodze zamienia elementy o wartości _OldVal elementami o wartości _NewVal // std::replace_copy int myt[] = { 10, 20, 30, 30, 20, 10, 10, 20 ; std::vector<int> V(8); std::replace_copy (myt, myt+8, V.begin(), 20, 99); template<class InputIterator, class OutputIterator, class Predicate, class Type> OutputIterator replace_copy_if( InputIterator _First, InputIterator _Last, OutputIterator _Result, Predicate _Pred, const Type& _Val ); z sekwencji określanej przez parę iteratorów [_First,_Last) kopiuje do sekwencji, której pierwszy element jest wskazywany przez _Result, wszystkie elementy, ale po drodze zamienia elementy spełniające predykat _Pred wartością _NewVal. 69 // std::replace_copy_if bool Nieparzysty (int i) { return ((i%2)==1); std::vector<int> V, W; for (int i=1; i<10; i++) V.push_back(i); // W.resize(V.size()); // allocate space std::replace_copy_if (V.begin(), V.end(), W.begin(), Nieparzysty, 0); // std::cout << "W zawiera:"; for (std::vector<int>::iterator it=w.begin(); it!=w.end(); ++it) 70 template<class InputIterator, class OutputIterator> OutputIterator unique_copy( InputIterator _First, InputIterator _Last, OutputIterator _Result ); z sekwencji określanej przez parę iteratorów [_First,_Last) kopiuje do sekwencji, której pierwszy element jest wskazywany przez _Result, wartości bez powtórzeń, tj. tak, aby każda wartość w sekwencji wynikowej była unikalna (występowała w niej tylko raz), występuje w dwóch wersjach druga z dodatkowym, ostatnim argumentem szablonu reprezentującym obiekt funkcyjny/funkcję służący do porównań. // std::unique_copy, std::sort, std::distance int myt[] = {10,20,20,20,30,30,20,20,10; std::vector<int> V (9); // V: std::vector<int>::iterator it; it=std::unique_copy (myt,myt+9,v.begin()); // V: // ^ for (it=v.begin(); it!=v.end(); ++it)
13 // std::unique_copy, std::sort, std::distance bool myfunction (int i, int j) { return (i==j); ; int myt[] = {10,20,20,20,30,30,20,20,10; std::vector<int> V (9); // V: std::vector<int>::iterator it; it=std::unique_copy (myt,myt+9,v.begin(), myfunction); // V: // ^ for (it=v.begin(); it!=v.end(); ++it) template<class BidirectionalIterator> void reverse( BidirectionalIterator _First, BidirectionalIterator _Last ); odwraca kolejność elementów w sekwencji określanej przez parę iteratorów [_First,_Last) // std::reverse for (int i=1; i<10; ++i) V.push_back(i); // std::reverse(v.begin(),v.end()); // template<class BidirectionalIterator, class OutputIterator> OutputIterator reverse_copy( BidirectionalIterator _First, BidirectionalIterator _Last, OutputIterator _Result ); z sekwencji określanej przez parę iteratorów [_First,_Last) kopiuje do sekwencji, której pierwszy element jest wskazywany przez _Result, wszystkie elementy ale w odwrotnej kolejności int myt[] ={1,2,3,4,5,6,7,8,9; // std::reverse_copy V.resize(9); // allocate space std::reverse_copy (myt, myt+9, V.begin()); template<class ForwardIterator> void rotate( ForwardIterator _First, ForwardIterator _Middle, ForwardIterator _Last ); obraca elementy w sekwencji określanej przez parę iteratorów [_First,_Last) zamieniając lewą i prawą połowę elementów sekwencji miejscami, przy czym iterator _Middle wskazuje środek. std::cout << "V contains:";
14 // std::rotate for (int i=1; i<10; ++i) V.push_back(i); // std::rotate(v.begin(),v.begin()+3,v.end()); // template<class ForwardIterator, class OutputIterator> OutputIterator rotate_copy( ForwardIterator _First, ForwardIterator _Middle, ForwardIterator _Last, OutputIterator _Result ); do sekwencji wskazywanej przez _Result kopiuje elementy z sekwencji określanej przez parę iteratorów [_First,_Last) w innym porządku, tj. zamieniając lewą i prawą połowę elementów sekwencji miejscami, przy czym iterator _Middle wskazuje środek // std::rotate_copy int myints[] = {10,20,30,40,50,60,70; std::vector<int> V (7); std::rotate_copy(myints,myints+3,myints+7,v.begin()); template <class RandomAccessIterator, class RandomNumberGenerator> void random_shuffle ( RandomAccessIterator first, RandomAccessIterator last); template <class RandomAccessIterator, class RandomNumberGenerator> void random_shuffle ( RandomAccessIterator first, RandomAccessIterator last, RandomNumberGenerator& rand ) miesza kolejność elementów w sekwencji // std::random_shuffle Jak miesza random_shuffle #include <ctime> // std::time #include <cstdlib> // std::rand, std::srand int myrandom (int i) { return std::rand()%i; std::srand ( unsigned ( std::time(0) ) ); for (int i=1; i<10; ++i) V.push_back(i); // std::random_shuffle ( V.begin(), V.end() ); std::random_shuffle ( V.begin(), V.end(), myrandom); template <class RandomAccessIterator, class RandomNumberGenerator> void random_shuffle ( RandomAccessIterator first, RandomAccessIterator last, RandomNumberGenerator& gen) { iterator_traits<randomaccessiterator>::difference_type i, n; n = (last-first); for (i=n-1; i>0; --i) { swap (first[i],first[gen(i+1)]);
15 template < class InputIterator, class OutputIterator, class UnaryOperator > OutputIterator transform ( InputIterator first1, InputIterator last1, OutputIterator result, UnaryOperator op ) modyfikuje elementy z sekwencji operatorem jednoargumentowym i wynik modyfikacji zapisuje do innej sekwencji. 85 // std::transform int op_increase (int i) { return ++i; std::vector<int> W; for (int i=1; i<6; i++) V.push_back (i*10); // V: W.resize(V.size()); // allocate space std::transform (V.begin(), V.end(), W.begin(), op_increase); // W: std::cout << W zawiera:"; for (std::vector<int>::iterator it=w.begin(); it!=w.end(); ++it) 86 template<class InputIterator1, class InputIterator2, class OutputIterator, class BinaryFunction> OutputIterator transform( InputIterator1 _First1, InputIterator1 _Last1, InputIterator2 _First2, OutputIterator _Result, BinaryFunction _Func ); transformuje elementy pochodzące z dwóch sekwencji operatorem dwuargumentowym, pierwsza sekwencja jest wskazywana przez iteratory [_First1, _Last1), drugiej pierwszy element jest wskazywany przez iterator _First2, wynik zapisywany jest do sekwencji, której pierwszy element jest wskazywany przez _Result, natomiast obiekt funkcyjny jest wskazywany przez _Func. 87 // std::transform #include <functional> // std::plus int op_increase (int i) { return ++i; std::vector<int> W; for (int i=1; i<6; i++) V.push_back (i*10); // V: W.resize(V.size()); // allocate space std::transform (V.begin(), V.end(), W.begin(), op_increase); // W: // std::plus adds together its two arguments: std::transform (V.begin(), V.end(), W.begin(), V.begin(), std::plus<int>()); // V: Podsumowanie: 1. fill, 2. fill_n, 3. generate, 4. generate_n, 5. copy, 6. copy_backward, 7. swap, 8. swap_ranges, 9. replace, 10.replace_if, 11.replace_copy, 12.replace_copy_if, 13.unique_copy, 14.reverse_copy, 15.rotate, 16.rotate_copy, 17.random_shuffle, 18.transform 89 15
STL: kontenery. STL: kontenery. STL: kontenery. Typy kontenerów STL. STL: kontenery. STL: kontenery. multimap. Kontener map: przykład zadanie:
Kontener map: przykład zadanie: Jak policzyć liczby różnych słów występujących w tekście? Rozwiązanie: Potrzebny jest kontener, który będzie zawierał listę różnych słów (tj. listę bez powtórzeń), która
Bardziej szczegółowoSTL: implementowanie algorytmów. STL: implementowanie algorytmów. STL: implementowanie algorytmów. STL: implementowanie algorytmów
Algorytm przeszukiwania wszerz Przeszukiwanie grafu odwiedzenie wszystkich jego wierzchołków w kolejności jak na rysunku obok: Reprezentacja grafu w programie Wierzchołki są identyfikowane przez liczby
Bardziej szczegółowoSTL: algorytmy sortujące. STL: algorytmy sortujące. STL: algorytmy sortujące. STL: algorytmy sortujące. STL: algorytmy sortujące
1. partition 2. stable_partition 3. sort 4. stable_sort 5. partial_sort 6. partial_sort_copy 7. nth_element 8. lower_bound 9. upper_bound 10.equal_range 11.binary_search 12.merge 13.inplace_merge 14.includes
Bardziej szczegółowoSTL: algorytmy sortujące. STL: algorytmy sortujące. STL: algorytmy sortujące. STL: algorytmy sortujące. STL: algorytmy sortujące
1. partition 2. stable_partition 3. sort 4. stable_sort 5. partial_sort 6. partial_sort_copy 7. nth_element 8. lower_bound 9. upper_bound 10.equal_range 11.binary_search 12.merge 13.inplace_merge 14.includes
Bardziej szczegółowoSTL: kontenery C++: STL: kontenery. STL: kontenery. STL: kontenery. STL: kontenery. Fabryka obiektów. Fabryka obiektów. Fabryka obiektów przykład:
Fabryka obiektów C++: Fabryka obiektów Klasa, której obiekty pośrednicza przy tworzeniu innych obiektów. Pomagają tworzyć obiekty, jeżeli informacja o typie odnosi się do konkretnego typu, znanego w momencie
Bardziej szczegółowoAlgorytmy w C++ dla opornych!
Algorytmy w C++ dla opornych! 02.10.2011 Opracował: Krzysztof Rudlicki W-ce przewodniczący SKN TeamBit krudlicki@future-processing.com O czym będę przynudzał: O - Dlaczego będę przynudzał? O - Vector A
Bardziej szczegółowoDariusz Brzeziński. Politechnika Poznańska, Instytut Informatyki
Dariusz Brzeziński Politechnika Poznańska, Instytut Informatyki int getmax (int a, int b) { return (a > b? a : b); float getmax (float a, float b) { return (a > b? a : b); long getmax (long a, long b)
Bardziej szczegółowoAlgorytmy, iteratory, kolekcje niestandardowe
Algorytmy, iteratory, kolekcje niestandardowe Biblioteka STL Sebastian Deorowicz Politechnika Śląska 2006 11 06 Sebastian Deorowicz (PŚl) Algorytmy, iteratory, kolekcje niestandardowe 2006 11 06 1 / 83
Bardziej szczegółowoobiekty funkcyjne - funktory
#include #include #include #include #include #include #include #include #include #include using namespace
Bardziej szczegółowoSTL: implementowanie algorytmów C++: STL. STL: implementowanie algorytmów. STL: implementowanie algorytmów. STL: implementowanie algorytmów
Algorytm przeszukiwania w głąb Przeszukiwanie grafu odwiedzenie wszystkich jego wierzchołków w kolejności jak na rysunku obok: C++: STL Implementowanie własnych algorytmów Reprezentacja grafu w programie
Bardziej szczegółowoDefinicja szablonu klasy. Korzystanie z szablonu. Specjalizacja metody szablonu.
class Wektor private: Typ x; Typ y; Wektor(Typ a, Typ b) :x(a), y(b) ; Wektor A(2, 5); Wektor B(2.7, 9.7); Wektor C('A', 'B'); 1 Definicja szablonu klasy. Korzystanie z szablonu. class
Bardziej szczegółowoZaawansowane programowanie w C++ (PCP)
Zaawansowane programowanie w C++ (PCP) Wykład 6 - szablony. dr inż. Robert Nowak - p. 1/15 Kolekcje i algorytmy» Deklaracja szablonu y Pojęcia niezależne od typu: kolekcje (np. listy) algorytmy (np. znajdowania
Bardziej szczegółowoKurs programowania. Wykład 9. Wojciech Macyna. 28 kwiecień 2016
Wykład 9 28 kwiecień 2016 Java Collections Framework (w C++ Standard Template Library) Kolekcja (kontener) Obiekt grupujacy/przechowuj acy jakieś elementy (obiekty lub wartości). Przykładami kolekcji sa
Bardziej szczegółowoProgramowanie i struktury danych
Programowanie i struktury danych 1 / 30 STL Standard Template Library, STL (ang. = Standardowa Biblioteka Wzorców) biblioteka C++ zawierająca szablony (wzorce), które umożliwiają wielokrotne użycie. Główne
Bardziej szczegółowoWstęp do programowania obiektowego. STL - Standard Template Library
Wstęp do programowania obiektowego STL - Standard Template Library 1 STL z ang. Standard Template Library, (pol. standardowa biblioteka szablonów) biblioteka C++ zawierająca pojemniki, iteratory, algorytmy,
Bardziej szczegółowoParadygmaty programowania
Paradygmaty programowania Programowanie generyczne w C++ Dr inż. Andrzej Grosser Cz estochowa, 2016 2 Spis treści 1. Zadanie 3 5 1.1. Wprowadzenie.................................. 5 1.2. Obiekty funkcyjne................................
Bardziej szczegółowoSTL: kontenery. Typy kontenerów STL. STL: kontenery. STL: kontenery. STL: kontenery. Typy kontenerów STL. deque (double-ended queue) list
Kontenery sekwencyjne: deque (kolejka dwustronna) deque (double-ended queue) implementacja kontenera zoptymalizowana pod kątem efektywności operacji dołączania i usuwania elementów z sekwencji na obu jej
Bardziej szczegółowoAlgorytmy i Struktury Danych. Anna Paszyńska
Algorytmy i Struktury Danych Anna Paszyńska Tablica dynamiczna szablon Array Zbiory Zbiory template class Container {public: virtual ~Container() { }; virtual int Count() const = 0;
Bardziej szczegółowoStandard C++0x (C++1x?) Marcin Świderski
Standard C++0x (C++1x?) Marcin Świderski sfider@students.mimuw.edu.pl O czym będzie mowa? Wytyczne komitetu standaryzacyjnego Rozszerzenia języka Rozszerzenia języka szablony Rozszerzenia biblioteki standardowej
Bardziej szczegółowoKurs programowania. Wykład 9. Wojciech Macyna
Wykład 9 Java Collections Framework (w C++ Standard Template Library) Kolekcja (kontener) Obiekt grupujacy/przechowuj acy jakieś elementy (obiekty lub wartości). Przykładami kolekcji sa zbiór, lista czy
Bardziej szczegółowoTechnologie programowania Wykład 4. Szablony funkcji Notes. Szablony funkcji Notes. Szablony funkcji Notes. Notes. Przemek Błaśkiewicz.
Technologie programowania Wykład 4 Przemek Błaśkiewicz 9 maja 2017 1 / 54 Szablony funkcji Często w programach zachodzi potrzeba użycia funkcji, które co do mechanizmu działaja tak samo, ale różnia się
Bardziej szczegółowoProgramowanie w C++ Wykład 6. Katarzyna Grzelak. 1 kwietnia K.Grzelak (Wykład 6) Programowanie w C++ 1 / 43
Programowanie w C++ Wykład 6 Katarzyna Grzelak 1 kwietnia 2019 K.Grzelak (Wykład 6) Programowanie w C++ 1 / 43 Pojęcia z poprzednich wykładów Tablica to ciag obiektów tego samego typu, zajmujacy ciagły
Bardziej szczegółowoSzablony klas, zastosowanie szablonów w programach
Szablony klas, zastosowanie szablonów w programach 1. Szablony klas i funkcji 2. Szablon klasy obsługującej uniwersalną tablicę wskaźników 3. Zastosowanie metody zwracającej przez return referencję do
Bardziej szczegółowoSzablony funkcji i klas (templates)
Instrukcja laboratoryjna nr 3 Programowanie w języku C 2 (C++ poziom zaawansowany) Szablony funkcji i klas (templates) dr inż. Jacek Wilk-Jakubowski mgr inż. Maciej Lasota dr inż. Tomasz Kaczmarek Wstęp
Bardziej szczegółowoSzablony funkcji i szablony klas
Bogdan Kreczmer bogdan.kreczmer@pwr.wroc.pl Zakład Podstaw Cybernetyki i Robotyki Instytut Informatyki, Automatyki i Robotyki Politechnika Wrocławska Kurs: Copyright c 2011 Bogdan Kreczmer Niniejszy dokument
Bardziej szczegółowo2. Klasy cz. 2 - Konstruktor kopiujący. Pola tworzone statycznie i dynamicznie - Funkcje zaprzyjaźnione - Składowe statyczne
Tematyka wykładów 1. Wprowadzenie. Klasy cz. 1 - Język C++. Programowanie obiektowe - Klasy i obiekty - Budowa i deklaracja klasy. Prawa dostępu - Pola i funkcje składowe - Konstruktor i destruktor - Tworzenie
Bardziej szczegółowoAlgorytmy i Struktury Danych.
Algorytmy i Struktury Danych. Standard Template Library. Część 1. Bożena Woźna-Szcześniak bwozna@gmail.com Jan Długosz University, Poland Wykład 6 Bożena Woźna-Szcześniak (AJD) Algorytmy i Struktury Danych.
Bardziej szczegółowoProgramowanie w C++ Wykład 7. Katarzyna Grzelak. 23 kwietnia K.Grzelak (Wykład 7) Programowanie w C++ 1 / 40
Programowanie w C++ Wykład 7 Katarzyna Grzelak 23 kwietnia 2018 K.Grzelak (Wykład 7) Programowanie w C++ 1 / 40 Standard Template Library (STL) K.Grzelak (Wykład 7) Programowanie w C++ 2 / 40 C++ Templates
Bardziej szczegółowoProgramowanie Obiektowo Zorientowane w języku C++ Biblioteka STL
Programowanie Obiektowo Zorientowane w języku C++ Biblioteka STL Mirosław Głowacki 1 1 Akademia Górniczo-Hutnicza im. Stanisława Staszica w Ktrakowie Wydział Inżynierii Metali i Informatyki Stosowanej
Bardziej szczegółowoSTL: Lekcja 1&2. Filozofia STL
STL: Lekcja 1&2 Tematy: Filozofia STL Po co nam STL? Podstawowa zawartość STL Co warto znać zanim zaczniemy pracę z STL?: wskaźniki Praca na tekstach: klasa String Vector: nowy wymiar standardowych tablic.
Bardziej szczegółowoDla każdej operacji łącznie tworzenia danych i zapisu ich do pliku przeprowadzić pomiar czasu wykonania polecenia. Wyniki przedstawić w tabelce.
Przygotować program tworzący tablicę dwuwymiarową zawierającą zestawy 10 2, 10 4, 10 6 liczb losowych zmiennoprzecinkowych. Korzystając z funkcji bibliotecznych uporządkować zawartość każdego (a) wiersza
Bardziej szczegółowoKurs programowania. Wykład 1. Wojciech Macyna. 3 marca 2016
Wykład 1 3 marca 2016 Słowa kluczowe języka Java abstract, break, case, catch, class, const, continue, default, do, else, enum, extends, final, finally, for, goto, if, implements, import, instanceof, interface,
Bardziej szczegółowoIMIĘ i NAZWISKO: Pytania i (przykładowe) Odpowiedzi
IMIĘ i NAZWISKO: Pytania i (przykładowe) Odpowiedzi EGZAMIN PIERWSZY (25 CZERWCA 2013) JĘZYK C++ poprawiam ocenę pozytywną z egzaminu 0 (zakreśl poniżej x) 1. Wśród poniższych wskaż poprawną formę definicji
Bardziej szczegółowoSTL Standardt Template Library (wprowadzenie)
STL Standardt Template Library (wprowadzenie) Biblioteka standardowych szablonów na dzień dzisiejszy stanowi jedną z najpotężniejszych możliwości języka C++ Zawiera szablony klas ogólnego przeznaczenia
Bardziej szczegółowoSkładnia C++ Programowanie Obiektowe Mateusz Cicheński
Składnia C++ Programowanie Obiektowe Mateusz Cicheński Klasy i modyfikatory dostępu Przesłanianie metod Polimorfizm Wskaźniki Metody wirtualne Metody abstrakcyjne i interfejsy Konstruktory i destruktory
Bardziej szczegółowoSTL: kontenery. STL: kontenery. STL: kontenery. STL: kontenery. STL: kontenery. STL: kontenery
Kontenery sekwencyjne: list (lista dwukierunkowa) jest przystosowany do szybkiego wstawiania elementów w dowolne miejsce sekwencji, nie nadaje się do efektywnej realizacji operacji swobodnego dostępu,
Bardziej szczegółowoTechnologie cyfrowe semestr letni 2018/2019
Technologie cyfrowe semestr letni 2018/2019 Tomasz Kazimierczuk Wykład 7 (08.04.2019) Wikipedia Programowanie komputerów proces projektowania, tworzenia, testowania i utrzymywania kodu źródłowego programów
Bardziej szczegółowoSkładnia C++ Programowanie Obiektowe Mateusz Cicheński
Składnia C++ Programowanie Obiektowe Mateusz Cicheński Klasy i modyfikatory dostępu Przesłanianie metod Polimorfizm Wskaźniki Metody wirtualne Metody abstrakcyjne i interfejsy Przeciążanie operatorów Słowo
Bardziej szczegółowoOperatory na rzecz typu TString
Operatory na rzecz typu TString Dopiszmy w definicji klasy operator[], dzięki któremu potraktujemy obiekt jak tablicę class TString { public: char& operator[]( size_t n ); const char& operator[]( size_t
Bardziej szczegółowoJęzyk ludzki kod maszynowy
Język ludzki kod maszynowy poziom wysoki Język ludzki (mowa) Język programowania wysokiego poziomu Jeśli liczba punktów jest większa niż 50, test zostaje zaliczony; w przeciwnym razie testu nie zalicza
Bardziej szczegółowoZaawansowane programowanie w języku C++ Biblioteka standardowa
Zaawansowane programowanie w języku C++ Biblioteka standardowa Prezentacja jest współfinansowana przez Unię Europejską w ramach Europejskiego Funduszu Społecznego w projekcie pt. Innowacyjna dydaktyka
Bardziej szczegółowoKLASA UCZEN Uczen imię, nazwisko, średnia konstruktor konstruktor Ustaw Wyswietl Lepszy Promowany
KLASA UCZEN Napisz deklarację klasy Uczen, w której przechowujemy następujące informacje o uczniu: imię, nazwisko, średnia (pola prywatne), poza tym klasa zawiera metody: konstruktor bezparametrowy (nie
Bardziej szczegółowowykład IV uzupełnienie notatek: dr Jerzy Białkowski Programowanie C/C++ Język C, a C++. wykład IV dr Jarosław Mederski Spis Język C++ - wstęp
Programowanie uzupełnienie notatek: dr Jerzy Białkowski 1 2 3 4 Historia C++ został zaprojektowany w 1979 przez Bjarne Stroustrupa jako rozszerzenie języka C o obiektowe mechanizmy abstrakcji danych i
Bardziej szczegółowoProgramowanie współbieżne i rozproszone
Programowanie współbieżne i rozproszone WYKŁAD 5 Jan Kazimirski 1 Programowanie GPU 2/2 2 Thrust Język CUDA C bazuje na języku C języku o dosyć niskim poziomie abstrakcji ( macro assembler) Implementowanie
Bardziej szczegółowo8. Wektory. Przykłady Napisz program, który pobierze od użytkownika 10 liczb, a następnie wypisze je w kolejności odwrotnej niż podana.
8. Wektory Przykłady 8.1. Napisz program, który pobierze od użytkownika 10 liczb, a następnie wypisze je w kolejności odwrotnej niż podana. Uwaga! Kod poniżej. To zadanie można rozwiązać przy użyciu wiedzy
Bardziej szczegółowoAby uzyskać zaliczenie w pierwszym terminie (do 30 stycznia 2018) rozliczyć trzeba co najmniej 8 projektów, po 4 z każdej z części: C++ oraz Python.
Aby uzyskać zaliczenie w pierwszym terminie (do 30 stycznia 2018) rozliczyć trzeba co najmniej 8 projektów, po 4 z każdej z części: C++ oraz Python. Pliki z rozwiązaniami projektu (wszystkie polecenia
Bardziej szczegółowoWprowadzenie do szablonów szablony funkcji
Bogdan Kreczmer ZPCiR IIAiR PWr pokój 307 budynek C3 bogdan.kreczmer@pwr.wroc.pl Copyright c 2006 2010 Bogdan Kreczmer Niniejszy dokument zawiera materiały do wykładu na temat programowania obiektowego.
Bardziej szczegółowoSzablony. Szablony funkcji
Szablony Szablony sa mechanizmem ponownego wykorzystania kodu (reuse) W przypadku funkcji ponownie wykorzystany jest algorytm W przypadku klas ponownie wykorzystane sa wszystkie skladowe Deklaracja szablonu
Bardziej szczegółowoWprowadzenie do szablonów klas
Bogdan Kreczmer bogdan.kreczmer@pwr.wroc.pl Zakład Podstaw Cybernetyki i Robotyki Instytut Informatyki, Automatyki i Robotyki Politechnika Wrocławska Kurs: Copyright c 2008-2010 Bogdan Kreczmer Niniejszy
Bardziej szczegółowoProjektowanie klas c.d. Projektowanie klas przykład
Projektowanie klas c.d. ogólne wskazówki dotyczące projektowania klas: o wyodrębnienie klasy odpowiedź na potrzeby życia (obsługa rozwiązania konkretnego problemu) o zwykle nie uda się utworzyć idealnej
Bardziej szczegółowoWprowadzenie do szablonów szablony funkcji
Wprowadzenie do szablonów szablony funkcji Bogdan Kreczmer ZPCiR IIAiR PWr pokój 307 budynek C3 bogdan.kreczmer@pwr.wroc.pl Copyright c 2006 2010 Bogdan Kreczmer Niniejszy dokument zawiera materiały do
Bardziej szczegółowoAutomatyczne tworzenie operatora = Integer2& operator=(const Integer& prawy) { zdefiniuje. Integer::operator=(ri);
Przeciążanie operatorów [] Przykład: klasa reprezentująca typ tablicowy. Obiekt ma reprezentować tablicę, do której można się odwoływać intuicyjnie, np. Tab[i] Ma być też dostępnych kilka innych metod
Bardziej szczegółowoZaawansowane programowanie w C++ (PCP)
Wykład 8 - biblioteka standardowa. Kolekcje i iteratory 27 kwietnia 2007 Powtórzenie - sprytne wskaźniki Zalety: upraszczają zarządzanie obiektami na stercie Wady: narzuty Sprytne wskaźniki dostępne w
Bardziej szczegółowoProgramowanie Komponentowe Zarządzanie obiektami: kontenery
Programowanie Komponentowe Zarządzanie obiektami: kontenery dr inż. Ireneusz Szcześniak jesień 2016 roku Kontenery Kontener w C++ to generyczna struktura danych. Przechowuje elementy jednego dowolnego
Bardziej szczegółowoC++ - przeciążanie operatorów. C++ - przeciążanie operatorów. C++ - przeciążanie operatorów. C++ - przeciążanie operatorów
Operatory są elementami języka C++. Istnieje zasada, że z elementami języka, takimi jak np. słowa kluczowe, nie można dokonywać żadnych zmian, przeciążeń, itp. PRZECIĄŻANIE OPERATORÓW Ale dla operatorów
Bardziej szczegółowoPARADYGMATY PROGRAMOWANIA Wykład 4
PARADYGMATY PROGRAMOWANIA Wykład 4 Metody wirtualne i polimorfizm Metoda wirualna - metoda używana w identyczny sposób w całej hierarchii klas. Wybór funkcji, którą należy wykonać po wywołaniu metody wirtualnej
Bardziej szczegółowoSzablon klasy std::vector
Szablon klasy std::vector Bogdan Kreczmer ZPCiR IIAiR PWr pokój 307 budynek C3 bogdan.kreczmer@pwr.wroc.pl Copyright c 2006 2010 Bogdan Kreczmer Niniejszy dokument zawiera materiały do wykładu na temat
Bardziej szczegółowoProgramowanie obiektowe w C++ Wykład 12
Programowanie obiektowe w C++ Wykład 12 dr Lidia Stępień Akademia im. Jana Długosza w Częstochowie L. Stępień (AJD) 1 / 22 Zakresowe pętle for double tab[5] {1.12,2.23,3.33,4.12,5.22 for(double x: tab)
Bardziej szczegółowoWykład 3 Składnia języka C# (cz. 2)
Wizualne systemy programowania Wykład 3 Składnia języka C# (cz. 2) 1 dr Artur Bartoszewski -Wizualne systemy programowania, sem. III- WYKŁAD Wizualne systemy programowania Metody 2 Metody W C# nie jest
Bardziej szczegółowoEGZAMIN 2 (14 WRZEŚNIA 2015) JĘZYK C++
IMIĘ i NAZWISKO: przykładowe odpowiedzi NR: 0 EGZAMIN 2 (14 WRZEŚNIA 2015) JĘZYK C++ 1. Napisz precyzyjnie co to jest ptr jeśli: const * const Foo ptr; ptr to stały wskaźnik do stałego obiektu typu Foo
Bardziej szczegółowoInstrukcja do pracowni specjalistycznej z przedmiotu. Obiektowe programowanie aplikacji
Politechnika Białostocka Wydział Elektryczny Katedra Telekomunikacji i Aparatury Elektronicznej Instrukcja do pracowni specjalistycznej z przedmiotu Obiektowe programowanie aplikacji Kod przedmiotu: TS1C410201
Bardziej szczegółowoProgramowanie w języku Java. Kolekcje
Programowanie w języku Java Kolekcje Definicja Kolekcja to obiekt, który grupuje elementy danych (inne obiekty) i pozwala traktować je jak jeden zestaw danych, umożliwiając jednocześnie wykonywanie na
Bardziej szczegółowoAutomatyczne tworzenie operatora = Integer2& operator=(const Integer& prawy) {
Przeciążanie a dziedziczenie class Integer2: public Integer Operatory, z wyjątkiem operatora przypisania są automatycznie dziedziczone w klasach pochodnych. Integer2(int i): Integer(i) Automatyczne tworzenie
Bardziej szczegółowoWykład I. Programowanie II - semestr II Kierunek Informatyka. dr inż. Janusz Słupik. Wydział Matematyki Stosowanej Politechniki Śląskiej
Wykład I - semestr II Kierunek Informatyka Wydział Matematyki Stosowanej Politechniki Śląskiej Gliwice, 2015 c Copyright 2015 Janusz Słupik Zaliczenie przedmiotu Do zaliczenia przedmiotu niezbędne jest
Bardziej szczegółowoZaawansowane programowanie w C++ (PCP)
Wykład 9 - powtórzenie. 11 maja 2007 Powtórzenie materiału obiekty automatyczne, statyczne, tymczasowe, dynamiczne dziedziczenie, agregacja polimorfizm, funkcje wirtualne wzorce projektowe (strukturalne,
Bardziej szczegółowoutworz tworzącą w pamięci dynamicznej tablicę dwuwymiarową liczb rzeczywistych, a następnie zerującą jej wszystkie elementy,
Lista 3 Zestaw I Zadanie 1. Zaprojektować i zaimplementować funkcje: utworz tworzącą w pamięci dynamicznej tablicę dwuwymiarową liczb rzeczywistych, a następnie zerującą jej wszystkie elementy, zapisz
Bardziej szczegółowoKLASA UCZEN Uczen imię, nazwisko, średnia konstruktor konstruktor Ustaw Wyswietl Lepszy Promowany
KLASA UCZEN Napisz deklarację klasy Uczen, w której przechowujemy następujące informacje o uczniu: imię, nazwisko, średnia (pola prywatne), poza tym klasa zawiera metody: konstruktor bezparametrowy (nie
Bardziej szczegółowoTechnologie cyfrowe semestr letni 2018/2019
Technologie cyfrowe semestr letni 2018/2019 Tomasz Kazimierczuk Wykład 8 (15.04.2019) Kompilacja Kompilacja programu (kodu): proces tłumaczenia kodu napisanego w wybranym języku na kod maszynowy, zrozumiały
Bardziej szczegółowoWskaźniki. nie są konieczne, ale dają językowi siłę i elastyczność są języki w których nie używa się wskaźników typ wskaźnikowy typ pochodny:
Wskaźniki nie są konieczne, ale dają językowi siłę i elastyczność są języki w których nie używa się wskaźników typ wskaźnikowy typ pochodny: typ nw; /* definicja zmiennej nw typu typ */ typ *w_nw; /* definicja
Bardziej szczegółowoProgramowanie w C++ Wykład 12. Katarzyna Grzelak. 28 maja K.Grzelak (Wykład 12) Programowanie w C++ 1 / 27
Programowanie w C++ Wykład 12 Katarzyna Grzelak 28 maja 2018 K.Grzelak (Wykład 12) Programowanie w C++ 1 / 27 Klasy cd K.Grzelak (Wykład 12) Programowanie w C++ 2 / 27 Klasy - powtórzenie Klasy typy definiowane
Bardziej szczegółowoSignals + Threads: Qt vs. Boost
Signals + Threads: Qt vs. Boost Adam Bujalski 2014-04-01 Adam Bujalski Signals + Threads: Qt vs. Boost 2014-04-01 1 / 22 Spis Treści 1 2 Wątki 3 Qt::QueuedConnection w boost Adam Bujalski Signals + Threads:
Bardziej szczegółowoMechanizm dziedziczenia
Mechanizm dziedziczenia Programowanie obiektowe jako realizacja koncepcji ponownego wykorzystania kodu Jak przebiega proces dziedziczenia? Weryfikacja formalna poprawności dziedziczenia Realizacja dziedziczenia
Bardziej szczegółowoJęzyk C++ wykład VIII
Programowanie uzupełnienie notatek: dr Jerzy Białkowski 1 2 3 4 Obiektowość języka C++ ˆ Klasa (rozszerzenie struktury), obiekt instancją klasy, konstruktory i destruktory ˆ Enkapsulacja - kapsułkowanie,
Bardziej szczegółowodr inż. Jarosław Forenc
Informatyka 2 Politechnika Białostocka - Wydział Elektryczny Elektrotechnika, semestr III, studia niestacjonarne I stopnia Rok akademicki 2011/2012 Pracownia nr 9 (20.01.2012) dr inż. Jarosław Forenc Rok
Bardziej szczegółowoObszar statyczny dane dostępne w dowolnym momencie podczas pracy programu (wprowadzone słowem kluczowym static),
Tworzenie obiektów Dostęp do obiektów jest realizowany przez referencje. Obiekty w języku Java są tworzone poprzez użycie słowa kluczowego new. String lan = new String( Lancuch ); Obszary pamięci w których
Bardziej szczegółowoProgramowanie obiektowe
Programowanie obiektowe Wykład 4 Marcin Młotkowski 15 marca 2018 Plan wykładu 1 2 3 Klasa podstawowa Własne kolekcje Obiekty i wartości Marcin Młotkowski Programowanie obiektowe 141 / 224 Z czego składa
Bardziej szczegółowoProgramowanie w C++ Wykład 11. Katarzyna Grzelak. 13 maja K.Grzelak (Wykład 11) Programowanie w C++ 1 / 30
Programowanie w C++ Wykład 11 Katarzyna Grzelak 13 maja 2019 K.Grzelak (Wykład 11) Programowanie w C++ 1 / 30 Klasy cd K.Grzelak (Wykład 11) Programowanie w C++ 2 / 30 Klasy - powtórzenie Klasy typy definiowane
Bardziej szczegółowoPARADYGMATY PROGRAMOWANIA Wykład 3
PARADYGMATY PROGRAMOWANIA Wykład 3 Definiowanie operatorów i ich przeciążanie Przykłady zastosowania operatorów: a) operator podstawienia ( = ) obiektów o złożonej strukturze, b) operatory działania na
Bardziej szczegółowoAutomatyczne tworzenie operatora = Integer2& operator=(const Integer& prawy) {
Przeciążanie operatorów [] Przykład: klasa reprezentująca typ tablicowy. Obiekt ma reprezentować tablicę, do której można się odwoływać intuicyjnie, np. Tab[i] Ma być też dostępnych kilka innych metod
Bardziej szczegółowoPojemniki Pojemnik to obiekt, którego zadaniem jest przechowywanie innych obiektów.
1 Wstęp Biblioteka standardowa C++ Wejście/wyjście (iostream) Napisy (string) Napisy jako strumienie (sstream) STL Standard Template Library Pojemniki (kolekcje) Iteratory (wyliczanie elementów) Algorytmy
Bardziej szczegółowoJęzyk C++ wykład VII. uzupełnienie notatek: dr Jerzy Białkowski. Programowanie C/C++ Język C++ wykład VII. dr Jarosław Mederski. Spis.
Programowanie uzupełnienie notatek: dr Jerzy Białkowski 1 2 3 4 Obiektowość języka C++ ˆ Klasa (rozszerzenie struktury), obiekt instancją klasy, konstruktory i destruktory ˆ Enkapsulacja - kapsułkowanie,
Bardziej szczegółowoWstęp do programowania obiektowego, wykład 7
Wstęp do programowania obiektowego, wykład 7 Klasy i funkcje abstrakcyjne Przeciążanie funkcji Definiowanie i interpretacja złożonych typów danych w C++ Wskaźniki do funkcji 1 KLASA ABSTRAKCYJNA 2 Klasa
Bardziej szczegółowoC++11. C++ 11 wybrane elementy. C++11: referencje do rvalue C++ 11: C++11: referencje do rvalue. C++11: referencje do rvalue. Referencje do rvalue
C++ 11 wybrane elementy C++11 Lista rozszerzeń C++11 obecnych w VC2013: 1. Referencje do rvalue, 2. Jednolite inicjowanie i delegowanie konstruktorów, 3. Konstruktory delegujące 4. Jednolita inicjalizacja
Bardziej szczegółowoWykład II. Programowanie II - semestr II Kierunek Informatyka. dr inż. Janusz Słupik. Wydział Matematyki Stosowanej Politechniki Śląskiej
Wykład II - semestr II Kierunek Informatyka Wydział Matematyki Stosowanej Politechniki Śląskiej Gliwice, 2015 c Copyright 2015 Janusz Słupik Operacje dyskowe - zapis do pliku #include #include
Bardziej szczegółowoProgramowanie obiektowe i C++ dla matematyków
Programowanie obiektowe i C++ dla matematyków Bartosz Szreder szreder (at) mimuw... 22 XI 2011 Uwaga! Ponieważ już sobie powiedzieliśmy np. o wskaźnikach i referencjach, przez które nie chcemy przegrzebywać
Bardziej szczegółowoJzyk C++ cz 3. Jarosław Gramacki Instytut Informatyki i Elektroniki ( $)*)+' *, - ( ' )*'.' '',*/ *, ','*0) 1 / ) %*+ 2'' 2" ( $%%) )'20 )*0) 1 / )
Jzyk C++ cz 3 Jarosław Gramacki Instytut Informatyki i Elektroniki # $$%%& ' ( $)*)+' *, - ( ' )*'.' '',*/ *, ','*0) 1 / ) %*+ 2'' 2" ( $%%) )'20 )*0) 1 / )!" 2 # $$%%& ' ( $%%/,))3 ( %* 2 / 4 ( ( *' *''*,
Bardziej szczegółowoWstęp do programowania
wykład 6 Agata Półrola Wydział Matematyki i Informatyki UŁ sem. zimowy 2017/2018 Losowanie liczb całkowitych Dostępne biblioteki Najprostsze losowanie liczb całkowitych można wykonać za pomocą funkcji
Bardziej szczegółowoProgramowanie 2. Język C++. Wykład 9.
9.1 Ukrywanie metod, metody nadpisane... 1 9.2 Metody wirtualne, wirtualny destruktor... 2 9.3 Metody czysto wirtualne... 6 9.4 Klasy abstrakcyjne... 7 9.5 Wielodziedziczenie... 9 9.1 Ukrywanie metod,
Bardziej szczegółowoKurs programowania. Wykład 2. Wojciech Macyna. 17 marca 2016
Wykład 2 17 marca 2016 Dziedziczenie Klasy bazowe i potomne Dziedziczenie jest łatwym sposobem rozwijania oprogramowania. Majac klasę bazowa możemy ja uszczegółowić (dodać nowe pola i metody) nie przepisujac
Bardziej szczegółowoLista, Stos, Kolejka, Tablica Asocjacyjna
Lista, Stos, Kolejka, Tablica Asocjacyjna Listy Lista zbiór elementów tego samego typu może dynamicznie zmieniać rozmiar, pozwala na dostęp do poszczególnych elementów Typowo dwie implementacje: tablicowa,
Bardziej szczegółowoC++: STL. STL: kontenery. STL: kontenery. STL: kontenery. STL: kontenery. Programowanie Obiektowe C++: Standard Template Library
Programowanie Obiektowe C++: Standard Template Library C++: STL Kontenery - wprowadzenie 1 Wprowadzenie Rozwiązanie większości zadań programistycznych polega na gromadzeniu i przetwarzaniu danych w ilości
Bardziej szczegółowoProgramowanie w języku C++
Programowanie w języku C++ Część dziewiąta Autor Roman Simiński Kontakt siminski@us.edu.pl www.us.edu.pl/~siminski Niniejsze opracowanie zawiera skrót treści wykładu, lektura tych materiałów nie zastąpi
Bardziej szczegółowoIdentyfikacje typu na etapie. wykonania (RTTI)
Identyfikacje typu na etapie (Run Time Type Identification) wykonania (RTTI) Może powstać taka sytuacje, gdy w trakcie kompilacji typ obiektu nie jest znany. C++ implementuje polimorfizm poprzez hierarchie
Bardziej szczegółowoZaawansowane programowanie w C++ (PCP)
Zaawansowane programowanie w C++ (PCP) Wykład 4 - wzorce projektowe. dr inż. Robert Nowak - p. 1/18 Powtórzenie klasy autonomiczne tworzenie nowych typów: dziedziczenie i agregacja dziedziczenie: przedefiniowywanie
Bardziej szczegółowoProgramowanie w językach
Programowanie w językach wysokiego poziomu Obsługa plików za pomocą strumieni Elektronika i Telekomunikacja, semestr III rok akademicki 2013/2014 dr inż. Paweł Myszkowski Plan zajęć a) otwieranie i zamykanie
Bardziej szczegółowoWykład 5 Wybrane zagadnienia programowania w C++ (c.d.)
Wykład 5 Wybrane zagadnienia programowania w C++ (c.d.) Kontenery - - wektor vector - - lista list - - kolejka queue - - stos stack Kontener asocjacyjny map 2016-01-08 Bazy danych-1 W5 1 Kontenery W programowaniu
Bardziej szczegółowoStos liczb całkowitych
Stos liczb całkowitych class StosInt int* tab; unsigned size ; StosInt(unsigned s=10) tab=new int[size=s];top=0; ~StosInt()delete[] tab; void push(int i)tab[top++]=i; int pop(void) return tab[--top]; int
Bardziej szczegółowoSłowa kluczowe i nazwy
Materiał uzyskany ze strony: http://edu.pjwstk.edu.pl/wyklady/pro/scb/prg2cpp_files/node1.html Słowa kluczowe i nazwy Nazwy (identyfikatory) są wprowadzane do jednostki kompilacji (pliku wraz z innymi
Bardziej szczegółowoTechniki programowania INP001002Wl rok akademicki 2018/19 semestr letni. Wykład 5. Karol Tarnowski A-1 p.
Techniki programowania INP001002Wl rok akademicki 2018/19 semestr letni Wykład 5 Karol Tarnowski karol.tarnowski@pwr.edu.pl A-1 p. 411B Plan prezentacji Przestrzenie nazw Standardowa biblioteka szablonów
Bardziej szczegółowo