Programowanie obiektowe w C++ Wykład 05a Temat wiodący: Static, const, volatile. static, const, volatile

Transkrypt

1 Programowanie obiektowe w C++ Wykład 05a Temat wiodący: Static, const, volatile static, const, volatile 1

2 Static zmienne klasowe zmienna klasowa o atrybucie static jest wspólna dla wszystkich obiektów danej klasy istnieje nawet gdy nie ma żadnego obiektu można się do niej odwoływać za pomocą operatora zakresu class ST static int s; // to jest tylko deklaracja int i; public: static int ps; ; int ST::s=0, ST::ps=0; // jak wyżej // to definicja deklaruje się w klasie, ale definiuje (już bez słowa kluczowego static) poza klasą można zdefiniować tylko raz dla bibliotek: definicje do *.cpp a dekl. klasy do *.h (nie trzeba i nie mozna dodatkowych extern ST::s) 2

3 Static metody mogą wtedy być wołane, nawet gdy nie ma obiektów (za pomocą operatora zakresu) mogą korzystać jedynie ze statycznych pól i metod klasy nie ma wskaźnika this Static metody class ST static int s; int i; public: static int ps; ST(int i=0) :i(i) s++; static void ile_nas() cout << s << "\n"; void wszystko() // nie wolno static!!! cout << s << " " << i cout << " " << ps << "\n"; ; 3

4 void main() int i; // i=s; // nie ma ::s ani ::ps // i=ps; // i=st::s; // private i=st::ps; ST::ile_nas(); // ST::wszystko(); // niestatyczna metoda klasy ST a; ST::ile_nas(); a.ile_nas(); a.wszystko(); const --- stałe const, volatile const int ci =7; volatile --- ulotne volatile int vi=8; i++; i--; i=i+0; 4

5 const, volatile obiekty również mogą być stałe bądź ulotne na rzecz obiektów stałych bądź ulotnyvh można aktywować jedynie metody uprzywilejowane metody uprzywilejowane definiujemy podając po nawiasie zamykającym listę argumentów słowa kluczowe const i/lub volatile. UWAGA: uprzywilejowanie metody może powodować jej przeciążenie: int f(); int f() const; class CV int i; public: CV(int i=1) :i(i) ; void out() cout << i; void out() const volatile cout << i; void inc() i++; void inc_c() const // i++; // i jest const void inc_v() volatile i++; void inc_cv() const volatile // i++; ; 5

6 void main() CV cv; const CV cvc; volatile CV cvv; const volatile CV cvcv; cv.inc(); cv.inc_c(); cv.inc_v(); cv.inc_cv(); // cvc.inc(); cvc.inc_c(); // cvc.inc_v(); cvc.inc_cv(); // cvv.inc(); // cvv.inc_c(); cvv.inc_v(); cvv.inc_cv(); // cvcv.inc(); // cvcv.inc_c(); // cvcv.inc_v(); cvcv.inc_cv(); cv.out(); //CV::out(); cvc.out(); //CV::out() const volatile; cvv.out(); cvcv.out(); const, volatile metody uprzywilejowane nie mogą być static. konstruktor ani destruktor nie może być const volatile ani static. deklarowanie metod uprzywilejowanych nie może prowadzić do niejednoznaczności int f() const; // int f() const volatile; 6

7 Przykład: pola const i static class info static int cntr, // licznik istniejacych obiektow serial; // statyczna zmienna pomocnicza const int nr; // unikalny numer seryjny obiektu public: info() info(const info & i); ~info(); info & operator=(const info &p); ; int info::cntr=0, info::serial=0; // static // static info::info() :nr(++serial) cntr++; cout << "\nkonstruktor bezparametrowy obiektu nr" << nr; cout << " jest " << cntr << " obiektow info"; cout.flush(); info::info(const info & i) :nr(++serial) cntr++; cout << "\nkonstruktor kopiujacy obiektu nr" << nr << " z obiektu " << i.nr; cout << " jest " << cntr << " obiektow info"; cout.flush(); 7

8 info::~info() cntr--; cout << "\ndestruktor obiektu nr" << nr; cout << " zostanie " << cntr << " obiektow info"; cout.flush(); info & info::operator=(const info &p) cout << "\noperator przypisania do obiektu nr " << nr; cout << " z obiektu nr" << p.nr; cout << " jest " << cntr << " obiektow info"; cout.flush(); return *this; this dostępny w każdej niestatycznej metodzie jest to wskaźnik do obiektu na rzecz którego wywołano metodę można go wykorzystać jeżeli mamy zwrócić wskaźnik bądź referencję do obiektu na rzecz którego wywoływana jest metoda nie zajmuje pamięci nie wymaga deklarowania 8

9 this person & person::timetravel(int years) age += years; return *this; person Boss(40, John, Kovalsky ); ( Boss.timeTravel(+20) ).timetravel(-30) friend po polsku zaprzyjaźnianie jest to deklaracja znosząca ograniczenia dostępu do składowych klasy przez ściśle określony kod 9

10 friend class A friend C::theMethodNoArg(); // dotyczy konkretnej metody, tu bezargumentowej friend class B; // dotyczy całej deklaracji klasy B // również deklaracje wewnątrz B mają dostęp // do pól prywatnych A friend fun(); // dotyczy konkretnej funkcji, tu bezargumentowej friend zaprzyjaźnianie nie podlega dziedziczeniu zaprzyjaźnianie nie jest przechodnie deklarowane w dowolnej sekcji (nawet prywatnej) klasy 10

11 friend class M friend void f() ; jest równoważne class M friend void f(); ; void f() Co to jest operator? Operatory a = b.val >> 4 + c * d[ e++ ] 11

12 Operatory operator definiuje operacje wykonywane na swoich argumentach i typ wyniku takiej operacji analogicznie do funkcji. w C++ można definiować znaczenie operatorów w przypadku wykorzystania ich do obiektów (przynajmniej jeden argument obiektowy). Operatory Można przeciążać większość operatorów Przeciążanie może poprawić wydajność Nie ma obowiązku a zwykle nie ma i potrzeby definiowania wielu operatorów, jeżeli operator byłby sporadycznie używany to zaleca się deklarowanie go jako metody bądź zwykłej funkcji. 12

13 Operatory które można przeciążać () [] -> ! ~ * & new delete (typ) // jednoargumentowe ->* * / % + - << >> < <= > >= ==!= & ^ && = += -= *= /= %= &= ^= = <<= >>= // op. przypisania Operatory nie można przeciążać operatorów:..* ::?: sizeof operatory, które mogą być jedynie metodami klasy: () [] -> new delete (typ) = operatory domniemane, jeżeli nie zdefiniowane: = & 13

14 Łączność operatory przypisania i jednoargumentowe są prawostronnie łączne a=b=c oznacza a=(b=c) pozostałe lewostronnie a+b+c oznacza (a+b)+c Kolejność wartościowania kolejność wartościowania argumentów niezdefiniowana, za wyjątkiem:, &&,,, && najpierw wartościowany lewy argument, potem prawy dla operacji logicznych stosowane jest skrócone wartościowanie. 14

15 Operatory a metody inna składnia deklaracji, definicji i wywołania operatory nie mogą mieć argumentów domyślnych (wyjątek: operator wywołania funkcji) określona jest liczba argumentów (wyjątek: operator wywołania funkcji) przyjęte jest zwyczajowe znaczenie operatorów Operatory Chcesz += to zdefiniuj go, nie wystarczy zdefiniować + i = Chcesz ++ to zdefiniuj go, kompilatorowi nie wtstarczy + i = Zachowaj wierność zwyczajowemu znaczeniu operatorów niech jednoarg. & zwraca adres Zachowaj konsekwencję ++i; i++; i+=1; i=i+1; // powinny dawać taki sam efekt. 15

16 Operatory jako metody pierwszy argument będzie obiektem klasy metoda ma mniej argumentów niż operator deklarowanie int point::operator<=(point); wywoływanie point point1, point2; int i= point1 <= point2; int j= point1.operator<=(point2); Operatory jako funkcje przynajmniej jeden z argumentów musi być obiektem wszystkie argumenty są parametrami funkcji operatorowej nie ma this deklarowanie wywoływanie int operator<=(point, point); point point1, point2; int i = point1 <= point2; int j= operator<=(point1, point2); 16

17 Konwencja dla operatorów ++ i -- operator++() i operator--() są przedrostkowe ++i --i operatory przyrostkowe deklarujemy i definiujemy z dokładnie jednym nienazwanym parametrem int: operator++(int); operator--(int); i++ i-- Konwencja dla operatorów ++ i -- class X public: X& operator++(); X operator++(int); ; // prefix ++a // postfix a++ class Y public: ; Y& operator++(y&); Y operator++(y&, int); // prefix ++b // postfix b++ 17

18 Konwencja dla operatorów ++ i -- void f(x a, Y b) ++a; // a.operator++(); a++; // a.operator++(0); ++b; // operator++(b); b++; // operator++(b, 0); a.operator++(); // odpowiada ++a; a.operator++(0); // odpowiada a++; operator++(b); // odpowiada ++b; operator++(b, 0); // odpowiada b++; Operatory class X // składowe z niejawnym this X* operator&(); // przedrostkowy, jednoargumentowy & X operator&(x); // dwuargumentowy X operator++(int); // przyrostkowy // X operator&(x, X); // blad trzyargumentoowy // X operator/(); // blad jednoarg. ; // funkcje globalne, bez this, często zaprzyjazniane X operator-(x); // przedrostkowy X operator-(x, X); // dwuargumentowy X operator--(x&, int); // przyrostkowy dekrementacja // X operator-(x, X, X); // blad trzyargumentoowy // X operator/(); // blad jednoarg. 18

19 Operator przypisania Musi być zdefiniowany jako metoda (niestatyczna) a nie jako funkcja T& T::operator=(const T &) Nie ma listy inicjalizacyjnej bo to nie jest konstruktor!!! Operator przypisania person& person::operator=(const person &o) if (this == &o) // Tom = Tom; return *this; delete name; name=new char[strlen(o.name) + 1]; strcpy(name, o.name); delete lastname; lastname=new char[strlen(o.lastname) + 1]; strcpy(lastname, o.lastname); age=o.age; return *this; // zwraca obiekt, będzie przekazany przez referencje 19

20 Operator przypisania dlaczego operator przypisania zwraca referencję? chcemy napisać o1=o2=o3; person& operator=(const person&); przypisania do: o2 z: o3 operator przypisania do: o1 z: (o2=o3) person operator=(const person&); przypisania do: o2 z: o3 konstruktor kopiujący (powstaje tymczasowy obiekt t1) operator przypisania do: o1 z: t1 konstruktor kopiujący (powstaje tymczasowy obiekt t2) destruktor t2 destruktor t1 Operator przypisania dlaczego operator przypisania zwraca referencję? chcemy napisac o1=o2=o3; void operator=(const person&); można o2=o3; nie da się o1=o2=o3; 20

21 Operator przypisania generowany automatycznie jeżeli się nie zdefiniuje operatora przypisania to kompilator dostarczy własny operator przypisania, który skopiuje obiekt pole po polu. nie będzie działał dla pól stałych nie będzie działał dla dla referencji dla wskaźników skopiuje wartość Operatory strumieniowe Wejście friend istream & operator >>(istream &, T &); Wyjście friend ostream &operator <<(ostream &, const T &); 21

22 Operatory strumieniowe class point int x, y; public: friend istream &operator >>(istream & s, point & p); friend ostream &operator <<(ostream & s, const point &); point p, p2; cin>>p; cin>>p>>p2; cout<<p2<<p; Operatory strumieniowe istream & operator >>(istream & s, point & p) s >> p.x >> p.y; return s; ostream &operator <<(ostream & s, const point & p) s << p.x << p.y; return s; 22

23 T t; Operator wyłuskania T* operator->(); t->m jest interpretowane jako: ( t.operator-> )->m można używać zmiennej jak wskaźnika jeżeli operator-> nie zwraca wskaźnika to można użyć go: a=t.operator->(); nie można: a=t->; bo to błąd składniowy Operator wywołania funkcji wynik T::operator()(args); Dowolna liczba argumentów, można przeciążać Wyjątek: tylko ten operator może mieć domyślne argumenty potem można obiekt używać tak, jak funkcję T ob; ob(); stosuje się gdy nie istnieje odpowiedni operator, a by się przydał jest jakś metoda dominująca dla klasy (będzie bez nazwy ale łatwiejsza do wywołania np. klasa counter i metoda inkrementacja) 23

24 operator indeksowania wynik T::operator[](index); typy wyniku i indeksu dowolne ale zdrowy rozsądek nakazuje indeks całkowity można tworzyć inteligentne agregaty, Operator konwersji operator konwersji tworzy obiekt określonego typu lub klasy z obiektu na rzecz którego jest wywoływany T::operator X(); operator konwersji klasy T do typu X: nie określa się jawnie typu wartości zwracanej, jest bezargumentowy musi być metodą (nie funkcją) 24

25 Operator konwersji np.: person::operator int(); konwersja może następować niejawnie: person o; int i=o+5; W wyrażeniach dla danego obiektu konwersja jest stosowana tylko jeżeli jest konieczna, może być tylko jedna konwersja danego składnika definiowana przez użytkownika nie może być niejednoznaczności Operator konwersji np. dla klas: A, B i C, zdefiniowano operatory konwersji B::operator A() i C::operator B(); int f(a a); A a; B b; C c; f(a); // ok.. f(b); // f(a(b)) // f(c); // nie ma operatora C::operator A() // nie zrobi się niejawnie f(a(b(c))) // (2 konwersje skladnika) 25

26 Operator konwersji aby przekształcić obiekt jednego typu w obiekt innego typu można jawnie użyć konstruktora, ale: nie da się przeprowadzić przekształcenia do typu podstawowego (np. int, bo to nie klasa), nie da się przekształcić do starej klasy bez modyfikowania jej definicji. Przykład class counter int cnt; public: counter(int = 0):cnt(0); int operator()(int =1); // increment by arg. or by 1 operator int(); // convert to int operator double(); // convert to double counter &operator+=(int); friend counter operator+(int, counter); // int+counter, friend counter operator+(int); // counter+int int operator++(); // ++counter int operator++(int); // counter++ ; 26

27 inline int counter::operator ()(int i) return cnt+=i; ; inline counter::operator int() return cnt; ; inline counter::operator double() return double(cnt); ; Przykład Przykład counter & counter::operator +=(int i) cnt+=i; // operator()(i); (*this)(i) return *this; ; counter operator+(int i, counter l) l+=i; // zaprzyjaźnianie nie było konieczne return l; ; 27

28 counter counter::operator +(int i) counter l=*this; l+=i; return l; ; Przykład int counter::operator ++() cnt+=1; return cnt; ; int counter::operator ++(int) int ret=cnt; cnt+=1; return ret; ; Przykład class complex double re, im; public: complex(double re, double im):re(re), im(im) ; complex & operator = (const complex &c); complex & operator += (const complex &c); complex operator + (const complex &); friend complex & operator -= (complex &, const complex &); friend complex operator - (const complex &, const complex &); friend istream & operator >>(istream &, complex &); friend ostream & operator <<(ostream &, const complex &); ; 28

29 Przykład complex & complex::operator = (const complex &c) re=c.re; im=c.im; return *this; ; Przykład complex & complex::operator += (const complex &c) re+=c.re; im+=c.im; return *this; ; inline complex complex::operator + (const complex & c) return complex(re+c.re, im+c.im); // complex(double, double) 29

30 Przykład inline complex & operator-=(complex & c1, const complex & c2) c1.re-=c2.re; c1.im-=c2.im; //friend return c1; complex operator-(const complex & c1, const complex & c2) complex c=c1; c-=c2; //friend return c; Przykład istream & operator >>(istream & s, complex & c) s >> c.re >> c.im; return s; ostream &operator <<(ostream & s, const complex & c) s << c.re << c.im; return s; 30