Wykład 3

Konstruktor – cechy 

główne

Co robi konstruktor?

Wywołanie konstruktora powoduje wykonanie następujących zadań:

• obliczenie rozmiaru obiektu 

• alokacja obiektu w pamięci 

• wyczyszczenie (zerowanie) obszaru pamięci zarezerwowanej dla 

obiektu (tylko w niektórych językach) 

• wpisanie do obiektu informacji łączącej go z odpowiadającą mu 

klasą (połączenie z metodami klasy) poprzez wskaźnik this

• wykonanie kodu klasy bazowej (w niektórych językach nie 

wymagane) 

• wykonanie kodu wywołanego konstruktora 
Z wyjątkiem ostatniego punktu powyższe zadania są wykonywane 

wewnętrznie i są wszyte w kompilator lub interpreter języka, lub 

w niektórych językach stanowią kod klasy bazowej.

W językach programowania w różny sposób oznacza się konstruktor:

• w C++, PHP4, Javie  i in. - jest to metoda o nazwie zgodnej z 

nazwą klasy 

• w Pascalu - metoda której nazwę poprzedzono słowem kluczowym 

constructor. 

• w PHP 5 - metoda o nazwie __construct 

Uwagi ogólne do konstruktorów:

1. Konstruktor 

NIE  MUSI

  wystąpić  w  opisie  klasy,  czyli 

obiekty  nie  muszą  być  jawnie  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 więc 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, a ponadto jest 
funkcją, która MUSI być dostępna dla składników 
klasy. 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

.

Konstruktor kopiujący 

Przyjrzyjmy się wywołaniu konstruktora klasy o nazwie klasa:
 
klasa::klasa(klasa&)
 
Jego argumentem jest referencja do obiektu danej klasy. Czyli do 

elementu,  który  w  chwili  uruchomienia  tego  konstruktora  już 
istnieje.  Taki  konstruktor  nie  konstruuje  obiektu  tylko  tworzy  kopię 
innego, który już istnieje wśród obiektów klasy. Pozostałe argumenty 
konstruktora są domniemane. Przykładami konstruktora kopiującego 
mogą być:

X::X(X&)
 
lub
 
X::X(X&, float=3.1415, int=0)
 

Konstruktor kopiujący c.d.

• Taki konstruktor wprowadza obiekty identyczne z już 

istniejącymi, czyli ich kopie.

• Taki konstruktor może być wywołany przez program 

niejawnie:

1.W sytuacji gdy do funkcji jest 

przez wartość

 przesyłany 

obiekt klasy X. Wówczas tworzona jest kopia tego obiektu. 

Jest to tzw. kopiowanie płytkie.

2.W sytuacji kiedy funkcja zwraca przez wartość obiekt klasy 

X. Wtedy także tworzona jest kopia obiektu. To także jest 

kopiowanie płytkie.

To, że konstruktor kopiujący podaje obiekt kopiowany przez 

referencję daje mu możliwość 

zmiany zawartości obiektu 

klasy!!

 (patrz przesyłanie argumentu do funkcji przez 

wartość)

Konstruktor kopiujący c.d.

• Nie można pominąć referencji w konstruktorze 

kopiującym, bo gdyby konstruktor X wywoływał 

obiekty swojej klasy X przez wartość, czyli 

wytwarzałby swoją kopię, to powstaje nie zamknięta 

pętla tworzenia kopii. 

• Konstruktor z przyczyn logiki języka otrzymuje więc 

warunki do tego aby uszkodzić oryginał!! 

• Zabezpieczamy się przed taką sytuacją następująco:

X::X(const X&obiekt)

• Teraz konstruktor X wie, że obiekt klasy X musi być 

wywoływany jako stały. Konstruktor kopiujący jest 

domyślnie obdarzony moderatorem const, czyli nie 

może zmienić sam siebie.

Kopiowanie płytkie i głębokie

Wyróżniamy dwa typy kopiowania obiektów 

zawierających pola będące wskaźnikami

• Kopiowanie płytkie
a. Kopiowanie wszystkich składowych (w tym 

wskaźników)

b. Kopiowane są wskaźniki, a nie to, na co wskazują
• Kopiowanie głębokie
a. Alokacja nowej pamięci dla wskaźników
b. Kopiowanie zawartości wskazywanej przez 

wskaźniki w nowe miejsce

 c. Kopiowanie pozostałych pól, nie będących 

wskaźnikami

Głębokie kopiowanie

Kiedy obiekt zawiera wskaźnik do dynamicznie zaalokowanego 

obszaru, należy zdefiniować operator przypisania 

wykonujący głębokie  kopiowanie

•

W rozważanej klasie należy zdefiniować operator 

przypisania:
AType& AType::operator=(const AType& otherObj)

•

Operator przypisania powinien uwzględnić przypadki 

szczególne:

1.

Sprawdzić przypisanie obiektu do samego siebie, np. A=A:

2.

if (this == &otherObj) // if true, do nothing

3.

Skasować zawartośc obiektu docelowego

4.

delete this->...

5.

Zaalokować pamięć dla kopiowanych wartości

6.

Przepisać kopiowane wartości

7.

Zwrócic *this

Konstruktor kopiujący a operator 

przypisania

Konstruktor kopiujący jest więc używany do 

stworzenia nowego obiektu

• Wydaje się prostszy od operatora przypisania - 

nie musi sprawdzać przypisania do samego siebie 

i zwalniać poprzedniej zawartości

• Jest użyty do skopiowania parametru aktualnego 

do parametru formalnego przy przekazywaniu 

parametru przez wartość

• Przy tworzeniu nowego obiektu, można go 

zainicjalizować istniejącym obiektem danego 

typu. Wywołany jest wówczas konstruktor 

kopiujący.

Konstruktor kopiujący a operator 

przypisania c.d.

• int main() {
• list a;
• //...
• list b(a); //copy constructor  is called
• list c=a; //copy constructor is called
• };

 
 
1.#include<iostream>
2.#include<string.h>
3.#include<conio.h>
4.class X
5.{public:char*p; X(char*);
6.};
7.class Y
8.{public:
9.char*p; Y(char*);
10.

Y(Y&);

// deklaracja konstruktora kopiajacego obiekty klasy Y

11.};
12.void main()
13.{
14.X x("xxx"); X j=x;

//powolanie do zycia obiektow x,j klasy X

15.cout<<"\nx="<<x.p<<",  j="<<j.p;    //  wydruk  wskaznika  czyli  adresu  do 

obiektow x,j

16.strcpy(j.p,"111"); // skopiowanie pod wskaznik obiektu j lancucha 111
17.cout<<"\nx="<<x.p<<", j="<<j.p;

Przykład: konstruktor kopiujący będzie kopiował wskaźnik do 

obiektu. ( czy to tzw. kopiowanie głębokie ?)

18.cprintf("\n\rx.p=%p, j.p=%p,x.p,j.p);
19.Y y("yyy"); Y d=y; //

powołanie obiektów klasy Y

20.cout<<"\ny="<<y.p<<", d="<<d.p;
21.strcpy(y.p,"222");
22.cout<<"\ny="<<y.p<<", d="<<d.p;
23.cprintf("\n\ry.p=%p, d.p=%p,y.p,d.p);
24.getch();
25.}
26.X::X(char*s)
27.{p=new char[80]; if(p)strcpy(p,s);
28.}
29.Y::Y(char*s)
30.{p=new char[80]; if(p)strcpy(this->p,s);
31.}
32.Y::Y(Y&y)
33.{p=new char[80]; if(p)strcpy(p,y.p);
34.}

Omówienie przykładu:

5.{public:char*p; X(char*);

Wiersz  5:  etykieta  public  dla  klasy  X  oraz  deklaracje 
zmiennej  własnej  p,  która  jest  wskaźnikiem  do  zmiennej 
znakowej oraz konstruktor obiektów klasy X oczekującego 
na  liście  parametrów  formalnych  wskaźnika  do  zmiennej 
typu  string  lub  charakter.  Ciało  tego  konstruktora  jest 
podane w wierszu 26-28:

26.X::X(char*s)
27.{p=new char[80]; if(p)strcpy(p,s);
28.}

Wiersz 8-9: analogiczny jak wiersz 5 ale dla klasy Y 

8.{public:
9.char*p; Y(char*);

Wiersz 9: konstruktor kopiujący klasy Y. Będzie on 
kopiował wskaźnik do zmiennej znakowej, którą 
wskaże. Może to być zmienna z innej klasy czyli z 
innego typu zmiennej obiektowej. Na tym polega 
kopiowanie głębokie. W klasie X funkcjonuje konstruktor 
kopiujący domyślny tworzony podczas kompilacji. Daje 
on kopiowanie płytkie, czyli dotyczące tylko składników 
własnej klasy X.

13.{
14.X x("xxx"); X j=x; //powolanie do zycia obiektow

x,j klasy X

Wiersz  13-14:  tworzymy  obiekt  x  oraz  obiekt j klasy X.  Do  obiektu  x 
wpisywany  jest  element  tablicy  zarezerwowanej  dla  niego  przez 
konstruktor  w  wierszu  26.  Obiekt  j  jest  inicjalizowany  obiektem  x. 
Kopiowanie x do j jest realizowane przez konstruktor domyślny klasy 
X.  Przepisuje  on  wskaźnik  do  obiektu  x  do  wskaźnika  do  obiektu  j. 
Dlatego wskaźnik p w obiekcie j będzie wskazywał to samo miejsce co 
wskaźnik  p  w  obiekcie  x.  Dlatego  wydruk  w  wierszu  14  powinien 
podać ten sam wynik dla każdego z tych obiektów.
Zauważmy, że obiekt j nie ma zarezerwowanej swojej przestrzeni na 
tablice  znakową,  korzysta  natomiast  ze  zmiennej  wskaźnikowej 
własnej p z klasy X do podłączenia się do tej samej tablicy co obiekt 
x.  Dlatego  pojawia  się  szczególny  zapis  obiektów  x  oraz  j  połączony 
ze zmienną własną wskaźnikową p. 
15.cout<<"\nx="<<x.p<<",  j="<<j.p;    //  wydruk  wskaznika  czyli 
adresu do obiektow x,j
16.strcpy(j.p,"111");  //  skopiowanie  pod  wskaznik  obiektu  j  lancucha 
111
17.cout<<"\nx="<<x.p<<", j="<<j.p;

15.cout<<"\nx="<<x.p<<", j="<<j.p;  // wydruk wskaznika 
czyli adresu do obiektow x,j
16.strcpy(j.p,"111");  //  skopiowanie  pod  wskaznik  obiektu  j 
lancucha 111
17.cout<<"\nx="<<x.p<<", j="<<j.p;

Wiersz 15-17: do tablicy wskazywanej przez 
wskaźnik p wpisujemy poprzez kopiowanie 
łańcucha wartość ’’111” ale przedtem 
sprawdzamy adresy obiektów.
Wiersz  16:  wydruk  wartości  obiektu  x  oraz  j 
wskazywanych przez zmienną p
Wiersz 17: wydruk adresów wskazywanych przez p 
dla  obiektu  x  oraz  j.  Te  adresy  powinny  być 
jednakowe, czy nie?

18.cprintf("\n\rx.p=%p, j.p=%p,x.p,j.p);
19.Y y("yyy"); Y d=y; 

powołanie obiektów klasy Y

20.cout<<"\ny="<<y.p<<", d="<<d.p;
21.strcpy(y.p,"222");
22.cout<<"\ny="<<y.p<<", d="<<d.p;

Wiersze 18-22: powtórzenie takich samych działań ale dla 
klasy Y. Wprowadzamy obiekty y oraz d, które grają takie 
same role jak poprzednio x oraz j.
Wiersz 21: modyfikujemy łańcuch w obiekcie d.
Wiersz  22:  drukujemy  wartości  obiektów  y  oraz  d  nie   
spodziewając  się  ich  identyczności  jak  poprzednio  dla  x 
oraz  j.  Dlaczego?  Dlatego,  że  konstruktor  Y  działa  przez 
referencję,  a  nie  poprzez  przypisanie  jak  konstruktor 
kopiujący  domyślny.  Łańcuch  d  jest  modyfikowany 
tylko  w  miejscu  d.  Konstruktor  Y  zapewnia  modyfikację 
poprzez referencję. 
Wydruk adresów obiektów y oraz d. Powinny być różne!!

26.X::X(char*s)
27.{p=new char[80]; if(p)strcpy(p,s);
28.}

Wiersz 26-28: ciało konstruktora obiektów klasy X.  
Operatorem new jest dynamicznie przydzielona 
pamięć dla tablicy 80cio  znakowej.  Kopiowanie 
łańcucha z listy parametrów formalnych konstruktora 
do tablicy nastąpi tylko wtedy, kiedy operator new tę 
pamięć przydzieli.

29.Y::Y(char*s)

30.{p=new char[80]; if(p)strcpy(this->p,s);

31.}

32.Y::Y(Y&y)

33.{p=new char[80]; if(p)strcpy(p,y.p);

34.}

Konstruktory klasy Y. Konstruktor kopiujący powiela 
postać konstruktora poza wskazaniem, że dozwala 
na kopiowanie obiektów klasy Y do wskaźnika p spod 
adresy każdego obiekty klasy Y.

Rezultat na ekranie (przykładowy):
 
x=xxx, j=xxx
x=111, j=111
x.p=2707:0004, j.p=2707:0004
y=yyy, d=yyy
y=yyy, d=222
y.p=270D:0004, d.p=2713:0004

Jakie mamy więc metody 

tworzenia obiektów?

Zmienne automatyczne

• Atype a; //konstruktor domyślny
Zmienne automatyczne z argumentami

• Atype a(3); //konstruktor z parametrem int
Przekazywanie parametrów funkcji przez wartość

• void f(Atype b) {...} …..

• Atype a; //konstruktor domyślny

• f(a); //konstruktor kopiujący
Przypisanie wartości zmiennym

• Atype a,b;…..

• a=b; //operator przypisania
Inicjalizacja nowych obiektów

• Atype b; //konstruktor domyslny

• Atype a=b; //konstruktor kopiujący (NIE operator 

przypisania)

Zwracanie wartości z funkcji

• Atype f() {

• Atype a; //konstruktor domyślny

• return a; //konstruktor kopiujący

• }

Cechy (zalecane) poprawnie 

napisanej klasy

Jawny konstruktor

• Gwarantuje, że każdy zadeklarowany egzemplarz obiektu zostanie 

w kontrolowany sposób zainicjalizowany

Jeżeli obiekt zawiera wskaźniki do dynamicznie zaalokowanej 

pamięci:

A. Jawny destruktor:

• Zapobiega wyciekom pamięci. Zwalnia zasoby podczas usuwania 

obiektu.

B. Jawny operator przypisania

• Używany przy przypisywaniu nowej wartości do istniejącego 

obiektu.

• Zapewnia, że obiekt jest istotnie kopią innego obiektu, a nie jego 

aliasem (inną nazwą).

C. Jawny konstruktor kopiujący

• Używany podczas kopiowania obiektu przy przekazywaniu 

parametrów, zwracaniu wartości i inicjalizacji. Zapewnia, że obiekt 

jest istotnie kopią innego obiektu, a nie jego aliasem.

Wykład 4

Przeciw pełnej 

hermetyzacji

Ukrywanie informacji - etykiety private 

i public 

Jeśli klasa ma etykietę private, to jej składniki będą dostępne tylko w 
zakresie  wnętrza  klasy.  Jeśli  etykiet  nie  ma,  to  w  trybie 
domyślnym  wszystkie  składniki  klasy  są  private.  Są  lokalne  w 
zakresie  ważności  klasy.  Jeśli  etykieta  jest  public,  to  składniki  klasy 
mogą  być  wywoływane  także  spoza  tej  klasy.  Etykietami  możemy 
określać  także  dostęp  do  wybranych  składników  klasy  wybiórczo 
umieszczając  etykietę  przed  nazwą  składnika  klasy.  Wtedy  private  i 
public mają sens podany wyżej. Dodatkowo stosuje się także etykietę 
protected.  Oznacza  ona,  że  taki  składnik  jest  dostępny  tylko  w 
ramach  dziedziczenia  tj.  w  klasach,  które  są  potomkami  klasy 
zawierającej ten składnik.
Tak  więc  etykiety  właśnie  zapewniają  nam  ochronę  dostępu  do 
składników  klasy.  Dane  najczęściej  umieszczamy  w  klasach 
chronionych czyli private. Do ustawiania wartości i pobierania danych 
korzystamy z funkcji składowych klasy. To do nich stosujemy etykiety 
ochrony. Etykiety te są jednym z narzędzi hermetyzacji klasy.

Przykład: 
class chamidlo
{
int a;
float b;
void fun1(int);
protected:
char m;
void fun2(void);

public:

int v;

void fun3(char*);
private:

int d;
void fun4(float b);

}
 
W  tej  klasie  składniki  prywatne,  czyli  dostępne  tylko  w  obrębie 

klasy  chamidlo  to:  a,b,fun1,d,  fun4.  Składniki  protected,  czyli 
zastrzeżone  dla  tej  klasy  i  jej  potomków  to:  m,fun2.  Pozostałe 
składniki  są  publiczne,  czyli  dostępne  dla  wszystkich  elementów 
programu. Są to: v, fun3.

Funkcje zaprzyjaźnione

 
To takie funkcje, które, mimo, że nie są składnikami klasy, to mają 

dostęp  do  jej  składników  czyli  innych  funkcji,  zmiennych  i  obiektów. 
Mają dostęp także do tych składników klasy, które są hermetyzowane 
etykietą  private.  Pamiętajmy,  że  jeśli  nie  ma  innych  etykiet,  to 
wszystkie  składniki  są  private.  Funkcja  zaprzyjaźniona  jest 
wprowadzana instrukcją  friend.

 

Sposób stosowania:
class figura{
 
int x,y;
…….
friend void goniec(figura&)
};

Sama funkcja goniec(figura&) jest zdefiniowana gdzieś w 
programie w całkowicie innym miejscu nie powiązanym z 
klasą pionek. W klasie figura {} chcemy z niej skorzystać 
nawet, jeśli przynależy ona do innej klasy. Wtedy poprawnie 
jest taką funkcję zaznaczyć etykietą  public w jej klasie.
 
Cechy funkcji zaprzyjaźnionych:
*Funkcja może być zaprzyjaźniona z kilkoma klasami.
*Na argumentach jej wywołania może wykonywać operacje 
zgodnie ze swoją definicją.
*Może być napisana w zupełnie innym języku niż C++ i 
dlatego może nie być funkcją składową klasy.

*Ponieważ  funkcja  typu  friend  nie  jest  składnikiem  klasy  to  nie  ma 
wskaźnika  this,  czyli  musi  się  posłużyć  operatorem  wskaźnika,  albo 
przypisania  aby  wykonać  działania  (także  te    na  składniku  klasy,  z 
którą jest zaprzyjaźniona).
*Jest deklarowana w klasie ze słowem instrukcji friend i nie podlega 
etykietom hermetyzcji (public, private, protected).
*Może  być  cała  zdefiniowana  w  klasie  i  wtedy  jest  typu  inline  ale 
nadal jest funkcją zaprzyjaźnioną.
*Nie musi być funkcją składową żadnej klasy ale może nią być.
*Klasa  może  się  przyjaźnić  z  wieloma  funkcjami,  które  są  lub  nie  są 
składnikami innych klas.
*Funkcje zaprzyjaźnione nie są przechodnie, to znaczy, że „przyjaciel 
mego  przyjaciela  nie  jest  moim  przyjacielem”  czyli  zaprzyjaźnienie 
nie przenosi się od klasy do klasy.
*Zaprzyjaźnienie nie podlega mechanizmowi dziedziczenia.
*Z  zasady  umieszcza  się  funkcje  zaprzyjaźnione  na  początku 
wszystkich deklaracji w klasie.

Zaprzyjaźnienie klas

#include <string>
using namespace std;
class Pies {

string kolor, przedmiot; 

int wiek; friend class Kot;

public:

Pies(string, int, string); void drukuj(); 

void zamien(Kot *);
};
class Kot {  string kolor, przedmiot; int wiek; 
friend class Pies;
public:

Kot(string, int, string); void drukuj(); 

void  zamien(Pies *);
void clear() { przedmiot=""; }
};

Zaprzyjaźnienie klas cd.1

Pies::Pies(string aKolor, int aWiek, string aPrzedmiot)
{

•     kolor = aKolor;

•     wiek = aWiek;

•     przedmiot = aPrzedmiot;
}

Kot::Kot(string aKolor, int aWiek, string aPrzedmiot)
{

•     kolor = aKolor;

•     wiek = aWiek;

•     przedmiot = aPrzedmiot;
}

Zaprzyjaźnienie klas cd.2

• void Pies::zamien(Kot *b)

• {

•     string old = b->przedmiot;

•     b->przedmiot = przedmiot;

•     przedmiot = old;

• }    

• void Kot::zamien(Pies *b)

• {

•     string old = b->przedmiot;

•     b->przedmiot = przedmiot;

•     przedmiot = old;

• } 

Zaprzyjaźnienie klas cd.3

• void

• Pies::drukuj()

• {

•     printf("Kolor [%s], wiek [%d], przedmiot [%s]\n", 

kolor.c_str(), wiek,

•         przedmiot.c_str());

• }

• void

• Kot::drukuj()

• {

•     printf("Kolor [%s], wiek [%d], przedmiot [%s]\n", 

kolor.c_str(), wiek,

•         przedmiot.c_str());

• }

Zaprzyjaźnienie klas cd.4

int main(int argc, char* argv[])
{

•     Pies a("czarny", 3, "kosc");     Kot b("bialy", 5, "pilka");

•     a.drukuj();  b.drukuj();

•     printf("\nZamiana...\n\n");     a.zamien(&b);     a.drukuj();  

b.drukuj();

•     printf("\nA zabiera B...\n\n");     a.zamien(&b);     b.clear();

•     a.drukuj();  b.drukuj();

•     printf("\n");     system("PAUSE");

•

return 0;

}

Cechy zaprzyjaźniania klas

• W klasie możemy deklarować przyjaźń z 

funkcjami składowymi innej klasy bez ograniczeń. 
Oznacza to, że obiekty klasy zaprzyjaźnionej i jej 
składniki otrzymują dostęp do wszystkich – także 
prywatnych – składników klasy zaprzyjaźnionej.

• Jedną klasę możemy zaprzyjaźnić z wieloma 

innymi klasami.

• Przyjaźń nie jest przechodnia.
• Zaprzyjaźnianie klas jest wyłączone z procesu 

dziedziczenia, czyli zaprzyjaźnienie nie jest 
dziedziczone.