Visual C++ 6.0 - Programowanie obiektowe

Visual C++ 6.0

Programowanie obiektowe

9. Klasy pierwotne

10. Klasy pochodne

11. Metody wirtualne

12. Projektowanie kolekcji

13. Studium projektowe

Dodatki

Błędy programowania

Klasy pierwotne

Za przykład klasy pierwotnej niech posłuży klasa definiująca pojęcie liczba zespolona. Jak wiadomo (albo nie!), liczba zespolona jest uporządkowaną parą liczb rzeczywistych. Do zapisu liczby zespolonej o składnikach a i b używa się notacji

a + bi

o tak dobranym i, że i² = -1.

Stąd łatwo już wynika, że

(a+bi) + (c+di) == (a+c) + (b+d)i

oraz że

(a+bi) * (c+di) == (a*c - b*d) + (a*d + b*c)i

Składnik a jest nazywany częścią rzeczywistą (re), a składnik b częścią urojoną (im) liczby zespolonej.

#include <iostream.h>

struct Cplx ;

Cplx add(Cplx &parL, Cplx parR);

int main(void)

two = ;

Cplx sum = add(one, two);

char *plus = '+';

if(sum.im < 0)

plus = '';

cout << sum.re << plus << sum.im << 'i' << endl;

return 0;

Cplx add(Cplx &parL, Cplx parR)

return sum;

Definicja typu strukturowego Cplx jest opisem pojęcia liczba zespolona. Egzemplarzami typu są zmienne one, two i sum.

Program wyznacza sumę dwóch liczb zespolonych i wyprowadza ją w postaci 3 + 7i.

Hermetyzacja

Przytoczone rozwiązanie ma tę wadę, że inicjowanie i przetwarzanie zmiennych struktury Cplx jest uciążliwe, a każdy użytkownik klasy może bez ograniczeń posługiwać się nazwami jej pól re i im.

Dlatego podczas definiowania klas stosuje się hermetyzację. Polega ona na tym, że słowo kluczowe struct zastępuje się słowem class, a zestawy składników klasy umieszcza w sekcjach private (prywatny), public (publiczny)  i protected (chroniony).

Uwaga: Typy zadeklarowane z użyciem słowa kluczowego class są nazywane klasami, a opisane przez nie zmienne są nazywane obiektami. Różnica między typami obiektowymi i strukturowymi polega jedynie na domniemaniach hermetyzacji. Dlatego każdy obiekt jest strukturą, a każda struktura jest obiektem.

dla dociekliwych

Każda deklaracja

struct Any ;

jest równoważna deklaracji

class Any ;

a każda deklaracja

class Any ;

jest równoważna deklaracji

class Any ;

a zatem różnice między strukturami i klasami są niemal żadne.

Podział na sekcje

Umieszczenie składnika w sekcji prywatnej oznacza, że będą mogły się nim posługiwać tylko składniki jego klasy oraz funkcje zaprzyjaźnione z jego klasą.

Uwaga: W celu zaprzyjaźnienia funkcji z klasą, należy w dowolnej sekcji klasy umieścić deklarację funkcji poprzedzoną słowem kluczowym friend.

Umieszczenie składnika w sekcji publicznej oznacza, że będą mogły się nim posługiwać wszystkie funkcje i wszystkie składniki.

Umieszczenie składnika w sekcji chronionej oznacza, że będę mogły się nim posługiwać tylko składniki jego klasy, funkcje zaprzyjaźnione z jego klasą oraz składniki jego klasy pochodnej.

Uwaga: Umieszczenie składnika (np. konstruktora albo operatora przypisania) w sekcji prywatnej, uniemożliwia używanie go poza klasą. Ten prosty zabieg funkcjonuje jak zakaz używania wybranych składników klasy.

#include <iostream.h>

class Cplx

void show(void)

Cplx add(Cplx &parL, Cplx parR)

int main(void)

Składniki re i im są prywatne, a składniki Cplx i show są publiczne.

Funkcja show nie jest składnikiem, ale jako zaprzyjaźniona z klasą Cplx, może odwoływać się do wszystkich jej składników, w tym do prywatnych składników re i im.

Składniki klasy

Składnikami klasy są pola, konstruktory, destruktory i metody. Deklaracja składnika może być umieszczona w sekcji prywatnej, publicznej albo chronionej.

Konstruktory

Konstruktorem jest składnik, który służy do inicjowania elementów struktury. Nazwa konstruktora jest identyczna z nazwą klasy. Deklaracja konstruktora ma postać deklaracji funkcji, ale nie może zawierać określenia typu rezultatu.

class Cplx

Cplx(double r)

Cplx(void)

//

Dzięki zdefiniowaniu konstruktorów stają się poprawne następujące deklaracje

Cplx numA(3,4);

Cplx numB(5);

Cplx numC;

Konstruktor domyślny

Konstruktor, który może być użyty bez podania argumentów jest nazywany domyślnym. Zazwyczaj jest nim konstruktor bezparametrowy.

Uwaga: Jeśli w klasie nie zdefiniuje się ani jednego konstruktora, to jest ona niejawnie wyposażana w konstruktor bezparametrowy o pustym ciele. Jest on wówczas konstruktorem domyślnym.

class Cplx

//

Argumenty domniemane

Konstruktory mogą mieć argumenty domniemane. Ich użycie upraszcza definicję klasy.

class Cplx

//

Mimo zdefiniowania tylko jednego konstruktora, są poprawne następujące deklaracje

Cplx numA(3, 4);

Cplx numB(5);

Cplx numC;

Lista inicjacyjna

Za nagłówkiem konstruktora, po znaku : (dwukropek), występuje lista inicjacyjna. Jej elementami są napisy

fld(exp, exp, , exp)

w których fld jest identyfikatorem pola, a każde exp jest listą wyrażeń (zazwyczaj jednoelementową).

Opracowanie elementu listy inicjacyjnej powoduje użycie wyrażeń exp do zainicjowania tego elementu obiektu, który jest opisany przez pole fld.

Jeśli w miejscu wystąpienia wyrażenia exp, nie jest widoczny identyfikator pola (gdyż został przesłonięty przez identyfikator parametru konstruktora), to nazwą pola fld klasy Name jest Name::fld.

Uwaga: Jeśli konstruktor nie ma listy inicjacyjnej, to domniemywa się ją pustymi wyrażeniami exp. W takim wypadku, elementy typów nieobiektowych (np. int) są inicjowane wartościami nieokreślonymi, a elementy typów obiektowych są inicjowane przez konstruktory domyślne.

class Cplx

//

W inicjatorze re(re) pierwsze re jest identyfikatorem pola, a drugie jest identyfikatorem parametru.

Gdyby użyto inicjatora im(re * Cplx::re), to argumentami operacji byłaby nazwa parametru i nazwa pola.

Konstruktor kopiujący

Konstruktorem kopiującym klasy Name jest konstruktor używany do inicjowania jej obiektu elementami innego obiektu klasy Name. Konstruktor kopiujący jest jednoparametrowy, a jego parametr jest typu const Name &.

Cplx numA(3, 4),

numB(numA),

numC = numB;

Jeśli definicja klasy nie zawiera konstruktora kopiującego, to jest niejawnie uzupełniana definicją takiego publicznego konstruktora, który inicjuje elementy obiektu elementami obiektu inicjującego. Oznacza to, że dla klasy Cplx domniemany konstruktor kopiujący jest zdefiniowany przez funkcję

Cplx(const Cplx &par) : re(par.re), im(par.im)

Uwaga: Inicjowanie realizowane przez domniemany konstruktor kopiujący polega na kopiowaniu-płytkim. Jeśli klasa zawiera pola wskaźnikowe lub odnośnikowe, to kopiowanie-płytkie może okazać się niezadowalające. W takim wypadku należy zdefiniować własny konstruktor kopiujący, który wykona kopiowanie-głębokie (uwzględniające klonowanie zmiennych identyfikowanych przez wskaźniki i odnośniki).

class Cplx

Cplx(const Cplx &par) : re(par.re), im(par.im)

//

Użycie własnego konstruktora kopiującego jest zbyteczne, ponieważ domniemany konstruktor kopiujący dla klasy Cplx ma dokładnie taką samą definicję.

dla dociekliwych

Może powstać pytanie, kiedy do nadawania wartości początkowych elementom obiektu używać listy inicjacyjnej, a kiedy używać instrukcji w ciele konstruktora.

Jeśli pola są typu nieobiektowego (np. int albo char *), to skutek jest taki sam. Ale jeśli elementy obiektu są typu obiektowego, to różnica może być istotna. Wynika to stąd, że nadawanie wartości za pomocą listy ma semantykę inicjowania, a nadawanie wartości za pomocą instrukcji, ma semantykę przypisywania. Dlatego zaleca się używanie listy inicjacyjnej.

Destruktory

Destruktorem jest składnik, który służy do wykonania czynności poprzedzających zniszczenie obiektu. Nazwą destruktora jest połączenie znaku ~ (tylda) i nazwy klasy. Deklaracja konstruktora ma postać deklaracji funkcji, ale nie może zawierać określenia typu rezultatu. Destruktor jest bezparametrowy i nie może być przeciążony.

Uwaga: Destruktor jest wywoływany niejawnie. Można go wywołać jawnie, ale wówczas należy naprawdę dobrze wiedzieć co się robi. Dlatego taki sposób postępowania lepiej zostawić zawodowcom.

#include <iostream.h>

class Cplx

~Cplx(void)

void show(void)

int main(void)

return 0;

Wykonanie programu powoduje wyprowadzenie napisu

Constructing: 1+2i

Constructing: 3+4i

Destructing: 3+4i

Destructing: 1+2i

Potwierdza się fakt, że obiekty automatyczne są niszczone w kolejności odwrotnej do kolejności ich tworzenia.

Metody

Jeśli składnikiem klasy Name jest metoda fun, a obiektem tej klasy wskazanym przez ptr jest obj, to

ptr->fun(arg, arg, , arg)

oraz

obj.fun(arg, arg, , arg)

jest wywołaniem metody fun na rzecz obiektu obj.

Uwaga: Metoda może być wywołana tylko na rzecz obiektu. Jeśli wyrażenie *ptr albo obj nie jest nazwą obiektu, to nie poddaje się go niejawnej konwersji. Dlatego poprawna może być m.in. operacja obj + '!', ale nie jest poprawna operacja '!' + obj, chyba że operator + zdefiniowano za pomocą funkcji globalnej.

W chwili wywołania metody jest tworzony wskaźnik this typu Name *, zainicjowany wskazaniem obiektu obj. Podczas wykonywania metody fun, trwałą nazwą tego obiektu jest *this, a nazwą jego składnika m jest (*this).m albo prościej:  this->m.

Uwaga: Jeśli w miejscu wystąpienia this->m jest widoczna deklaracja składnika m, to this->m można uprościć do m.

#include <iostream.h>

class Cplx {

protected:

double re, im;

public:

Cplx(double r, double i) : re(r), im(i)

Cplx add(Cplx &par)

void show(void)

int main(void)

W ciele funkcji add obiekt one ma nazwę *this, a jego elementy mają nazwy this->re i this-im.

Funkcje operatorowe

Funkcją operatorową jest funkcja o nazwie

operator

w której @ jest jednym operatorów wymienionych w tabeli Operatory.

Tabela Operatory

new delete

+ - * / % ^ & | ~

! = < > += -= *= /= %=

^= &= |= << >> >>= <<= == !=

<= >= && || ++ -- , () []

-> ->*

Funkcja operatorowa może być funkcją globalną albo metodą klasy. Operator może być zdefiniowany przez funkcję globalną tylko wówczas, gdy ma ona co najmniej jeden argument obiektowy. Operatory =, [], () i -> mogą być definiowane tylko przez metody.

Operatory jednoargumentowe

Jeśli w pewnym miejscu programu występuje operacja

a

w której a jest wyrażeniem typu obiektowego, to jest traktowana jak wywołanie

operator (a)

jednoparametrowej funkcji globalnej operator@.

Jeśli takiej funkcji nie ma, to jest traktowana jak wywołanie

a.operator

bezparametrowej metody należącej do klasy obiektu a.

Jeśli w pewnym miejscu programu występuje operacja

a--

albo

a++

to, dla odróżnienia od operacji poprzednikowej, jest traktowana tak, jak wywołanie funkcji z dodatkowym parametrem typu int.

Uwaga: Jeśli istnieje funkcja globalna, to zabrania się, aby w klasie obiektu a istniała metoda bezparametrowa.

#include <iostream.h>

class Cplx {

friend Cplx operator~(Cplx &par);

friend void operator++(Cplx &par, int);

friend ostream &operator<<(ostream &out, Cplx &par);

protected:

double re, im;

public:

Cplx(double r, double i) : re(r), im(i)

Cplx operator-(void)

void operator++(void)

Cplx operator~(Cplx &par)

void operator++(Cplx &par, int)

ostream &operator<<(ostream &out, Cplx &par)

int main(void)

Operacja -one jest traktowana jak wywołanie operator-(one) i jest realizowana przez funkcję globalną, zaprzyjaźnioną z klasą.

Operacja ~-one jest traktowana jak wywołanie one.operator<<(-one) i jest realizowana przez metodę klasy.

Operacja ++two zwiększa o 1 wartość części rzeczywistej, a operacja two++ zwiększa o 1 wartość części urojonej. Operacja ++two jest traktowana tak, jak wywołanie two.operator++(), a operacja two++ jest traktowana tak, jak wywołanie operator ++(two, 0).

Operatory dwuargumentowe

Jeśli w pewnym miejscu programu występuje operacja

a b

w której a albo b jest wyrażeniem typu obiektowego, to jest traktowana jak wywołanie

operator (a, b)

dwuparametrowej funkcji globalnej operator@.

Jeśli takiej funkcji nie ma, to jest traktowana jak wywołanie

a.operator (b)

jednoparametrowej metody należącej do klasy obiektu a.

Uwaga: Jeśli istnieje funkcja globalna, to zabrania się, aby w klasie obiektu a istniała metoda, którą można by wywołać z argumentem b.

#include <iostream.h>

class Cplx {

friend ostream &operator<<(ostream &out, Cplx &par);

protected:

double re, im;

public:

Cplx(double r, double i) : re(r), im(i)

Cplx operator+(Cplx &par)

ostream &operator<<(ostream &out, Cplx &par)

int main(void)

Operacja one + two jest traktowana jak wywołanie one.operator+(two) i jest realizowana przez metodę klasy.

Operacja cout << sum jest traktowana jak wywołanie operator<<(cout, sum) i jest realizowana przez funkcję globalną zaprzyjaźnioną z klasą.

Operatory specjalne

Niektóre operatory muszą być implementowane przez metody. Są nimi = (przypisanie), [] (indeksowanie), -> (wybranie) i () (wywołanie). Ostatni z nich może być wieloargumentowy.

Jeśli w klasie nie zdefiniowano operatora  przypisania, to jest domniemywany w postaci publicznej metody, realizującej kopiowanie-płytkie.

Uwaga: Rezultatem domniemanego przypisania jest odnośnik do lewego argumentu. Oznacza to, że dla klasy Cplx domniemana operacja przypisania jest zdefiniowana przez funkcję

Cplx &operator=(const Cplx &par)

Uwaga: Inicjowanie realizowane przez domniemany operator przypisania polega na kopiowaniu-płytkim. Jeśli klasa zawiera pola wskaźnikowe lub odnośnikowe, to może okazać się niezadowalające. W takim wypadku należy zdefiniować własny operator przypisania, który wykona kopiowanie-głębokie (uwzględniające klonowanie zmiennych identyfikowanych przez wskaźniki i odnośniki).

Konwertery

Konwerterem jest metoda, która definiuje konwersję obiektu jej klasy na obiekt typu docelowego.

Jeśli w pewnym miejscu występuje operacja

(Type)a

w której a wyrażeniem typu obiektowego, a Type jest nazwą typu docelowego, to jest traktowana jak wywołanie

a.operator Type

bezparametrowej metody operator Type zdefiniowanej w klasie obiektu a.

#include <iostream.h>

#include <math.h>

class Cplx {

friend ostream &operator<<(ostream &out, Cplx &par);

protected:

double re, im;

public:

Cplx(double r, double i) : re(r), im(i)

operator double(void)

ostream &operator<<(ostream &out, Cplx &par)

int main(void)

Operacja (double)one jest traktowana jak wywołanie one.operator double().

Niejawne konwersje

W każdym miejscu, gdzie typ wyrażenia jest niezgodny z typem inicjowanej nim zmiennej, może być zastosowana niejawna konwersja standardowa, konstruktorowa albo konwerterowa. Konwersja konstruktorowa jest określona przez konstruktor, a konwerterowa przez konwerter. Wymaga się, aby zastosowana konwersja była jednoznaczna.

#include <iostream.h>

class Cplx {

private:

double re, im;

public:

Cplx(double re =0, // =(double)0

double im =0) // =(double)0

: re(re), im(im)

operator double(void)

Cplx num = 12;  // Cplx(12)

int main(void)

Składniki statyczne

Składnik statyczny klasy jest zadeklarowany ze specyfikatorem static. Jest on w istocie elementem klasy, a nie obiektu i istnieje nawet wówczas, gdy nie utworzono ani jednego obiektu klasy. Nazwą statycznego składnika mem klasy Class jest Class::mem.

Funkcja statyczna nie ma wskaźnika this, a więc nie może odwoływać się do pól nie-statycznych. Pole statyczne należy zadeklarować w klasie i zdefiniować poza klasą (obecnie także i w klasie). Domyślnym inicjatorem pola statycznego jest = 0.

#include <iostream.h>

class Real

~Real(void)

static int getCount(void)

int Real::count = 0;  // definicja

int main(void)

cout << Real::getCount() << endl; // 1

return 0;

Metoda statyczna getCount dostarcza informacji o liczbie obiektów klasy Real.

Dystrybucja klasy

Przetestowana definicja klasy, uzupełniona o wspomagające ją funkcje globalne jest dystrybuowana w postaci źródłowego pliku nagłówkowego i binarnego pliku implementacyjnego. Użytkownik klasy włącza do swoich modułów nagłówek klasy i dołącza do swojego projektu plik implementacyjny.

Klasa Cplx

Przytoczona tu klasa zawiera przykładowy zestaw składników i funkcji wspomagających. Ponieważ składniki funkcyjne zdefiniowane w ciele klasy są domyślnie otwarte (inline), więc aby uczynić je zamkniętymi można je zdefiniować poza ciałem klasy.

Uwaga: Identyfikator składnika zdefiniowanego poza ciałem klasy musi być poprzedzony kwalifikatorem zakresu Name::, w którym Name jest nazwą jego klasy.

#include <iostream.h>

#include <math.h>

class Cplx {

friend inline double sqrt(Cplx &par);

protected:

double re, im;

public:

Cplx(double re =0, double im =0) : re(re), im(im)

~Cplx(void)

operator double(void)

Cplx operator+(Cplx &par);

Cplx operator~(void)

void putCplx(ostream &out)

void getCplx(istream &inp)

}

char drop;

inp >> drop;

}

Cplx Cplx::operator+(Cplx &par)

double sqrt(Cplx &par)

ostream &operator<<(ostream &out, Cplx &par)

istream &operator>>(istream &inp, Cplx &par)

int main(void)

Aby nie zaprzyjaźniać funkcji operatorowych operator<< i operator>> z klasą Cplx użyto w nich publicznych metod putCplx i getCplx.

Plik nagłówkowy

W pliku nagłówkowym pozostawia się deklaracje jej składników i funkcji wspomagających oraz definicje składników i funkcji wspomagających zadeklarowanych (jawnie albo niejawnie) ze specyfikatorem inline.

W nagłówku pozostawia się argumenty domniemane, ale usuwa się z niego listy inicjacyjne (wraz z dwukropkami).

Uwaga: Deklaracje nagłówka obudowuje się zazwyczaj dyrektywami #ifndef, #define i #endif. Dzięki temu unika się błędów spowodowanych więcej niż jednokrotnym włączeniem nagłówka do tego samego pliku źródłowego.

#ifndef CPLX

#define CPLX

#include <iostream.h>

#include <math.h>

class Cplx ;

double sqrt(Cplx &par);

ostream &operator<<(ostream &out, Cplx &par);

istream &operator>>(istream &inp, Cplx &par);

#endif

Plik implementacyjny

Plik implementacyjny zawiera dyrektywę #include włączającą nagłówek oraz definicje tych wszystkich funkcji, które zadeklarowano (tylko zadeklarowano!) w nagłówku.

W pliku implementacyjnym pozostawia się listy inicjacyjne i specyfikatory virtual, ale usuwa się z niego argumenty domniemane.

#include 'cplx.h'

#include <iostream.h>

#include <math.h>

Cplx::Cplx(double re, double im) : re(re), im(im)

Cplx::~Cplx(void)

Cplx::operator double(void)

Cplx Cplx::operator~(void)

void Cplx::putCplx(ostream &out)

void Cplx::getCplx(istream &inp)

}

char drop;

inp >> drop;

Cplx Cplx::operator+(Cplx &par)

double sqrt(Cplx &par)

ostream &operator<<(ostream &out, Cplx &par)

istream &operator>>(istream &inp, Cplx &par)

Program testujący

#include <iostream.h>

#include <math.h>

#include 'cplx.h'

int main(void)

Klasy pochodne

Klasą pochodną jest klasa, która wywodzi się od klasy bazowej wyszczególnionej na liście dziedziczenia.. Klasę pochodną tworzy się wówczas, gdy jej klasie bazowej brakuje pewnych składników, ale gdy nowej klasy nie chce się definiować od początku.

class Derived

: public Base1, public Base2

Klasa Derived pochodzi od klas Base1 i Base2 wyszczególnionych na liście dziedziczenia.

Dziedziczenie i inicjowanie

Klas pochodna dziedziczy wszystkie składniki klasy bazowej, ale nie dziedziczy konstruktorów i operatorów przypisania.

Każdy obiekt klasy pochodnej składa się z takich samych elementów z jakich składa się obiekt klasy bazowej oraz z tych dodatkowych elementów, które są opisane przez pola klasy pochodnej.

Inicjowanie elementów klasy bazowej odbywa się za pomocą konstruktora klasy bazowej, wywołanego z listy inicjacyjnej konstruktora klasy pochodnej.

Uwaga: Tę część obiektu klasy pochodnej, która jest obiektem klasy bazowej nazywa się podobiektem klasy pochodnej.

class Real {

protected:

double re;

public:

Real(double re) : re(re)

class Cplx : public Real {

protected:

double im;

public:

Cplx(double re, double im) : Real(re), im(im)

Obiekt klasy Cplx składa się z elementów opisanych przez pole re klasy Real i pole im klasy Cplx.

Element listy inicjacyjnej Real(re) służy do zainicjowania tej części obiektu klasy Cplx, która jest podobiektem klasy Real.

Identyfikowanie podobiektów

Jeśli klasa Derived wywodzi się od klasy Primary, a obiekt objD klasy Derived zawiera obiekt objP klasy Primary, to

(Primary &)objD jest nazwą podobiektu objP

(Derived &)objP jest nazwą obiektu objD

(Primary *)&objD jest wskaźnkiem na podobiekt objP

(Derived *)&objP jest wskaźnikiem na obiekt objD

*(Primary *)&objD jest nazwą podobiektu objP

*(Derived *)&objP jest nazwą obiektu objD

Uwaga: Konwersja odnośnika-do-obiektu na odnośnik-do-jego-podobiektu oraz konwersja wskaźnika-na-obiekt we wskaźnik-na-podobiekt jest konwersją standardową i jako taka może być wykonana niejawnie.

#include <iostream.h>

class Real

Real(const Real &par) : pRe(new double)

~Real(void)

Real &operator=(Real &par)

ostream &operator<<(ostream &out, Real &par)

class Cplx : public Real

Cplx(const Cplx &par) : Real(par), pIm(new double)

Cplx(void)

Cplx &operator=(Cplx &par)

ostream &operator<<(ostream &out, Cplx &par)

int main(void)

W wyrażeniu (Real &)*this = (Real &)par napis (Real &)*this jest nazwą podobiektu obiektu *this, a napis (Real &)par jest nazwą podobiektu obiektu par. Pierwszy z tych napisów jest równoważny napisowi *(Real *)this, a drugi jest równoważny napisowi *(Real *)&par.

Zastąpienie rozpatrywanego wyrażenia wyrażeniem *pRe = *par.pRe jest niemożliwe, ponieważ pole pRe jest prywatne, a metoda operator= klasy Cplx nie jest zaprzyjaźniona z klasą Real.

Gdyby nie zdefiniowano funkcji operator<< dla klasy Cplx, to operacja cout << num zostałaby niejawnie zastąpiona operacją cout << (Real &)num i zostałaby wyprowadzona liczba 3.

dla dociekliwych

Po utworzeniu obiektu i jego podobiektów jest wywoływany konstruktor obiektu. Podczas opracowywania jego listy inicjacyjnej są wywoływane konstruktory podobiektów. Następnie odbywa się inicjowanie własnych elementów obiektu. Na zakończenie jest wykonywane ciało konstruktora obiektu.

Uwaga: Inicjowanie podobiektów odbywa się w kolejności wyszczególnienia klas na liście dziedziczenia. Inicjowanie własnych elementów obiektu odbywa się w kolejności zadeklarowania ich pól.

Tuż przed zniszczeniem obiektu jest wywoływany destruktor obiektu. Po wykonaniu jego ciała są wywoływane destruktory własnych elementów obiektu, a następnie destruktory podobiektów.

Uwaga: Destruktory elementów są wywoływane w kolejności odwrotnej do zadeklarowania ich pól. Destruktory podobiektów są wywoływane w kolejności odwrotnej do wyszczególnienia klas na liście dziedziczenia.

#include <iostream.h>

class Real

~Real(void)

class Cplx : public Real

~Cplx(void)

int main(void)

Wykonanie programu powoduje wyprowadzenie napisu

Real-C: 3

Real-C: 4

Cplx-C:

Cplx-D:

Real-D: 4

Real-D: 3

Potwierdza się, że kolejność elementów listy inicjacyjnej jest nieistotna.

Studium programowe

Jeśli ktoś dysponuje klasą Cplx, z definicją zawartą w nagłówku cplx.h i implementacją w pliku binarnym cplx.obj (por. poprzedni rozdział), ale chce mieć klasę do niej podobną, której każdy obiekt zawiera dodatkowy element, określający ile razy część urojona miała wartość 0, to taka klasę, nazwaną tu Cplx2, może zdefiniować następująco.

#include 'cplx.h'

class Cplx2 : public Cplx {

friend ostream &operator<<(ostream &out, Cplx2 &par);

protected:

int count;

public:

Cplx2(double re =0, double im =0) : Cplx(re, im), count(0)

Cplx2 &operator=(const Cplx2 &par)

ostream &operator<<(ostream &out, Cplx2 &par)

istream &operator>>(istream &inp, Cplx2 &par)

return inp;

Podobnie jak uczyniono to uprzednio, klasę Cplx2 można dystrybuować w postaci pliku nagłówkowego cplx2.h i pliku implementacyjnego cplx2.obj.

Plik nagłówkowy

#ifndef CPLX2

#define CPLX2

#include <iostream.h>

#include 'cplx.h'

class Cplx2 : public Cplx ;

ostream &operator<<(ostream &out, Cplx2 &par);

istream &operator>>(istream &inp, Cplx2 &par);

#endif

Plik implementacyjny

#include 'cplx2.h'

#include <iostream.h>

Cplx2::Cplx2(double re, double im) : Cplx(re, im), count(0)

Cplx2 &Cplx2::operator=(const Cplx2 &par)

ostream &operator<<(ostream &out, Cplx2 &par)

istream &operator>>(istream &inp, Cplx2 &par)

return inp;

Program testujący

#include <iostream.h>

#include 'cplx2.h'

int main(void)

Metody wirtualne

Metodą wirtualną jest metoda zadeklarowana ze specyfikatorem virtual. Jeśli wywołanie metody wirtualnej odbywa się na rzecz obiektu kompletnego (a nie na rzecz jego podobiektu!), albo zawiera operator zakresu (np. obj.Cplx::abs()), to skutek wywołania będzie taki sam jak dla metody nie-wirtualnej. Jeśli wywołanie odbywa się na rzecz podobiektu obiektu kompletnego, to zostanie wykonana metoda o równoważnej sygnaturze, widoczna w klasie obiektu kompletnego. Taki sposób wywołania jest polimorficzny, ponieważ jest inny podczas kompilowania, a inny podczas wykonania programu.

Uwaga: Sygnaturę funkcji uzyskuje się po usunięciu z jej deklaracji specyfikatorów typu funkcji, identyfikatorów jej parametrów i opisów argumentów domniemanych. W szczególności funkcja o deklaracji const int fun(int par[3]) ma sygnaturę fun(int [3]).

#include <iostream.h>

#include <math.h>

class Real {

protected:

double re;

public:

Real(double re) : re(re)

virtual double abs(void)

class Cplx : public Real {

protected:

double im;

public:

Cplx(double re, double im) : Real(re), im(im)

double abs(void)

int main(void)

Wywołanie num.abs() odbywa się na rzecz obiektu kompletnego, więc zostanie wywołana metoda abs jego klasy, czyli Cplx::abs.

Wywołanie ref.abs() odbywa się na rzecz podobiektu klasy Real, identyfikowanego przez ref. Ponieważ w klasie Real metoda abs jest wirtualna, więc faktycznie zostanie wywołana metoda abs widoczna w klasie obiektu kompletnego do którego należy podobiekt, czyli Cplx::abs.

Wywołanie ptr->abs() odbywa się na rzecz podobiektu *ptr klasy Real, wskazanego przez ptr. Ponieważ w klasie Real metoda abs jest wirtualna, więc faktycznie zostanie wywołana metoda abs widoczna w klasie obiektu kompletnego, którego podobiektem jest *ptr, czyli Cplx::abs.

Gdyby z definicji funkcji Real::abs usunięto specyfikator virtual, to wywołania ref.abs() i ptr->abs() dotyczyłyby metody Real::abs, co spowodowałoby wyprowadzenie liczb 4.

Gdyby z klasy Cplx usunięto metodę abs, to w klasie obiektu kompletnego byłaby widoczna metoda abs odziedziczona z klasy Real, a więc w każdym z rozpatrzonych przypadków zostałaby wywołana metoda Real::abs.

Czyste metody wirtualne

Jeśli nie przewiduje się wykonania metody wirtualnej, to można usunąć jej ciało, a w deklaracji umieścić inicjator = 0. Tak zdefiniowana metoda jest czystą metodą wirtualną.

virtual double abs(void) = 0;

Klasa, która zawiera przynajmniej jedną czystą metodę wirtualną jest klasą abstrakcyjną. Klasa abstrakcyjna jest przydatna tylko do definiowania klas pochodnych (nie można tworzyć obiektów takiej klasy).

Jeśli w klasie pochodnej klasy abstrakcyjnej nie zdefiniuje się wszystkich odziedziczonych przez nią czystych metod wirtualnych, to taka klasa także będzie klasą abstrakcyjną.

Studium programowe

Studium poświęcono zdefiniowaniu klasy z metodą wirtualną oraz klasy pochodnej. Pokazano, jak nie zmieniając pierwotnej definicji operatora wyjścia można, dzięki przedefiniowaniu metody wirtualnej, zmienić sposób wyprowadzania wyników.

Klasa String

Niech będzie dana następująca klasa String do wykonywania operacji na łańcuchach o rozmiarze nie przekraczającym 256 elementów.

#include <iostream.h>

#include <string.h>

class String

String &operator+=(char *ptr)

String &operator+=(String &par)

virtual char operator[](int pos)

ostream &operator<<(ostream &out, String &par)

Użycie

Jeśli klasę String jest dystrybuowana w postaci pliku nagłówkowego string.h i pliku implementacyjnego string.obj, to można jej użyć w następującym programie.

#include <iostream.h>

#include 'string.h'

int main(void)

Operacja += musi być ujęta w nawiasy. Wynika to stąd, że jej priorytet jest niższy od priorytetu operacji <<.

Klasa String2

Jeśli użytkownik klasy String nie jest zadowolony ze sposobu wykonywania operacji wyjścia, to korzystając z tego, że metoda operator[] jest wirtualna, może zdefiniować następującą klasę String2 i przedefiniować w niej tę metodę tak, aby dostarczała nie kody liter łańcucha, ale kody odpowiadających im dużych liter.

#include <ctype.h>

class String2 : public String {

public:

String2(char *ptr) : String(ptr)

char operator[](int pos)

Uwaga: Argumentowi funkcji toupper nie nadano postaci str(pos), ponieważ identyfikator str jest prywatny, a więc w klasie String2 jest niedostępny. Nie nadano mu postaci ((String &)*this)[pos], równoważnej (*this)[pos], ponieważ spowodowałoby to rekurencyjne wywołanie metody String2::operator[], to jest wpadnięcie programu w pętlę.

Użycie

Jeśli klasę String2 jest dystrybuowana w postaci pliku nagłówkowego string2.h i pliku implementacyjnego string2.obj, to można jej użyć w następującym programie.

#include <iostream.h>

#include 'string2.h'

int main(void)

Uzasadnienie

Definicja klasy String ma postać

class String

ostream &operator<<(ostream &out, String &par)

a definicja klasy String2 ma postać

class String2 : public String

Ponieważ nie zdefiniowano operatora wyjścia dla obiektów klasy String2, więc w zasięgu deklaracji

String2 h('Hello');

wykonanie operacji

cout << h

powoduje niejawne zastosowanie konwersji standardowej odnośnika-do-obiektu na odnośnik-do-podobiektu

cout << (String &)h

a następnie wywołanie operatora wyjścia dla obiektów klasy String.

W ciele tego operatora parametr par jest odnośnikiem do podobiektu, a więc wywołanie par[i] metody wirtualnej operator[] klasy String zostaje zastąpione wywołaniem metody operator[] klasy String2. A zatem w miejscu wywołania par[i] jest dostarczany kod dużej litery.

Projektowanie kolekcji

Klasą kolekcyjną  jest klasa, której obiekty są przystosowane do przechowywania obiektów wybranej rodziny klas. Zazwyczaj stawia się wymaganie, aby klasy rodziny wywodziły się od wspólnej klasy pierwotnej.

Klasą iteracyjną jest klasa, która umożliwia otrzymywanie wskaźników albo odnośników na kolejne obiekty znajdujące się w kolekcji. Klasa iteracyjna jest zazwyczaj definiowana jako klasa wewnętrzna jej klasy kolekcyjnej.

W następującym programie zdefiniowano klasę kolekcyjną Numbers umożliwiającą tworzenie kolekcji oraz klasę iteracyjną Numbers::Scanner umożliwiającą przeglądanie kolekcji.

Klasa Numbers umożliwia dodawanie obiektów do kolekcji (operator+=) oraz ujawnianie i wyznaczanie sumy wartości bezwzględnych wszystkich obiektów znajdujących się w kolekcji (metody showAll i getSum).

W kolekcji można przechowywać obiekty numeryczne dowolnych klas pochodnych od klasy Root, byle tylko każdą z nich wyposażono w metody wirtualne showVal i getAbs.

Uwaga: Klasę Numbers zdefiniowano w taki sposób, że żadna z jej metod nie zależy od typu obiektów umieszczanych w kolekcji. Właściwość ta umożliwia umieszczanie w kolekcjach Numbers, obiektów takich klas, które nie były znane podczas definiowania klasy kolekcyjnej.

#include <iostream.h>

#include <math.h>

#include <stdlib.h>

class Root ;

const int Size = 1000;

class Numbers

Root *operator++(int)

};

friend Root *Numbers::Scanner::operator++(int);

private:

Root *pItem[Size];

int count;

public:

Numbers(void) : count(0)

Numbers &operator<=(Root &ref)

pItem[count++] = &ref;

return *this;

}

void showAll(ostream &out)

out << endl;

}

double getSum(void)

return sum;

}

class Real : public Root {

protected:

double re;

public:

Real(double re =0) : re(re)

double getAbs(void)

void showVal(ostream &out)

class Cplx : public Real {

protected:

double re, im;

public:

Cplx(double re =0, double im =0) : re(re), im(im)

double getAbs(void)

void showVal(ostream &out)

int main(void)

return 0;

Studium programowe

Klasę Numbers można dystrybuować w postaci pliku nagłówkowego numbers.h oraz pliku implementacyjnego numbers.obj. Mimo, iż kod źródłowy klasy jest wówczas niedostępny, można jej użyć w programie posługującym się klasą Fract, nie znaną w chwili gdy powstawały klasy Numbers i Scanner.

Uwaga: Klasa Fract implementuje liczby ułamkowe. Ich liczniki i mianowniki są przechowywane w postaci znormalizowanej.

#include <iostream.h>

#include 'numbers.h'

class Frac : public Root

int gdc(int n, int d)

return n;

}

void norm()

}

Frac operator+(Frac &par)

operator double(void)

double getAbs(void)

void showVal(ostream &out)

int main(void)

return 0;

Metoda gdc wyznacza największy-wspólny-podzielnik, a metoda norm normalizuje liczbę ułamkową w taki sposób, aby licznik i mianownik nie miały wspólnego podzielnika różnego od 1.

Studium projektowe

Przedstawione tu studium projektowe ilustruje istotne problemy jakie powstają podczas projektowania klas. Dokonano go na przykładzie klasy String, której obiekty umożliwiają reprezentowanie i wykonywanie operacji na łańcuchach. Po umieszczeniu jej definicji w nagłówku string.h, klasa String może być użyta m.in. w następujący sposób.

#include <iostream.h>

#include 'string.h'

int main(void)

Operacja dodawania (+) służy do sklejania łańcuchów, a operacja wykrzyknik (!) dostarcza rozmiar łańcucha.

Założenia projektowe

Obiekt klasy String składa się z 2 elementów: ze zmiennej typu int określającej rozmiar łańcucha oraz ze zmiennej typu char * wskazującej pierwszy element łańcucha przydzielonego na stercie. Z całą klasa jest związana zmienna statyczna count określająca aktualną liczbę łańcuchów.

class String ;

Klasa String o podanej definicji umożliwia tworzenie obiektów, inicjowanie ich za pomocą konstruktora domyślnego i kopiującego oraz przypisywanie obiektów. Po uwzględnieniu domniemań, tak zdefiniowana klasa jest równoważna klasie

class String {

private:

int len;

char *ptr;

static int count;

public:

String(void) : len(), ptr()

String(const String &par)

: len(par.len), ptr(par.ptr)

~String(void)

String &operator=(const String &par)

Ponieważ nie zdefiniowano ani jednego jawnego konstruktora, więc obiekty nie są właściwie zainicjowane i ich elementy mają wartości nieokreślone. Wobec braku operatora wyjścia (albo konwertera), na obiektach klasy nie można wykonywać operacji wejścia-wyjścia.

#include <iostream.h>

class String ;

int String::count = 0;

int main(void)

Wyposażenie w konstruktor

Inicjowanie elementów obiektu danymi o wartościach określonych jest możliwe tylko wówczas, gdy jego klasę wyposażono w konstruktor. Jego definicji można nadać postać

String(char *ptr ='')

: len(strlen(ptr)), ptr(new char [len+1])

Tak zdefiniowany konstruktor, ponieważ może być wywołany bez argumentów, jest zarazem konstruktorem domyślnym.

#include <iostream.h>

#include <string.h>

class String

static int getCount(void)

int String::count = 0;

ostream &operator<<(ostream &out, String &par)

int main(void)

Program jest poprawny formalnie, ale użyta w nim klasa String nie jest zdefiniowana właściwie. Powoduje to m.in. że funkcja getString dostarcza wartość 1, a nie 3.

Wyposażenie w destruktor

Projektowana klasa ma poważną wadę, wynikającą z użycia domniemanego destruktora, nie zwalniającego pamięci przydzielonej w konstruktorze. Wada ta ujawni się podczas wykonania pętli

for(int i = 0; i < Size ; i++)

String s('Hello');

z dostatecznie dużym Size, na przykład 10000000.

Brakujący destruktor, uwzględniający aktualizację zmiennej count można zdefiniować następująco

~String(void)

Konstruktor kopiujący

Wyposażenie klasy String w destruktor stwarza jednak inne trudności. A mianowicie, gdyby wykonano instrukcje

String s1('Hi');

// błąd

to ponieważ zniszczenie zmiennej s2 spowodowałoby zwolnienie pamięci zainicjowanej łańcuchem 'Hi', więc podczas niszczenia zmiennej s1 podjęto by próbę ponownego zwolnienia tej pamięci, co skończyłoby się załamaniem systemu zarządzania stertą.

Dlatego klasa String musi być wyposażona w konstruktor kopiujący, realizujący głębokie-kopiowanie obiektu inicjującego.

String(const String &par)

: len(par.len), ptr(new char [len+1])

Po takich zmianach następujący program wykonuje się już poprawnie.

#include <iostream.h>

#include <string.h>

class String

String(const String &par)

: len(par.len), ptr(new char [len+1])

~String(void)

static int getCount(void)

int String::count = 0;

ostream &operator<<(ostream &out, String &par)

int main(void)

return 0;

Operator przypisania

Tak zdefiniowana klasa String ma niestety jeszcze wadę wynikającą z tego że domniemany operator przypisania realizuje kopiowanie-płytkie. Ujawni się to na przykład po wykonaniu instrukcji

String s1('Hi');

// błąd

Dlatego klasę String należy wyposażyć w operator przypisania realizujący kopiowanie-głębokie

String &operator=(const String &par)

return *this;

Napisano go w taki sposób, że jest dozwolone wykonanie przypisania tożsamościowego (np. a = a) oraz łączenie operacji przypisania (np. a = b = c);

#include <iostream.h>

#include <string.h>

class String

String(const String &par)

: len(par.len), ptr(new char [len+1])

~String(void)

String &operator=(const String &par)

return *this;

}

static int getCount(void)

int String::count = 0;

ostream &operator<<(ostream &out, String &par)

int main(void)

cout << s2 << endl; // Hi

cout << String::getCount() << endl; // 2

return 0;

Operatory sumowania

Operatory sumowania umożliwiają wykonywanie operacji sklejania łańcuchów (a + b) oraz operacji doklejania łańcucha (a += b).

W celu umożliwienia wykonywania operacji podobnych do 'Hi' + obj, w których obj jest nazwą obiektu klasy String, zdefiniowano następującą funkcję globalną

String operator+(char *ptr, String  &par)

Pozostałe operacje zdefiniowano za pomocą metod.

String operator+(String &par)

String operator+(char *ptr)

String &operator+=(String &par)

Należy zwrócić uwagę, że rezultat operacji sklejania jest nie-odnośnikowy, a rezultat operacji doklejania jest odnośnikowy.

#include <iostream.h>

#include <string.h>

class String

String(const String &par)

: len(par.len), ptr(new char [len+1])

~String(void)

String &operator=(const String &par)

return *this;

}

String operator+(String &par)

String operator+(char *ptr)

String &operator+=(String &par)

static int getCount(void)

int String::count = 0;

String operator+(char *ptr, String  &par)

ostream &operator<<(ostream &out, String &par)

int main(void)

dla dociekliwych

Operacja sklejania jest dość kosztowna, gdyż jej wykonanie wymaga dwukrotnego skopiowania obiektu klasy String: podczas tworzenia zmiennej tmp oraz podczas wykonywania instrukcji powrotu. Dlatego kuszące jest zdefiniowanie operacji sklejania z rezultatem odnośnikowym.

String &operator+(String &par)

Rozwiązanie to jest jednak wadliwe, ponieważ wykonanie każdej operacji sklejenia powoduje utworzenie obiektu na stercie, bez możliwości jego zniszczenia. Można to ulepszyć, zapisując operację w postaci

String &operator+(String &par)

W takiej wersji nadaje się ona do wykonywania działań a+b+c+d, ale w istocie też jest błędna, ponieważ może załamać system zarządzania stertą dla operacji (a+b)+(c+d), co ma miejsce w Visual C++.

Należy zauważyć, że identyczny problem powstałby także w przypadku, gdyby rezultat sklejenia był odnośnikiem do zmiennej statycznej.

String &operator+(String &par)

Dlatego zaleca się pozostanie przy pierwotnym rozwiązaniu.

Operator rozmiaru

Operator wyznaczania rozmiaru można zdefiniować za pomocą metody operator!.

int operator!(void)

Operator wejścia

istream &operator>>(istream &inp, String &par)

Operator indeksowania

char &operator[](int pos)

Parametry ustalone

Jeśli argument funkcji nie jest l-nazwą, to może być skojarzony tylko z parametrem, który jest zmienna ustaloną. Ten wniosek prowadzi do zweryfikowania większości przytoczonych uprzednio definicji.

#include <iostream.h>

#include <string.h>

#include <iomanip.h>

class String

String(const String &par)

: len(par.len), ptr(new char [len+1])

~String(void)

String &operator=(const String &par)

return *this;

}

String operator+(const String &par)

String operator+(const char *ptr)

String &operator+=(const String &par)

static int getCount(void)

int operator!(void)

char &operator[](const int pos)

}

int String::count = 0;

String operator+(const char *ptr, const String &par)

ostream &operator<<(ostream &out, const String &par)

istream &operator>>(istream &inp, String &par)

int main(void)

Program wyprowadza napis 'Hello World'. Jako nie-ustalone zadeklarowano tylko te parametry, które nie mogą być ustalone.

Dodatek F

Błędy programowania

Omówione tutaj błędy są często trudne do wykrycia. Dlatego aby ich uniknąć, warto się z nimi zapoznać.

Średniki po for

for(int i = 0; i < 50 ; i++);

Program nie wyprowadza nic. Jest to spowodowane przez zbędny średnik.

Średniki po class

#include <iostream.h>

struct Any

main(void)

Niezrozumiały komunikat jest następstwem braku średnika po deklaracji typu.

Brak rezerwacji

#include <iostream.h>

#include <string.h>

int main(void)

Błąd wykonania jest spowodowany brakiem obszaru pamięci do którego zamierzano skopiować łańcuch 'Hello'.

Brak wywołania

Każde wywołanie funkcji musi zawierać (być może pustą!) listę argumentów. Użycie nazwy funkcji bez nawiasów jest dozwolone, ale nie pociąga za sobą wywołania funkcji.

#include <iostream.h>

int fun(void)

int main(void)

Priorytet operatorów

int a = 10, b = 20;

cout << a, b;  // cout << a; b;

cout << a += 2;  // błąd

Pierwszy z błędów jest dość nieprzyjemny, bo zapis operacji sugeruje, że zamierzano wyprowadzić wartości zmiennych a i b, podczas gdy wyprowadzi się tylko wartość a.

Kolejność opracowywania

Argumenty funkcji są opracowywane w dowolnej kolejności. W każdej implementacji kolejność ta może być inna. W Visual C++ argumenty są opracowywane od-prawej-do-lewej.

Uwaga: Omówiony tu problem jest szczególnie istotny podczas wykonywania operacji wejścia-wyjścia zdefiniowanych za pomocą funkcji globalnych.

#include <iostream.h>

class Real {

private:

double re;

public:

Real(double re =0) : re(re)

operator char *()

Real &get(int val)

int main(void)

Operacja cout << 1 << 2 jest równoważna operacji

cout.operator<<(1).operator<<(2)

Kolejność wyprowadzenia liczb jest gwarantowana: najpierw 1, potem 2.

Operacja cout << get(1) << get(2) jest równoważna operacji

operator<<(operator<<(get(1)), get(2))

Kolejność wyprowadzenia liczb może być dowolna. Podany wynik dotyczy Visual C++.