Wykład 4 Klasa Vec, której konstruktory alokują pamięć dla obiektów 1.Przykład definicji klasy Vec 2.Definicje konstruktorów i destruktora 3.Definicja operatora przypisania 4.Definicje wybranych operatorów PO4-1 / 28

Klasa wektorów Przykład definicji klasy Vec PO4-2 / 28

Przykład klasy Propozycja budowy obiektu n Rozmiar tablicy naz Nazwa tablicy A Wskaźnik na tablicę A[0]A[1]...A[i]...A[n–1] Alokowany dla obiektu obszar pamięci na tablicę n zmiennych X Pr Zmienne wspólne wszystkim obiektom tej klasy Obiekt PO4-3 / 28

Definicja klasy class Vec { private: int n; // rozmiar tablicy char naz[8]; // tablica na nazwę do 7 znaków double *A; // wskaźnik na tablicę static int Pr; static double X; public: void Nazwa(const char*); // funkcja // konstruktory Vec(char *t=0); // konstruktor bezargumentowy Vec(double a, char *t=0); Vec(int n, double *y, char *t=0); Vec(const Vec &); // konstruktor kopiujący // destruktor ~Vec(); // destruktor... PO4-4 / 28

Definicja klasy c.d.... // przeciążone operatory Vec &operator=(const Vec&); // przypisanie Vec operator+(const Vec&)const; double operator*(const Vec&)const; Vec operator*(double)const; friend Vec operator*(double, const Vec&); double &operator[](int)const; double operator()(double)const; operator double()const; // konwerter Vec -> double friend ostream &operator<<(ostream&,const Vec&); friend istream &operator>>(istream&, Vec&); }; PO4-5 / 28

Metoda Nazwa void Vec::Nazwa(const char *p) { naz[0]='\0'; if(p) strncat(naz, p, 7); } Służy do wpisania nazwy wektora do obiektu PO4-6 / 28

Definicje konstruktorów Przykładowe konstruktory i destruktor PO4-7 / 28

Konstruktor bezparametrowy Konstruktor bezparametrowy ma postać Vec::Vec(char *t):n(0), A(0) { Nazwa(t); } W klasie Vec zadeklarowano konstruktor Klasa() { } Vec(char *t =0); Można go wywołać bez parametrów, jest on zatem konstruktorem bezparametrowym. Jego definicja poza klasą może być następująca PO4-8 / 28

Konwersja konstruktorowa Konstruktor typu Vec::Vec(double a, char *t): n(1), A(new(nothrow) double[1]) { Nazwa(t); if(A) A[0]=a; else n=0; } W klasie Vec zadeklarowano konstruktor Klasa(Typ) {...} definiuje konwersję z typu Typ do typu klasy Vec(double a, char *t=0); Można go wywołać tylko z parametrem a, definiuje on zatem konwersję z typu double do typu Vec. PO4-9 / 28

Konstruktor wieloparametrowy Vec::Vec(int n, double *y, char *t): n(n), A(new(nothrow) double[n]) { Nazwa(t); if(A) for(int i=0; i<n; i++) A[i]=y[i]; else Vec::n=0; } W klasie Vec zadeklarowano konstruktor Vec(int n, double *y, char *t=0); Tworzy on obiekt z tablicy n zmiennych typu double. PO4-10 / 28

Konstruktor kopiujący Konstruktor kopiujący może mieć postać Vec::Vec(const Vec &v): n(v.n), A(v.A?new(nothrow) double[n]:0) { Nazwa(v.naz); if(A) for(int i=0; i<n; i++) A[i]=v.A[i]; else n=0; } W klasie Vec zadeklarowano konstruktor Klasa(Klasa&) {... } Klasa(const Klasa&) {... } Vec(const Vec &); PO4-11 / 28

Domyślny konstruktor kopiujący n naz A n A VW PO4-12 / 28

Przeciążony konstruktor kopiujący n naz A n A VW PO4-13 / 28

Destruktor Destruktor może mieć postać Vec::~Vec() { delete []A; A=0; // Konieczne, aby nie było możliwości // ponownego usunięcia tej pamięci. n=0; } W klasie Vec zadeklarowano destruktor ~Vec(); Jego zadaniem jest usunąć pamięć wskazywaną przez A. ~Klasa( ) {... } PO4-14 / 28

Operator przypisania Przykład definicji operatora przypisania PO4-15 / 28

Operator przypisania Razem z konstruktorem kopiującym należy zdefiniować operator przypisania o postaci Vec &Vec::operator=(const Vec &v) { if(&v = = this) return *this; // gdy X=X; delete []A; n=v.n; A=new(nothrow) double[n]; if(A) for(int i=0; i<n; i++) A[i]=v.A[i]; else n=0; return *this; } W klasie Vec zadeklarowano operator Vec &operator=(const Vec &); Klasa &operator=(const Klasa&) {... } PO4-16 / 28

Domyślne przypisanie V=W n naz A n A VW PO4-17 / 28

Zdefiniowane przypisanie V=W n naz A n A VW PO4-18 / 28

Operatory Przykłady przeciążania wybranych operatorów PO4-19 / 28

Dodawanie wektorów - przykład PO4-20 / 28 Oś 1 Oś 2 Y X x1x1 x2x2 y1y1 y2y2 y1y1 y2y2 Y x 1 +y 1 X+Y x 2 +y 2

Dodawanie wektorów X x1x1 x2x2 x3x3... xnxn Y y1y1 y2y2 y3y3 ynyn X +Y x 1 + y 1 x 2 + y 2 x 3 + y 3... x n + y n Niech będą dane wektory X i Y o współrzędnych: X=[x 1, x 2, x 3,..., x n ], Y=[y 1, y 2, y 3,..., y n ], Suma X+Y jest wektorem o współrzędnych X+Y=[x 1 +y 1, x 2 +y 2, x 3 +y 3,..., x n +y n ]. PO4-21 / 28

Dodawanie Vec Vec::operator+(const Vec &v)const {Vec s; s.n = n >v.n ? n : v.n; s.A = new(nothrow) double[s.n]; if(s.A) {int i; for(i=0; i<n; i++) s.A[i]=A[i]; for( ; i<v.n; i++) s.A[i]=0; for(i=0; i<v.n; i++) s.A[i]+=v.A[i]; } else s.n=0; return s; } A v.A s.A PO4-22 / 28

Iloczym skalarny wektorów Niech będą dane wektory X i Y o współrzędnych: X=[x 1, x 2, x 3,..., x n ], Y=[y 1, y 2, y 3,..., y n ], Iloczyn skalarny jest liczbą o wartości = x 1 y 1 + x 2 y 2 + x 3 y x n y n. PO4-23 / 28

Iloczyn skalarny A v.A double Vec::operator*(const Vec &v)const {double s=0; int k = n <v.n ? n : v.n; for(int i=0; i<k; i++) s += v.A[i]*A[i]; return s; } Przykład double y; Vec v,w;... y = v*w; PO4-24 / 28

Mnożenie wektora przez skalar X x1x1 x2x2 x3x3... xnxn aXaX a x1a x1 a x2a x2 a x3a x3 a xna xn Niech będzie dana liczba rzeczywista a oraz wektor X o współrzędnych: X=[x 1, x 2, x 3,..., x n ]. Iloczyn aX oraz Xa jest wektorem o współrzędnych aX = Xa = [a x 1, a x 2, a x 3,..., a x n ]. PO4-25 / 28

Iloczyn przez stałą Vec Vec::operator*(double a)const {Vec v(*this); for(int i=0; i<v.n; i++) v.A[i]*=a; return v; } Vec operator*(double a, const Vec &v) {return v*a; // v.operator*(a) } Przykład 1 Vec v,w;... v = w*12.0; Przykład 2 Vec v,w;... v = 12.0*w; PO4-26 / 28

Uwagi 1 Przykład 1 Vec v,w;... v = w*12.0; Przykład 2 Vec v,w;... v = 12.0*w; PO4-27 / 28 v = w.operator*(12.0); v = operator*(12.0, w); Nie ma funkcji v = 12.0.operator*(w);

Uwagi 2 Przykład 3 Vec v,w;... v = w+12.0; Przykład 4 Vec v,w;... v = 12.0+w; PO4-28 / 28 v = w.operator+(12.0); Wyrażenie v = operator+(12.0, w); wymaga, aby obok metody operator+ istniała funkcja Vec operator+(double, const Vec&); albo w miejsce obu istniała jedna funkcja Vec operator+(const Vec&, const Vec&); Nie ma funkcji v = w.operator+(double); ale jest konwersja konstruktorowa Vec(double); v = w.operator+(Vec(12.0)); Nie ma funkcji v = 12.0.operator+(w);