Visual C 6 0 Programowanie Obiektowe [46 stron]

prof. Jan Bielecki

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 {
double re, im;
};

Cplx add(Cplx &parL, Cplx parR);

int main(void)
{
Cplx one = { 1.0, 3.0 },
two = { 2.0, 4.0 };

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)
{
double re = parL.re + parR.re,
im = parL.im + parR.im;
Cplx sum = { re, im };
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 ... {
public:
// ...
};

a każda deklaracja

class Any ...{
// ...
};

jest równoważna deklaracji

class Any ... {
private:
// ...
};

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 {
friend Cplx add(Cplx &parL, Cplx parR);
protected:
double re, im;
public:
Cplx(double r, double i) : re(r), im(i)
{
}
void show(void)
{
cout << re << '+' <<
im << 'i' << endl;
}
};

Cplx add(Cplx &parL, Cplx parR)
{
double r = parL.re + parR.re,
i = parL.im + parR.im;
return Cplx(r, i);
}

int main(void)
{
Cplx one(1.0, 3.0),
two(2.0, 4.0);

Cplx sum = add(one, two);

sum.show();

return 0;
}

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 {
// ...
protected:
double re, im;
public:
Cplx(double r, double i)
{
re = r;
im = i;
}
Cplx(double r)
{

re = r;
im = 0;
}
Cplx(void)
{
re = im = 0;
}
// ...
};

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 {
// ...
protected:
double re, im;
public:
Cplx(void) // konstrukor domy

lny

{
re = im = 0;
}
// ...
};

Argumenty domniemane

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

class Cplx {
// ...
protected:
double re, im;
public:
Cplx(double r =0, double i =0) // konstruktor domy

lny

{
re = r;
im = i;
}
// ...
};

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 {
// ...
protected:
double re, im;
public:
Cplx(double re =0, double im =0) : re(re), im(im)
{
}
// ...
};

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 {
// ...
protected:
double re, im;
public:
Cplx(double re =0, double im =0) : re(re), im(im)
{
}
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 {
friend Cplx add(Cplx &parL, Cplx parR);
protected:
double re, im;
public:
Cplx(double re, double im) : re(re), im(im)
{
cout << "Constructing: ", show();
}
~Cplx(void)
{
cout << "Destructing: ", show();
}
void show(void)
{
cout << re << '+' <<
im << 'i' << endl;
}
};

int main(void)
{
Cplx numA(1, 2);
{
Cplx numB(3, 4);
// ...
}

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)
{
double re = this->re + par.re,
im = this->im + par.im;
return Cplx(re, im);
}
void show(void)
{
cout << this->re << '+' <<
this->im << 'i' << endl;
}
};

int main(void)
{
Cplx one(1.0, 3.0),
two(2.0, 4.0);

Cplx sum = one.add(two);

sum.show(); // 3+7i

return 0;
}

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

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)
{
return Cplx(-re, -im);
}
void operator++(void)
{
++re;
}
};

Cplx operator~(Cplx &par)
{
return Cplx(par.re, -par.im);
}

void operator++(Cplx &par, int)
{
++par.im;
}

ostream &operator<<(ostream &out, Cplx &par)
{
if(par.re)
out << par.re;
if(par.re && par.im > 0)
out << '+';
return out << par.im << 'i';
}

int main(void)
{
Cplx one(1,2);
cout << ~-one << endl; // -1+2i

Cplx two(3,4);
++two;
two++;
cout << two << endl; // 4+5i

return 0;
}

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

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)
{
double re = Cplx::re + par.re,
im = Cplx::im + par.im;
return Cplx(re, im);
}
};

ostream &operator<<(ostream &out, Cplx &par)
{
if(par.re)
out << par.re;
if(par.re && par.im > 0)
out << '+';
return out << par.im << 'i';
}

int main(void)
{
Cplx one(1.0, 3.0),
two(2.0, 4.0);

Cplx sum = one + two;

cout << sum << endl; // 3+7i

return 0;
}

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)

{
re = par.re;
im = par.im;
return *this;
}

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)
{
return sqrt(re * re + im * im);
}
};

ostream &operator<<(ostream &out, Cplx &par)
{
if(par.re)
out << par.re;
if(par.re && par.im > 0)
out << '+';
return out << par.im << 'i';
}

int main(void)
{
Cplx one(3,4);

cout << one << endl; // 3+4i
cout << (double)one << endl; // 5

return 0;
}

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)
{
return re; // (double)re
}
};

Cplx num = 12; // Cplx(12)

int main(void)
{
cout << num << endl; // num.operator double()

return 0;
}

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 {
private:
static int count; // deklaracja
protected:
double re;
public:
Real(double re =0) : re(re)
{
count++;
}
~Real(void)
{
count--;
}
static int getCount(void)
{
return count;
}
};

int Real::count = 0; // definicja

int main(void)
{
cout << Real::getCount() << endl; // 0

Real r1;
{
Real r2, r3;
cout << Real::getCount() << endl; // 3
}
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)
{
return sqrt(re * re + im * im);
}
Cplx operator+(Cplx &par);
Cplx operator~(void)
{
return Cplx(re, -im);
}
void putCplx(ostream &out)
{
if(re)
out << re;
if(re && im > 0)
out << '+';
out << im << 'i';
}

void getCplx(istream &inp)
{
inp >> re;
if(inp.peek() == 'i')
im = re, re = 0;
else {
inp >> im;
if(inp.peek() != 'i') {
inp.clear(ios::badbit);
return;
}
}
char drop;
inp >> drop;
}
};

Cplx Cplx::operator+(Cplx &par)
{
return Cplx(re + par.re, im + par.im);
}

double sqrt(Cplx &par)
{
return (double)par;
}

ostream &operator<<(ostream &out, Cplx &par)
{
par.putCplx(out);
return cout;
}

istream &operator>>(istream &inp, Cplx &par)
{
par.getCplx(inp);
return inp;
}

int main(void)
{
Cplx one, two;

cin >> one >> two;

cout << "Sum = " << one + two << endl;
cout << "sqrt(" << one << ") = " <<
double(one) << endl;
cout << "sqrt(" << two << ") = " <<
sqrt(two) << endl;

return 0;
}

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 {
friend inline double sqrt(Cplx &par);
protected:
double re, im;
public:
Cplx(double re =0, double im =0);
~Cplx(void);
operator double(void);
Cplx operator+(Cplx &par);
Cplx operator~(void);
void putCplx(ostream &out);
void getCplx(istream &inp);
};

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)
{
return sqrt(re * re + im * im);
}

Cplx Cplx::operator~(void)
{
return Cplx(re, -im);
}

void Cplx::putCplx(ostream &out)
{
if(re)
out << re;
if(re && im > 0)
out << '+';
out << im << 'i';
}

void Cplx::getCplx(istream &inp)
{
inp >> re;
if(inp.peek() == 'i')
im = re, re = 0;
else {
inp >> im;
if(inp.peek() != 'i') {
inp.clear(ios::badbit);
return;
}
}
char drop;
inp >> drop;
}

Cplx Cplx::operator+(Cplx &par)
{
return Cplx(re + par.re, im + par.im);
}

double sqrt(Cplx &par)
{
return (double)par;
}

ostream &operator<<(ostream &out, Cplx &par)
{
par.putCplx(out);
return cout;
}

istream &operator>>(istream &inp, Cplx &par)
{
par.getCplx(inp);
return inp;
}

Program testujący

#include <iostream.h>
#include <math.h>
#include "cplx.h"

int main(void)
{
Cplx one, two;

cin >> one >> two;

cout << "Sum = " << one + two << endl;
cout << "sqrt(" << one << ") = " <<
double(one) << endl;
cout << "sqrt(" << two << ") = " <<
sqrt(two) << endl;

return 0;
}

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 {
friend ostream &operator<<(ostream &out, Real &par);
private:
double *pRe;
public:
Real(double re =0) : pRe(new double)
{
*pRe = re;
}
Real(const Real &par) : pRe(new double)
{
*pRe = *par.pRe;
}
~Real(void)
{
delete pRe;
}
Real &operator=(Real &par)
{
*pRe = *par.pRe;
return *this;
}
};

ostream &operator<<(ostream &out, Real &par)
{
return out << *par.pRe;
}

class Cplx : public Real {
friend ostream &operator<<(ostream &out, Cplx &par);
private:
double *pIm;
public:
Cplx(double re, double im) : Real(re), pIm(new double)
{
*pIm = im;
}
Cplx(const Cplx &par) : Real(par), pIm(new double)
{
*pIm = *par.pIm;
}
Cplx(void)
{
delete pIm;
}
Cplx &operator=(Cplx &par)
{
(Real &)*this = (Real &)par;
*pIm = *par.pIm;
return *this;
}

};

ostream &operator<<(ostream &out, Cplx &par)
{
out << (Real &)par;
if(par.re && *par.pIm > 0)
out << '+';
return out << *par.pIm << 'i';
}

int main(void)
{
Cplx num(3,4);

cout << num << endl; // 3+4i

return 0;
}

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 {
private:
double re;
public:
Real(double re) : re(re)
{
cout << "Real-C: " << re << endl;
}
~Real(void)
{
cout << "Real-D: " << re << endl;
}
};

class Cplx : public Real {
private:
Real im;
public:

Cplx(double re, double im) : im(im), Real(re)
{
cout << "Cplx-C: " << endl;
}
~Cplx(void)
{
cout << "Cplx-D: " << endl;
}
};

int main(void)
{
Cplx num(3,4);

cout << endl;

return 0;
}

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)
{
if(par.im == 0)
count++;
(Cplx &)*this = par;
return *this;
}
};

ostream &operator<<(ostream &out, Cplx2 &par)
{
out << (Cplx &)par;
if(par.count != 0)
out << ':' << par.count;
return out;
}

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

if(inp.peek() == ':') {
char chr;
int num;
inp >> chr >> num;
}
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 {
friend ostream &operator<<(ostream &out, Cplx2 &par);
protected:
int count;
public:
Cplx2(double re =0, double im =0);
Cplx2 &operator=(const Cplx2 &par);
};

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)
{
if(par.im == 0)
count++;
(Cplx &)*this = par;
return *this;
}

ostream &operator<<(ostream &out, Cplx2 &par)
{
out << (Cplx &)par;
if(par.count != 0)
out << ':' << par.count;
return out;
}

istream &operator>>(istream &inp, Cplx2 &par)
{
inp >> (Cplx &)par;
if(inp.peek() == ':') {
char chr;
int num;
inp >> chr >> num;
}
return inp;

}

Program testujący

#include <iostream.h>
#include "cplx2.h"

int main(void)
{
Cplx2 num(3,4);
cout << num << endl; // 3+4i
num = 0;
num = Cplx2(1,2);
num = 0;

cin >> num; // 5i
cout << num << endl; // 5i:2

return 0;
}

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)
{
return re < 0 ? -re : re;
}
};

class Cplx : public Real {
protected:
double im;
public:
Cplx(double re, double im) : Real(re), im(im)
{
}
double abs(void)
{
return sqrt(re * re + im * im);
}
};

int main(void)
{
Cplx num(3,4);
Cplx &ref = num;
Cplx *ptr = &num;

cout << num.abs() << endl; // 5

cout << ref.abs() << endl; // 5

cout << ptr->abs() << endl; // 5

return 0;
}

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 {
friend ostream &operator<<(ostream &out, String &par);
private:
int len;
char str[256];
public:
String(char *ptr) : len(strlen(ptr))
{
strcpy(str, ptr);
}
String &operator+=(char *ptr)
{
strcpy(str + len, ptr);
return *this;
}
String &operator+=(String &par)

{
return *this += par.str;
}
virtual char operator[](int pos)
{
return str[pos];
}
};

ostream &operator<<(ostream &out, String &par)
{
for(int i = 0; i < par.len ; i++)
out << par[i];
return out;
}

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)
{
String h("Hello"),
w("World");

cout << h << endl; // Hello
cout << (h += w) << endl; // HelloWorld
cout << ((h += " ") += w) << endl; // Hello World

return 0;
}

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)
{
return toupper(String::operator[](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)
{
String2 h("Hello"),
w("World");

cout << h << endl; // HELLO
cout << (h += w) << endl; // HELLO WORLD
cout << ((h += " ") += w) << endl; // HELLO WORLD

return 0;
}

Uzasadnienie

Definicja klasy String ma postać

class String {
// ...
virtual char operator[](int pos)
{
return str[pos];
}
};

ostream &operator<<(ostream &out, String &par)
{
for(int i = 0; i < par.len ; i++)
out << par[i];
return out;
}

a definicja klasy String2 ma postać

class String2 : public String {
// ...
char operator[](int pos)
{
return toupper(String::operator[](pos));
}
};

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 {
friend class Numbers;
public:
virtual void showVal(ostream &out) = 0;
virtual double getAbs(void) = 0;
};

const int Size = 1000;

class Numbers {
public:
class Scanner {
private:
Numbers &dataBase;
int pos;
public:
Scanner(Numbers &dataBase)
: dataBase(dataBase), pos(0)
{
}
Root *operator++(int)
{
if(pos == Size)
return pos = 0, 0;
else
return dataBase.pItem[pos++];
}
};
friend Root *Numbers::Scanner::operator++(int);

private:
Root *pItem[Size];
int count;
public:
Numbers(void) : count(0)

{
}
Numbers &operator<=(Root &ref)
{
if(count == Size) {
cout << "Numbers overflow" << endl;
exit(0);
}
pItem[count++] = &ref;
return *this;
}
void showAll(ostream &out)
{
out << "Data base contains:" << endl;
for(int i = 0; i < count ; i++) {
Root *ptr = pItem[i];
ptr->showVal(out);
out << endl;
}
out << endl;
}
double getSum(void)
{
double sum;
for(int i = 0; i < count ; i++) {
Root *ptr = pItem[i];
sum += ptr->getAbs();
}
return sum;
}
};

class Real : public Root {
protected:
double re;
public:
Real(double re =0) : re(re)
{
}
double getAbs(void)
{
return re < 0 ? -re : re;
}
void showVal(ostream &out)
{
out << re;
}
};

class Cplx : public Real {
protected:
double re, im;
public:
Cplx(double re =0, double im =0) : re(re), im(im)
{
}
double getAbs(void)
{
return sqrt(re * re + im * im);
}
void showVal(ostream &out)
{
out << '(' << re << ',' << im << ')';
}
};

int main(void)
{
Real r1(1), r2(2);
Cplx c1(3,4);

Numbers dataBase;

dataBase <= r1 <= r2 <= c1;

dataBase.showAll(cout); // 1 2 (3,4)

cout << "Sum = " <<
dataBase.getSum() << // 8
endl;

cout << endl << "Scanner output:" << endl;
Numbers::Scanner scan(dataBase);
Root *pItem;
while(pItem = scan++) {
pItem->showVal(cout);
cout << endl;
}

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 {
private:
int num, den;
public:
Frac(int num =0, int den =1) : num(num), den(den)
{
norm();
}
int gdc(int n, int d)
{
int t;
while(d) {
t = n % d;
n = d;
d = t;
}
return n;
}
void norm()
{
int g = gdc(num, den);
num /= g;
den /= g;
if(den < 0) {
num = -num;
den = -den;
}
}
Frac operator+(Frac &par)
{
Frac f;
f.num = num * par.den + par.num * den;
f.den = den * par.den;
f.norm();
return f;
}
operator double(void)

{
return double(num) / den;
}
double getAbs(void)
{
double val = double(num) / den;
return val < 0 ? -val : val;
}
void showVal(ostream &out)
{
out << num << '/' << den;
}
};

int main(void)
{
Frac f1(4,8),
f2(3,4);

Numbers dataBase;
dataBase.add(f1).add(f2);

dataBase.showAll(cout); // 1/2 3/4

cout << endl;
cout << "Sum = " <<
dataBase.getSum() << // 1.25
endl;
cout << f1 + f2 << endl; // 1.25

cout << endl;
cout << "Scanner output:" << endl;
Numbers::Scanner scan(dataBase);
Root *pItem;
while(pItem = scan++) {
pItem->showVal(cout);
cout << endl;
}

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)
{
String h("Hello"),
w = "World";
cout << "The length of \"" << h + w <<
"\" is: " << !(h + w) << endl;

return 0;
}

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 {
int len;
char *ptr;
static int count;
};

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)
{
len = par.len;
ptr = par.ptr;
return *this;

}
};

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 len;
char *ptr;
static int count;
};

int String::count = 0;

int main(void)
{
String s1,
s2(s1),
s3 = s2;
s1 = s3;
cout << s1 << endl; // bł

cout << String::count << endl; // bł

return 0;
}

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])
{
strcpy(String::ptr, ptr);
count++;
}

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

ostream &operator<<(ostream &out, String &par)
{
return out << par.ptr;
}

int main(void)
{
String s1("Hi"),
s2(s1),
s3 = s2;
s1 = s3;
cout << s1 << endl; // Hi
cout << String::getCount() << endl; // 1 (nieprawda!)

return 0;
}

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)
{
delete [] ptr;
count--;
}

Konstruktor kopiujący

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

String s1("Hi");
{
String s2(s1);
} // bł

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])
{
strcpy(ptr, par.ptr);
count++;
}

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

#include <iostream.h>
#include <string.h>

class String {
friend ostream &operator<<(ostream &out, String &par);
private:
int len;
char *ptr;
static int count;
public:
String(char *ptr)
: len(strlen(ptr)), ptr(new char [len+1])
{
strcpy(String::ptr, ptr);
count++;
}
String(const String &par)
: len(par.len), ptr(new char [len+1])
{
strcpy(ptr, par.ptr);
count++;
}
~String(void)
{
delete [] ptr;
count--;
}
static int getCount(void)
{
return count;
}
};

int String::count = 0;

ostream &operator<<(ostream &out, String &par)
{
return out << par.ptr;
}

int main(void)
{
String s1("Hi");
{
String s2(s1),
s3 = s2;
cout << s3 << endl; // Hi
cout << String::getCount() << endl; // 3
}

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");
{
String s2;
s2 = s1;
} // bł

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

String &operator=(const String &par)
{
if(this != &par) {
delete [] ptr;
len = par.len;
ptr = new char [len+1];
strcpy(ptr, par.ptr);
}
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 {
friend ostream &operator<<(ostream &out, String &par);
private:
int len;
char *ptr;
static int count;
public:
String(char *ptr ="")
: len(strlen(ptr)), ptr(new char [len+1])
{
strcpy(String::ptr, ptr);
count++;
}
String(const String &par)
: len(par.len), ptr(new char [len+1])
{
strcpy(ptr, par.ptr);
count++;
}
~String(void)
{
delete [] ptr;
count--;
}
String &operator=(const String &par)
{
if(this != &par) {
delete [] ptr;
len = par.len;
ptr = new char [len+1];
strcpy(ptr, par.ptr);
}
return *this;
}
static int getCount(void)
{
return count;
}
};

int String::count = 0;

ostream &operator<<(ostream &out, String &par)
{
return out << par.ptr;
}

int main(void)
{
String s1("Hi"),
s2(s1);
{
String s3;
s3 = s2;
}

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)
{
return String(ptr) + par;
}

Pozostałe operacje zdefiniowano za pomocą metod.

String operator+(String &par)
{
char *pTmp = new char [len + par.len + 1];
strcpy(pTmp, ptr);
strcat(pTmp, par.ptr);
String tmp(pTmp);
delete [] pTmp;
return tmp;
}

String operator+(char *ptr)
{
return *this + String(ptr);
}

String &operator+=(String &par)
{
char *pTmp = ptr;
len += par.len;
ptr = new char [len + 1];
strcpy(ptr, pTmp);
strcat(ptr, par.ptr);
return *this;
}

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

{
strcpy(ptr, par.ptr);
count++;
}
~String(void)
{
delete [] ptr;
count--;
}
String &operator=(const String &par)
{
if(this != &par) {
delete [] ptr;
len = par.len;
ptr = new char [len+1];
strcpy(ptr, par.ptr);
}
return *this;
}
String operator+(String &par)
{
char *pTmp = new char [len + par.len + 1];
strcpy(pTmp, ptr);
strcat(pTmp, par.ptr);
String tmp(pTmp);
delete [] pTmp;
return tmp;
}
String operator+(char *ptr)
{
return *this + String(ptr);
}
String &operator+=(String &par)
{
char *pTmp = ptr;
len += par.len;
ptr = new char [len + 1];
strcpy(ptr, pTmp);
strcat(ptr, par.ptr);
return *this;
}
static int getCount(void)
{
return count;
}
};

int String::count = 0;

String operator+(char *ptr, String &par)
{
return String(ptr) + par;
}

ostream &operator<<(ostream &out, String &par)
{
return out << par.ptr;
}

int main(void)
{
String a("a"),
b("b"),
c("c"),
d("d");
cout << a + b << endl; // ab
cout << a + c << endl; // ac
cout << a + b + c + d << endl; // abcd
cout << (a + b) + (c+d) << endl; // abcd

return 0;
}

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)
{
String &s = *new String;
char *p = s.ptr;
s.len = len + par.len;
s.ptr = new char [s.len + 1];
strcpy(s.ptr, ptr);
strcat(s.ptr, par.ptr);
delete [] p;
return s;
}

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)
{
static String *p = 0;
String *p2 = p;
String &s = *(p = new String);
s.len = len + par.len;
s.ptr = new char [s.len + 1];
strcpy(s.ptr, ptr);
strcat(s.ptr, par.ptr);
delete p2;
return s;
}

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)
{
static String s;
char *p = s.ptr;
s.len = len + par.len;
s.ptr = new char [s.len + 1];
if(this != &s)
strcpy(s.ptr, ptr);
else
strcpy(s.ptr, p);
strcat(s.ptr, par.ptr);
delete p;
return s;
}

Dlatego zaleca się pozostanie przy pierwotnym rozwiązaniu.

Operator rozmiaru

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

int operator!(void)

{
return len;
}

Operator wejścia

istream &operator>>(istream &inp, String &par)
{
const int Size = 81;
char buf[Size];
cin >> setw(Size) >> buf;
par = String(buf);
if(!par == Size-1)
cout << endl << "Warning!: " << par << endl;
return inp;
}

Operator indeksowania

char &operator[](int pos)
{
static char dummy;
if(pos >= 0 && pos < !*this)
return ptr[pos];
else {
cout << endl << "Warning!" << endl;
return dummy;
}
}

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 {
friend ostream &operator<<(ostream &out, const String &par);
friend istream &operator>>(istream &inp, const String &par);
private:
int len;
char *ptr;
static int count;
public:
String(const char *ptr ="")
: len(strlen(ptr)), ptr(new char [len+1])
{
strcpy(String::ptr, ptr);
count++;
}
String(const String &par)
: len(par.len), ptr(new char [len+1])
{
strcpy(ptr, par.ptr);
count++;
}
~String(void)
{
delete [] ptr;
count--;
}

String &operator=(const String &par)
{
if(this != &par) {
delete [] ptr;
len = par.len;
ptr = new char [len+1];
strcpy(ptr, par.ptr);
}
return *this;
}
String operator+(const String &par)
{
char *pTmp = new char [len + par.len + 1];
strcpy(pTmp, ptr);
strcat(pTmp, par.ptr);
String tmp(pTmp);
delete [] pTmp;
return tmp;
}
String operator+(const char *ptr)
{
return *this + String(ptr);
}
String &operator+=(const String &par)
{
char *pTmp = ptr;
len += par.len;
ptr = new char [len + 1];
strcpy(ptr, pTmp);
strcat(ptr, par.ptr);
return *this;
}
static int getCount(void)
{
return count;
}
int operator!(void)
{
return len;
}
char &operator[](const int pos)
{
static char dummy;
if(pos >= 0 && pos < !*this)
return ptr[pos];
else {
cout << endl << "Warning!" << endl;
return dummy;
}
}
};

int String::count = 0;

String operator+(const char *ptr, const String &par)
{
return String(ptr) + par;
}

ostream &operator<<(ostream &out, const String &par)
{
return out << par.ptr;
}

istream &operator>>(istream &inp, String &par)
{
const int Size = 81;
char buf[Size];
cin >> setw(Size) >> buf;
par = String(buf);
if(!par == Size-1)
cout << endl << "Warning!: " << par << endl;

return inp;
}

int main(void)
{
String hi("Hello");
cout << "\"" + hi + " " + "World" + "\"" << endl;

return 0;
}

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++);
{
cout << i;
cout << endl;
}

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

redniki po class

#include <iostream.h>

struct Any {
char name[20];
int age;
}

main(void)
{
cout << "Hi" << endl;

return 0;
}

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

Brak rezerwacji

#include <iostream.h>
#include <string.h>

int main(void)
{
char *ptr;
strcpy(ptr, "Hello");
cout << ptr << endl;

return 0;
}

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)
{
cout << 10 << endl;
return 20;
}

int main(void)
{
fun(); // 10
fun; // instrukcja pusta

cout << fun() << endl; // 10 20
cout << fun << endl; // wska

nik na funkcj

return 0;
}

Priorytet operatorów

int a = 10, b = 20;
cout << a, b; // cout << a; b;
cout << a += 2; // bł

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 *()
{
return "";
}
};

Real &get(int val)
{
cout << val;
return Real(0);
}

int main(void)
{
cout << 1 << 2 << endl; // 12

cout << get(1) << get(2) << endl; // 21

return 0;
}

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++.

Wyszukiwarka

Podobne podstrony:
Visual C++ 6 0 Programowanie obiektowe Visual c++ 6 0 programowanie obiektowe
Visual c 6 0 programowanie obiektowe(3)
Bielecki - Visual C++, Visual C++ 6.0 Programowanie obiektowe, Jan Bielecki
Visual C 6 0 Programowania obiektowe
Programowanie obiektowe w Visual Basic NET dla kazdego povbnd

więcej podobnych podstron