Klasy obiektów

Wykład 2

Pojęcie klasy obiektów

Klasa jest nowym typem zmiennej w programie . Definiujemy ją

jako:

 
class nasza_klasa {
//
//
...
//ciało klasy
};
 
Jeśli chcemy stworzyć konkretny element czyli obiekt tej klasy

to zapisujemy :

 
nasza_klasa nasz_obiekt;

 

Wtedy w pamięci operacyjnej

powstanie

obiekt klasy

nasza_klasa, który się nazywa nasz_obiekt.

Kiedy już mamy typ nasza_klasa, to możemy utworzyć
obiekt pochodny, na przykład wskaźnik do obiektu z
naszej_klasy:
 

nasza_klasa *wsk;

(czy mogę określić referencję na nazwę klasy?) 

albo:
 

nasza_klasa &name = obiekcik;

 

Utworzy to wskaźnik do obiektów klasy nasza_klasa albo
referencje do wybranego obiektu klasy nasza_klasa.
 
Przykład: program w C++, który przechowuje
informację o kolorze i wartości punktowej karty do gry.
Wykorzystuje klasę Karta. W kodzie ponumerowano
wiersze do dalszej analizy.

Kod programu do przykładu

1. #include <iostream>
2. #include <conio.h>
3. #include <string.h>
4. #include <dos.h>
5. class Karta
6. {
7. public:
8. char kol[80];
9. int wym;
10.Karta(char*, int);
11.void Druk();
12.};

void main()
{

Karta k1(“czarna”,5),k2(“czerwona”,8);

//

powolanie do zycia obiektow k1 oraz k2 klasy Karta

k1.Druk();

//

wykonanie funkcji Druk() na rzecz

obiektu k1

k2.Druk();

strcpy(k1.kol,”czarno-czerwona”); //

zmiana zmiennej

kol na rzecz obiektu k1

k2.wym=28;

//

zmiana zmiennej wym na rzecz

obiektu k2

cout<<endl;

k1.Druk();
k2.Druk();
getch();
}

Karta::Karta(char* s,int w): wym(w)
{
strcpy(kol,s);
}

 

Definicja
konstrukto
ra

Inicjalizacja
argumentu
konstruktora

Definicja
funkcji

void Karta::Druk()

{

cout<<”\nkolor=”<<kol<<”,wymiar=
”<<wym;

}

omówienie:

uwagi o strukturze kodu programu:

•opis klasy Karta znajduje się przed blokiem main() czyli w tej części
kodu programu, która przeznaczona jest do umieszczania deklaracji,
definicji i inicjalizowania typów zmiennych. To także wskazuje, że

klasa jest typem zmiennej

.

•Opis klasy zawsze umieszczamy w nawiasie klamrowym, po którym
jest średnik, tak, jak w normalnych deklaracjach typów zmiennej.

•Konstruktor obiektu Karta, o ZAWSZE nazwie takiej samej jak klasa
jest w obszarze opisu klasy tylko deklarowany i podawana jest lista
jego argumentów. Nie podajemy typu pomimo, że jest funkcją.

•Ciało konstruktora, który jest funkcją, jest opisywane

poza

blokiem main()

•W bloku definiowania klasy deklarowane są także funkcje
składowe klasy, które dalej będą metodami obiektów klasy. W
przykładzie jest to funkcja Druk().

•Opis funkcji klasy umieszczamy po bloku main() tak, jak opis
konstruktora ale może być podany także wewnątrz bloku deklaracji
klasy.

Opis kodu:

Wiersze 5-11: początek i koniec opisu klasy Karta zawierający
deklaracje konstruktora Karta i funkcji Druk() oraz
wykorzystywanych zmiennych, tablicy char[80] oraz zmiennej
całkowitej wym.

class Karta

{

public:

char kol[80];

int wym;

Karta(char*, int);

void Druk();

};

Wiersze 12-25: blok main(), w którym powołane są dwa obiekty klasy Karta o
nazwach k1 i k2 w wierszu 14ym. Obiekty mają argumenty takie, jakie
zadeklarowano w konstruktorze, czyli zmienna typu char oraz zmienna
integer. WNIOSEK: deklaracja konstruktora musi zawierać to, co
potem jest potrzebne w funkcjonowaniu obiektów konstruowanych w
klasie. W każdym obiekcie k1 oraz k2 wartości zmiennych deklarowanych są
zainicjowane poprzez podanie konkretnych wartości.

void main()

{

Karta k1(“czarna”,5),k2(“czerwona”,8);

k1.Druk();

k2.Druk();

strcpy(k1.kol,”czarno-czerwona”);

k2.wym=28;

cout<<endl;

k1.Druk();

k2.Druk();

getch();}

Wiersze 26-33: definicja konstruktora klasy. Najpierw nazwa Karta, a
potem operator :: czyli operator zakresu. Teraz już na liście
argumentów formalnych podane są nazwy argumentów s oraz w. Po
liście argumentów formalnych może ( ale nie musi) pojawić się
dwukropek i lista inicjalizująca wartości argumentów, czyli
argumenty początkowe. Następnie w nawiasie klamrowym, po
którym nie ma średnika umieszczamy ciało konstruktora. W ciele
konstruktora, w wierszu 27 mamy kopiowanie łańcucha nazwy
koloru karty z s do kol.

Karta::Karta(char* s,int w): wym(w)
{

strcpy(kol,s);

}

Wiersze 34-36: definicja funkcji własnej klasy Karta o
nazwie Druk(). Jest ona wykonywana w bloku main() na
rzecz obiektów k1 oraz k2. To, że jest ona funkcją własną
klasy Karta wskazuje nazwa klasy rozpoczynająca
definicję i operator zakresu :: , który wskazuje, że funkcja
działa w całym zakresie ważności klasy. Funkcja Druk()
wykonuje na ekranie wypisanie nazwy koloru karty i jej
wartości punktowej.

void Karta::Druk()
{
cout<<”\nkolor=”<<kol<<”,wymiar=”<<wym;
}

k1.Druk();
k2.Druk();

Kolor obiektu k1 jest modyfikowany w wierszu 18
funkcją strcpy. W składni wymienia się nazwę
obiektu, a po kropce nazwę argumentu
zmienianego. W wierszu 19 modyfikowany jest
argument wym obiektu k2 poprzez zwykłą operację
przypisania nowej wartości.

k1.Druk();
k2.Druk();
strcpy(k1.kol,”czarno-czerwona”);
k2.wym=28;

WNIOSEK:

Klasa a obiekt

Widać, że

klasa nie definiuje konkretnych

obiektów tylko ich typy

!!! Jest ona typem

obiektu jako abstrakcyjnej zmiennej, a nie
obiektem lub zbiorem obiektów

.

Uwagi ogólne do konstruktorów:

1. Konstruktor

NIE MUSI

wystąpić w opisie klasy, czyli

obiekty nie muszą być wprowadzane konstruktorem.

2. Nazwa konstruktora może być przeładowana

, czyli

stosowana wielokrotnie w opisie klasy z różnymi
listami argumentów. Wtedy kompilator odróżnia
konstruktory po listach argumentów, tak, jak w
przypadku przeładowanych nazw funkcji.
Konstruktorów może wiec być wiele.

3. Konstruktor

może być wywoływany ( a nie

deklarowany!!) bez żadnych argumentów

. Jest to tak

zwany konstruktor domniemany. Czasem nazywamy
go domyślnym albo standardowym. Ze względu na
istotę przeładowania nazwy konstruktor domniemany
czyli bezargumentowy może wystąpić tylko raz. Jeśli
nie deklarujemy w klasie żadnego konstruktora, to
kompilator sam ustanawia właśnie konstruktor
domniemany do obsługi obiektów w programie. Każdy
konstruktor z argumentami, którym nadamy wartości
domyślne czyli niedefiniowalne jest także
konstruktorem domniemanym.

•

Konstruktor jest zwykle deklarowany jako
publiczny, bo przecież wprowadzane nim
obiekty mogą być używane przez klasy
zewnętrzne. Możemy jednak dla
konstruktora przewidzieć ochronę tak, jak
dla klas za pomocą etykiet private lub
protected. Wówczas jednak także
konstruowane obiekty będą dostępne tylko
w obrębie klasy z tym konstruktorem jako
private albo jako protected tylko w
zakresie klas dziedziczących.

Konstruktor może zamiast definiować
obiekty podawać kopie obiektów zawartych
w innej klasie. Wtedy jest to tak zwany

konstruktor kopiujący

.

Konstruktor może dokonywać konwersji
typu obiekty z jednego w drugi. Nazywamy
go wtedy

konstruktorem konwertującym

.

Przykład: Konstruktor domniemany

#include
<iostream.h>
#include <conio.h>
#include <string.h>
#include <dos.h>
class X
{
public:
char kol[80];
int wym;

X(char* s=“?”, int
w=-1);

void Druk();
};

#include <iostream.h>
#include <conio.h>
#include <string.h>
#include <dos.h>
class Karta
{
public:
char kol[80];
int wym;

Karta(char*, int);

void Druk();
};

void main()
{
clsscr();

X k1,k2(“fiolet”);

k1.Druk();
k2.Druk();
strcpy(k1.kol,”biala”);
strcpy(k2.kol, k1.kol);
k1.wym+=10;
k2.wym=k1.wym*5;
cout<<endl;

k1.Druk();
k2.Druk();
cout<<”\n\n”<,”size=”<<si
zeof(k1);
cout<<”\n\n”<,”size=”<<si
zeof(X);
 
getch();
}

void main()
{
clsscr();

Karta
k1(“czarna”,5),k2(“czerwona”,8);

k1.Druk();
k2.Druk();
strcpy(k1.kol,”czarno-
czerwona”);
k2.wym=28;
cout<<endl;

k1.Druk();
k2.Druk();
getch();
}

X::X(char* s,int w)
{
wym=w;
strcpy(kol,s);
}
void X::Druk()
{
cout<<”\nkolor=”<<kol<<”,w
ymiar=”<<wym;
}

Karta::Karta(char* s,int w):
wym(w)
{
strcpy(kol,s);
}
void Karta::Druk()
{
cout<<”\nkolor=”<<kol<<”,wy
miar=”<<wym;
}

Cechy obiektów

• Poprzez sposób definiowania obiektu decydujemy o zakresie

ważności jego nazwy czyli także o czasie jego życia.

• Jeśli obiekt jest definiowany w dostępie publicznym to

rozumiemy, że jest dostępny globalnie (uwaga na Grębosza

i pomyłkę pomiędzy pojęciem zmiennej typu wbudowanego

i obiektem) czyli mogą z niego korzystać wszystkie funkcje i

obiekty innych klas w programie.

• Obiekt może funkcjonować lokalnie (obiekt prywatny) i

wówczas automatycznie kończy się jego zakres ważności

wtedy, kiedy fragment programu (klasa, blok) pozostaje

zakończona faktycznie. Taki obiekt –podobnie jak zmienna

lokalna – traci swoje cechy (pomimo hermetyzacji) w

zakresie wartości jego zmiennych i metod. Taki obiekt,

podobnie jak zmienną lokalną, będziemy uważać za

zapisywany automatycznie.

Cechy obiektów

• Obiekt globalny jest inicjalizowany inaczej niż lokalny bo

wstępnie (zanim zacznie funkcjonować jako konkret) jest
inicjowany zerami.

• Obiekt mogę powołać do życia jako obdarzony atrybutami. W

szczególności może to być atrybut static. Taki obiekt, nawet
jeśli jest lokalny, zachowa swoje wartości zmiennych i metod
takie, jak przy ostatnim komunikacie. Inicjalizacja jest tu
podobna jak obiektu globalnego – wartościami zerowymi.

• Jeśli atrybutu static użyjemy do nazwy globalnej, to może

ona być dostępna TYLKO W SWOIM PLIKU. Oznacza to, że
nie mogę uzyskać dostępu do takiego obiektu wtedy, kiedy
jest on w pliku dołączonym dyrektywą preprocesora include
jako plik nagłówkowy.