Obiekty jako zmienne w pamięci 

dynamicznej komputera – 

abstrahowanie zmiennych 

wykład 3 

 

Składniki klasy-podsumowanie 

• Składnikami  klasy  mogą,  i  najczęściej  muszą  być 

deklarowane 

zmienne, 

funkcje, 

nazywane 

wówczas  funkcjami  składowymi,  a  także  obiekty 

innych  klas  i  deklarowane  konstruktory  obiektów 

własnych  klasy.  Składnikiem  klasy  będzie  też 

konstruktor 

domniemany, 

kopiujący 

i 

konwertujący  występujące  niejawnie  na  rzecz 

obiektów klasy.

• Funkcje  wchodzące  w  skład  klasy  w  tym 

znaczeniu,  że  wykonują  czynności  na  rzecz 

obiektów  klasy  mogą  być  definiowane  wewnątrz 

klasy  albo  na  zewnątrz  po  bloku  main()  tak,  jak 

inne  funkcje.  Mogą  funkcje  składowe  klasy  być 

także  funkcjami  biblioteki  standardowej  i  wtedy 

odpowiednie  pliki  nagłówkowe,  zawierające  te 

funkcje,  należy  dołączyc  preprocesorem.  W 

przykładach  omawianych  była  to  na  przykład 

funkcja strcpy() z pliku bibliotecznego string.h.

Funkcja wykorzystywana dalej jako metoda 
obiektów może się znaleźć w pliku nagłówkowym 
i nie spowoduje to kłopotów z linkowaniem 
programu, kiedy będzie się ona wielokrotnie 
wywoływana w programie. Tak samo zachowują 
się funkcje z biblioteki standardowej. Jest to 
możliwe dlatego, że taka funkcja składowa klasy 
jest po kompilacji traktowana jako funkcja typu 
inline, czyli wywoływana jednokrotnie. Każde jej 
następne wywołanie to po prostu wykonanie ciała 
funkcji bez konieczności poszukiwania jej adresu 
przy każdym wywołaniu.

Przykład:
Plik osoba.h
-------------------------------------------------------------------
#include<iostream.h>

#include<string.h>

class Osoba{
char nazwisko[80];
int wiek;
public:

void zapamietaj(char *napis, int lata);

void wypisz() { 
cout<<”\t”<<nazwisko<<”,lat:”<<wiek<<endl;}
/// FUNKCJA  wypisz JEST WEWNATRZ CIALA KLASY
};

Zdefiniowany został plik nagłówkowy, który będzie włączany 
wszędzie tam, gdzie w programie stosowana będzie klasa 
Osoba.
Funkcja składowa klasy nazwana wypisz (...) wszędzie tam, 
gdzie zostanie zastosowana będzie miała tylko formę:
 

cout<<”\t”<<nazwisko<<”,lat:”<<wiek<<endl;
 
 Nie będzie każdorazowo wywoływana. Gdyby jednak funkcja 
była 

zdefiniowana poza ciałem klasy to nie może wystąpić w 

pliku nagłówkowym

 bo pojawią się błędy linkowania 

(konsolidacji). 
Jeśli funkcji składowych klasy jest wiele to warto przygotować 
plik nagłówkowy, w którym są one definiowane wewnątrz 
klasy.

Funkcja i wskaźnik this 

Rozpatrzmy funkcję klasy Osoba opisaną poniżej
 
void Osoba::zapamietaj(char *napis, int lata)

{

strcpy(nazwisko,napis);
wiek=lata;

}

Powołajmy do życia kilka obiektów klasy Osoba:
 
Osoba student1, student2, profesor, technik, inżynier
 
Mamy  pięć  obiektów  i  chcemy,  aby  do  konkretnego  wpisany 

został wiek =23.

Wykonujemy  to  za  pomocą  podanej  wyżej  funkcji  na  przykład 

następująco:

 
student2.zapamietaj(’’Tomek Gawin’’,23);

Funkcja  musi  odszukać  obiekt  student2  aby  wykonać  operację  na 
jego rzecz. Robi to tak, że korzysta z ukrytego przed nami wskaźnika 
this, który jest inicjalizowany w momencie pojawienia się operatora 
kropki po nazwie obiektu. Ten wskaźnik pokazuje funkcji na którym 
egzemplarzu  (konkrecie,  instancji)  obiektów  klasy  ma  wykonać 
swoje czynności. Oznacza to, że postać funkcji należy rozumieć tak:
 
void Osoba::zapamietaj(char *napis, int lata)

{

strcpy(this->nazwisko, napis);
this->wiek=lata;

}

 Tablica  nazwisko  i  zmienna  wiek  zostają  „podczepione”  pod 
wskaźnik obiektu.
Zauważcie, że zmienna typu char jest w opisie funkcji wskaźnikiem 
do  zmiennej  napis.  To  zapewni  bezbłędne  zadziałanie  operacji  this. 
Wskaźnik  this  jest  wstawiany  we  właściwe  miejsce  poza  nasza 
wiedzą. Jest to wskaźnik stały czyli typu 
 

X const*

gdzie X to nasz obiekt.

this - WSKAŹNIK SPECJALNY 

• Każdej funkcji - metodzie zadeklarowanej 

wewnątrz klasy zostaje w momencie 

wywołania w niejawny sposób (ang. 

implicitly) przekazany wskaźnik do obiektu (w 

stosunku do którego funkcja ma zadziałać). 

Pointer wskazuje funkcji w pamięci ten 

obiekt, którego członkiem jest dana funkcja. 

Bez istnienia takiego właśnie wskaźnika nie 

moglibyśmy stosować spokojnie funkcji, nie 

moglibyśmy odwoływać się do pola obiektu, 

gdybyśmy nie wiedzieli 

jednoznacznie, o który obiekt chodzi. 

this - WSKAŹNIK SPECJALNY, c.d.

• Program posługuje się automatycznie niejawnym 

wskaźnikiem do obiektu (ang. implicit pointer). Możemy 

wykorzystać ten istniejący, choć do tej pory nie widoczny dla 

nas pointer posługując się słowem kluczowym this (ten). This 

pointer wskazuje na obiekt, do którego należy funkcja. 

Korzystając z tego wskaźnika funkcja może bez cienia 

wątpliwości zidentyfikować właśnie ten obiekt, z którym 

pracuje a nie obiekt przypadkowy. 

[!!!] FUNKCJE KATEGORII static NIE OTRZYMUJĄ POINTERA 

this. 

Należy pamiętać, że wskaźnik this istnieje wyłącznie podczas 

wykonywania metod (ang. class member function execution), 

za 

wyjątkiem funkcji statycznych. 

Obiekt jako zmienna – przesyłanie 

obiektu do funkcji 

Przesyłanie obiektu przez wartość

Przykład:
 
Plik prezentacja.c
 
///////
 
#include<iostream.h>
#include ”osoba.h”
///////
void prezentacja (Osoba);

//

nazwa klasy jest w tej deklaracji typem 

argumentu funkcji 

///////

void main()
{
Osoba kompozytor, autor; 

//

wywolanie obiektow klasy 

Osoba do zycia

kompozytor.zapamietaj(”Aleksander Borodin”, 54);
autor.zapamietaj(”Alosza Jerofiejew”, 33);
/// 

teraz wywołamy obiekty poprzez wywołania funkcji, w której 

sa one argumentami

 
//////
prezentacja(kompozytor);

//

argument podany jawnie czyli przez 

wartosc

prezentacja(autor);
}
/////////
void prezentacja(Osoba ktos)

// 

to jest opis ciala funkcji i tu 

argument ma już nazwe poza typem

{
cout<<”\n przedstawiam panstwu , oto we wlasnej osobie:”;
ktos.wypisz();
}

Co wytworzymy na ekranie poprzez wykonanie tego 
programu?
 
przedstawiam panstwu, oto we wlasnej osobie 
Aleksander Borodin, lat:54
przedstawiam panstwu, oto we wlasnej osobie Alosza 
Jerofiejew, lat:33
 
 
 
Wystąpiło  tu 

stosowanie  obiektu  jako  argumentu 

funkcji.

  Obiekt  inicjalizował  się  jako  kopia  wewnątrz 

funkcji.  Przy  obiektach  o  skomplikowanej  budowie  nie 
jest  to  dobry  sposób,  bo  tworzenie  kopii  obiektu 
wewnątrz funkcji musi trwać odpowiednio długo.
Wypisanie na ekran nastąpiło za pomocą funkcji 
dołączonej w pliku nagłówkowym osoba.h. 

Przesyłanie obiektu przez referencję

Przesyłanie  przez  referencję  działa  tak  samo  jak  dla  wszystkich 
innych  zmiennych  w  programie. 

Referencja  działa  jak  przezwisko 

zmiennej

  pokazujące,  gdzie  jej  szukać.  Nie  jest  tworzona  kopia 

zmiennej  w  funkcji,  a  tylko  podawane  miejsce  jej  ulokowania.  W 
podanym przykładzie wystarczy zmienić postać funkcji prezentacja.
 
Przykład:
 
Plik prezentacja.c
 
///////
 
#include<iostream.h>
#include <osoba.h>
///////

void prezentacja (Osoba

&

);

///////
main()
{
Osoba kompozytor, autor;
kompozytor.zapamietaj(’’Aleksander Borodin”, 54);
autor.zapamietaj(’’Alosza Jerofiejew”, 33);
/// teraz wywołamy obiekty poprzez wywołania funkcji
 
//////
prezentacja(kompozytor);
prezentacja(autor);
}
/////////
 
void prezentacja(Osoba

&

 ktos)

{
cout<<”\n przedstawiam panstwu  ,oto we wlasnej osobie:”;
ktos.wypisz();
} 
Czyli argument funkcji jest deklarowany przez referencję i obiekt i to 
wystarcza aby funkcja pracowała na oryginale obiektu w miejscu jego 
ulokowania na stosie RAM. Tworzenie kopii nie jest teraz konieczne. 

Operatory new i delete 

Podczas  deklarowania  zmiennych  rezerwowany  jest  dla  ich  obszar 
pamięci.  Jeśli  się  do  zadeklarowanych  zmiennych  odwołamy,  to 
program  musi  wiedzieć,  gdzie  dokładnie  szukać  ich  wartości  w 
pamięci operacyjnej. 
Szczególne  kłopoty  powstają  wówczas,  kiedy  deklarujemy  zmienną, 
która  ma  wiele  elementów  o  różnych  lokalizacjach  w  RAM.  Taką 
zmienną  jest  np.  tablica.  Jak  pamiętamy,  nie  możemy  się  do  niej 
odwołać  w  programie  jeśli  w  momencie  odwołania  nie  jest  znany 
rozmiar tablicy.
Możemy  zastosować  odwołanie  dynamiczne  do  pamięci  za  pomocą 
operatora new. Wtedy wystarczy nazwa zmiennej, w tym tablicy i nie 
musimy  znać  jej  rozmiaru,  a  mimo  to  wszystkie  elementy  zostaną 
poprawnie  odszukane  do  dalszego  zastosowania  w  programie. 
Operator  new  musi  działać  nie  na  zmiennej  tylko  na  wskaźniku  do 
zmiennej,  czyli  na  wskazaniu  miejsca  (adresu)  w  pamięci 
operacyjnej. Mówimy potocznie, że jest to miejsce na stercie (heap).

Przykład: program tworzy listę osób z nazwiskami i imionami. Dane 
o  osobach  umieszczane  są  w  tablicach.  W  jednej  umieszcza  się 
nazwiska,  a  w  drugiej  imiona.  Do  opisu  posłuży  obiekt,  który  ma 
adres zwracany przez operator new.
 
#include <conio.h>
#include <stdlib.h>
#include <string.h>
 
class Osoba {
public:
char imie[80], nazw[80];
};

void main()
{
//void clrscr();
Osoba *p1=new Osoba, *p2=new Osoba;
if(!p1||!p2)
{
cprintf(“\n\rp1 i/lub p2?”);
getch();
exit(0);
}
strcpy(p1->imię,”Jan”);
strcpy(p1->nazw,”Krol”);
*p2= *p1;
strcpy(p1->imię,”Ewa Nowak-”);
cprintf( ”\n\r%s%s”,p1->imie, p1->nazw);
cprintf( ”\n\r%s%s”,p2->imie, p2->nazw);
delete p1;delete p2;
getch();
}

Sposób 
użycia 
operatora 
new do 
obiektów

Co zobaczymy na ekranie?
 

Jan Krol
Ewa Nowak-Krol

 
Jak to działa?
Pliki nagłówkowe: conio.h zawierają biblioteki do funkcji cprintf(); 
string.h zawiera biblioteczna funkcje strcpy();. 

#include <conio.h>

#include <stdlib.h>
#include <string.h>
Niektóre pliki nagłówkowe nie musza być pisane z 
rozszerzeniem h.

Klasa  Osoba  nie  zawiera  konstruktora.  Po  kompilacji  mamy  więc 
konstruktor  Osoba  domniemany.  Dostępne  są  dla  każdego  obiektu 
tego konstruktora zmienne tablicowe: imie[], nazw[].

class Osoba {
public:
char imie[80], nazw[80];
};

Obiekty  p1  i  p2  jako  konkrety  klasy  Osoba  zostają  przywołane 
poprzez  wskaźniki  o  adresach  zwracanych  operatorem  new.  Ten 
operator  przydziela  jednocześnie  wskaźnikom  *p1  oraz  *p2  miejsca 
w  pamięci.  Może  się  zdarzyć,  że  w  RAM  nie  będzie  miejsca  na 
przydzielenie  pamięci  dla  p1  oraz  p2.  Wtedy  zostanie  im  nadana 
przez  operator  new  wartość  NULL.  Gdyby  tak  się  zdarzyło,  to 
zostanie  to  wykryte  przez  if(!p1||!p2),  a  potem  wydrukowane  w 
formie  wartości  p1  oraz  p2  na  ekranie  w  kolejnym  wierszu 
programu.  Następnie  wykonana  by  była  instrukcja  exit(0),  co 
oznacza  zakończenie  programu  poprze  wyjście  poza  ostatnia  linię 
kodu. Funkcja exit() jest umieszczona w pliku stdlib.h.

Osoba *p1=new Osoba, *p2=new Osoba;

if(!p1||!p2)

{

cprintf(“\n\rp1 i/lub p2?”);

getch();

exit(0);

} 

Funkcja  strcpy()  z  biblioteki  nagłówkowej  string.h  kopiuje 
łańcuchy  Jan  oraz  Krol  do  tablic  imie[]  i  nazw[].  Tablice  są  w 
obiekcie wskazywanym przez p1. Jeśli obiekt jest wskazywany przez 
wskaźnik,  to  odwołujemy  się  do  niego  operatorem  strzałki,  a  nie 
kropki jak w poprzednich przykładach.
Pod adres wskaźnika p2 zostaje wpisana deferencja czyli zawartość 
spod adresu *p1. 

strcpy(p1->imię,”Jan”);
strcpy(p1->nazw,”Krol”);
*p1= *p2;

Do tablicy imie[] wskazywanej przez p2 kopiowany jest łańcuch Ewa 
Nowak-.
Drukowane są tablice z obiektów p1 oraz p2.
Operator  delete  usuwa  obiekty  p1  oraz  p2  ze  sterty  pamięci 
dynamicznej i tym samym zwalnia pamięć.

strcpy(p1->imię,”Ewa Nowak-”);
cprintf( ’’\n\r%s%s”, p1->imie,p1->nazw);
cprintf( ’’\n\r%s%s”, p2->imie,p2->nazw);
delete p1;delete p2;

getch();
}

Wskaźniki do obiektów

• Wskaźniki do obiektów funkcjonują podobnie jak wskaźniki 

do 

struktur. Operator -> pozwala na dostęp zarówno do danych 

jak i 

do funkcji. Dla przykładu wykorzystamy obiekt naszej 

prywatnej 

klasy Licznik. 

class Licznik 

{ 

public: 

char moja_litera; 

int ile; 

Licznik(char znak) { moja_litera = z; ile = 0; } 

void Skok_licznika(void) { ile++; } 

}; 

Wskaźniki do obiektów, c.d.

• Aby w programie można było odwołać się do obiektu nie 

poprzez 

nazwę a przy pomocy wskaźnika, zadeklarujemy wskaźnik 

do 

obiektów klasy Licznik: 

Licznik *p; 

Wskaźnik w programie możemy zastosować np. tak: 

p->Skok_licznika(); 

(czytaj: Wywołaj metodę "Skok_licznika()" w stosunku do 

obiektu 

wskazywanego w danym momencie przez wskaźnik p) 

Wskaźniki do obiektów, c.d.

• Trzeba pamiętać, że sama deklaracja w 

przypadku referencji i wskaźników nie 

wystarcza. Przed użyciem należy jeszcze  

zainicjować wskaźnik w taki sposób, by 

wskazywał na nasz  obiekt-licznik. 

Wskaźnik do obiektu inicjujemy w taki sam 

sposób jak każdy inny pointer: 

p = &Obiekt;