Referencje

Referencja  jest  czymś  w  rodzaju  synonimu  lub  odsyłacza.  Gdy  tworzy  się 
referencje, to trzeba ją zainicjalizować nazwą innego, docelowego obiektu. Od 
tego  momentu  referencja  spełnia  rolę  alternatywnej  nazwy  dla  obiektu  i 
wszystkie  operacje  wykonywane  na  referencji  będą  również  wykonywane  na 
obiekcie docelowym.
Niektórzy programiści twierdzą, że referencja to wskaźnik. 

Nie jest to prawdą!

 

Oczywiście, zazwyczaj referencje tworzone są z wykorzystaniem wskaźników, 
ale jest to sprawa tylko i wyłącznie twórców kompilatora. 

Trzeba rozróżniać te dwa pojęcia:

 wskaźniki są zmiennymi przechowującymi adresy innych obiektów. 

 referencje są "synonimami" lub odsyłaczami do obiektów.

Tworzenie referencji

Referencję  tworzy  się  poprzez  wpisanie  nazwy  typu  docelowego 
poprzedzonego symbolem operatora referencji ( & ). Następnie należy podać 
nazwę  dla  referencji.  Nazwa  referencji  może  być  dowolną,  poprawną  nazwą 
C++. 

Przyjmijmy że będziemy referencje nazywać zaczynając nazwę od litery r. 

Przykład:

Jeżeli mamy zmienną całkowitą nPom, to można stworzyć do niej referencję w 
następujący sposób:

int &rPom = nPom ;

Taką deklarację można przeczytać: "rPom jest referencją do zmiennej typu int 
zainicjowaną tak, aby odsyłała do zmiennej nPom". 

Przykład:

Zauważ,  że  referencja  jest  od  razu 
inicjalizowana. 

Gdybyśmy 

pominęli 

inicjalizację, kompilator zgłosiłby błąd. 

Wykorzystanie operatora adresu na 

referencjach

Jeżeli  pobierze  się  adres  referencji,  to  otrzyma  się  adres  zmiennej,  którą  ta 
referencja  reprezentuje.  Taka  jest  natura  referencji  -  są  one  odsyłaczami  do 
obiektów docelowych. 

Przykład:

W  C++  nie  ma  możliwości  otrzymania  fizycznego  adresu  referencji  gdyż 
byłoby  to  zbędne  (w  przeciwieństwie  do  wskaźników).  Referencje  są 
inicjalizowane  w  momencie  tworzenia  i  zawsze  stanowią  synonim  obiektu 
docelowego, nawet w przypadku użycia operatora adresu.

Jeżeli mielibyśmy klasę o nazwie Prezydent, to wówczas można zadeklarować 
obiekt tej klasy następująco:

Przykład:

Prezydent oLechWalesa;

Prezydent &rWalesa = oLechWalesa;

Teraz można zadeklarować referencję do obiektu klasy Prezydent:

W pamięci będzie istnieć tylko jeden obiekt. Obydwa stworzone identyfikatory 
odnoszą się do tego obiektu. Każda operacja wykonana na obiekcie  rWalesa 
zostanie również wykonana na oLechWalesa.

Zapamiętaj:  aby  odróżniać  symbol  &  który  deklaruje  referencje  (o 
nazwie  rWalesa)  do  obiektu  klasy  lub  zmiennej,  a  symbolem  & 
zwracającym  adres  zmiennej.  Normalnie,  przy  wykorzystywaniu 
referencji,  nie  jest  potrzebny  operator  adresu.  Po  prostu  używa  się 
referencji tak, jak obiektu docelowego. 

Czasami  nawet  doświadczeni  programiści  nie  są  pewni,  co  się  stanie,  przy 
próbie  ponownego  przypisania  do  referencji.  Okazuje  się,  że  taka  operacja 
powoduje  przypisanie  nowej  wartości  do  obiektu  docelowego  (co  po  chwili 
namysłu jest oczywiste i zgodne z definicją referencji). 

Przykład:

Rezultat  tej  operacji  jest  inny  niż 
zamierzony.  rRef  nadal  jest  powiązana 
ze  zmienną  nPom1,  lecz  zmianie  uległa 
wartość, która jest teraz równa 8.

 

Chcieliśmy zmienić znaczenie referencji 
rRef i przypisać jej nowy obiekt 
docelowy – nPom2. 

Dzieje się tak dlatego ponieważ przypisanie:

nPom1 = nPom2 ;

rRef = nPom2 ;

Do czego można tworzyć referencje?

Referencje  można  stworzyć  dla  dowolnego  obiektu,  niezależnie  od  tego,  czy 
jest  on  standardowym  obiektem  C++  czy  też  zdefiniowanym  przez 
użytkownika. Ważne jest, że referencja odnosi się do konkretnego obiektu, a 
nie do klasy. 

Oznacza to, że nie można napisać tak: int  &rIntRef = int; 

Trzeba zainicjować referencje za pomocą konkretnej zmiennej typu int:

int nPom = 200;
int &rIntRef = nPom ;

Podobnie  rzecz  się  ma  z  obiektami  zdefiniowanymi  przez  użytkownika.  Nie 
można napisać tak:

KOT &rKotRef = KOT ; 

Tutaj, podobnie jak w przypadku zmiennej całkowitej, trzeba zainicjować 
referencję za pomocą konkretnego obiektu klasy KOT:

KOT oFilemon ;
KOT &rKotRef = oFilemon ;

Referencje do obiektów wykorzystuje się tak, jak obiekty. Dane i funkcje 
wewnętrzne dostępne są z wykorzystaniem operatora dostępu do klasy - 
kropki ( . ).

Puste (null) wskaźniki i puste (null) referencje.

Kiedy wskaźnik jest niezainicjowany lub ewentualnie skasowany za pomocą 
delete, to powinna być my przypisana wartość null (0). 

Referencja  nie  może  być  pusta  (  null  ).  Program,  w  którym  znajdują  się 
referencje  do  obiektów  null  jest  błędny  i  jego  działanie  jest 
nieprzewidywalne.  Może  on  działać  pozornie  prawidłowo,  lecz  w  pewnym 
momencie może np. niespodziewanie skasować wszystkie zbiory na dysku.

Ta reguła nie obowiązuje w przypadku referencji !

Większość  kompilatorów  honoruje  puste  obiekty.  Problemy  pojawiają  się 
jedynie przy próbie wykonania operacji na takich obiektach. Pamiętajcie, że w 
takiej sytuacji, próba przeniesienia programu pod inny kompilator lub na inną 
maszynę  może  skończyć  się  niepowodzeniem  jeśli  to  inne  środowisko  nie 
zezwala na istnienie pustych ( null ) obiektów.

Przekazywanie argumentów funkcji przez 
referencje.

Powiedzieliśmy sobie, że funkcje mają dwa ograniczenia: 



  

argumenty są przekazywane przez wartość 

  funkcja może zwrócić tylko jedną  wartość.

Przekazywanie  argumentów  przez  referencje  pozwala  na  obejście  obydwu 
tych ograniczeń. 
W C++, przekazywanie przez referencje, może być przeprowadzone 
na dwa sposoby: 

♦

  

wykorzystaniem wskaźników, 

♦  referencji. 

Wewnątrz funkcji nie jest tworzona kopia przekazywanego obiektu. Do 
funkcji przekazywany jest oryginalny obiekt.
Przekazywanie obiektów przez referencje pozwala funkcji na 
wykonywanie modyfikacji w tych obiektach.

Każde rozwiązanie ma własną składnię jednak efekt końcowy jest taki 
sam. 

Przykład:

Problem  polega  tutaj  na 
tym, że zarówno x jak i y są 
przekazywane 

przez 

wartość.  Oznacza  to,  że  są 
tworzone lokalne kopie tych 
zmiennych 

i 

wszystkie 

operacje są wykonywane na 
kopiach,  nie    powodując 
żadnych  zmian  zmiennych 
oryginalnych. 

To, 

czego 

tutaj 

potrzeba, 

to 

przekazywanie  x  i  y  przez 
referencje.

Można ten problem rozwiązać na dwa sposoby: 
1. można zamienić parametry funkcji Zamien() na wskaźniki do oryginalnych 

wartości 

2. przekazywać referencje.

Ad.1. Implementacja funkcji Zamien () z wykorzystaniem 
wskaźników

Kiedy  przekazuje  się  wskaźnik,  to  faktycznie  przekazuje  się  adres  zmiennej, 
co  pozwala  funkcji  na  manipulowanie  jej  wartością.  Żeby  funkcja  Zamien  () 
mogła  zamieniać  dwie  zmienne  wartościami,  to  trzeba  ją  zadeklarować  tak, 
aby  jako  parametry  pobierała  dwa  wskaźniki  do  zmiennych  typu  int.  Taki 
zabieg  pozwoli  funkcji  na  pośrednie  odwołanie  się  do  tych  zmiennych  i 
zamianę ich wartości. 

Funkcja  Zamien  ()  jest  wywoływana  z 
parametrami  którymi  są  adresy  zmiennych, 
które chcemy zamienić. 

Zmienna lokalna nTemp nie musi być wskaźnikiem ponieważ 
jej zadaniem jest przechowanie wartości *pX

Ad.2. Implementacja funkcji Zamien () z wykorzystaniem 
referencji

Poprzedni  program  działa,  lecz  funkcja  Zamien  ()  jest  raczej  nieporęczna  z 

następujących powodów:

1. wielokrotne  pośrednie  odwoływanie  się  do  zmiennych  wskazywanych 

powoduje, że takie rozwiązanie jest podatne na błędy

2. konieczność  przekazywania  adresów  zmiennych  powoduje  "ujawnienie" 

wewnętrznych mechanizmów funkcji Zamien () .

Zamierzeniem C++ jest oddzielenie użytkownika funkcji od jej wewnętrznych 
mechanizmów  i  implementacji.  Przekazywanie  wskaźników  przenosi  część 
ciężaru wykonania funkcji na funkcję wywołującą (na użytkownika). 

Tym razem, bezpośrednio przekazywane są do 
funkcji zmienne, a nie ich adresy. 

W  funkcji  Zamien  ()  zmienne  x  i  y  są 
identyfikowane  przez  referencje.  Można  tak 
napisać,  gdyż  jak  już  wcześniej  wielokrotnie 
mówiłem,  stanowią  one  odnośniki,  synonimy 
oryginalnych zmiennych.

Interpretacja nagłówków i prototypów funkcji

Poprzez  analizę  zadeklarowanych  parametrów  w  prototypie,  który  zazwyczaj 
znajduje  się  w  specjalnym  pliku  nagłówkowym  (*.hpp  ,  *h  )  wraz  z  innymi 
prototypami,  programista  dowiaduje  się,  że  parametry  przekazywane  do 
funkcji  zamień  są  przekazywane  przez  referencje,  co  w  przypadku  funkcji 
Zamien () oznacza, że zostaną one prawidłowo zamienione.

Skąd jednak funkcja wywołująca wie, czy wartości są przekazywane 
przez referencje czy przez wartość?

Zwracanie wielu wartości 

Jak już mówiliśmy, każda funkcja, normalnie może zwrócić tylko jedną 
wartość. 

Jedna z możliwości polega na przekazaniu do funkcji przez referencje dwóch 
roboczych  obiektów.  Funkcja  może  nadać  im  wymagane  wartości. 
Przekazanie  przez  referencje  gwarantuje,  ze  przypisanie  wartości  nastąpi  do 
obiektów  oryginalnych,  co  umożliwi  ich  odczytanie.  W  efekcie  uzyskujemy 
funkcję, która zwraca dwie wartości. 

Co jednak zrobić, gdy chcemy zwrócić z funkcji dwie wartości? 

Takie  rozwiązanie  pozwala  na  ominięcie  normalnej  wartości  zwracanej  przez 
funkcję,  którą  można  w  tym  momencie  wykorzystać  np.  do  zwracania  kodu 
błędu.

Zmienna 

nLiczba, 

i 

adresy 

dwóch 

pozostałych  zmiennych,  są  przekazywane 
do funkcji Potegi () .

Dodatkowe  wartości,  kwadratu  i  sześcianu  podanej 
liczby, 

nie 

są 

zwracane 

z 

wykorzystaniem 

mechanizmów  oferowanych  przez  return.  Zmieniona 
zostaje  zawartość  pamięci  wskazywanej  przez 
przekazane  do  funkcji  wskaźniki,  co  powoduje 
modyfikację 

wartości 

zmiennych 

w 

funkcji 

wywołującej, do których te adresy nalezą.

Ten  program  można  udoskonalić,  np.  poprzez  wprowadzenie  deklaracji  dla 
wartości błędu i sukcesu:

enum WARTOSC_BLEDU {SUKCES, PORAZKA};

Teraz, zamiast zwracać niewiele mówiące wartości 0 lub 1, możemy zwracać 
SUKCES albo PORAZKA.

Zwracanie wartości przez referencje

Efektywność przekazywania przez referencje

Za  każdym  razem,  kiedy  przekazuje  się  przez  wartość  obiekt  do  funkcji, 
tworzona  jest  kopia  obiektu.  Również,  kiedy  zwraca  się  obiekt  z  funkcji  (za 
pomocą  return)  jest  tworzona  kopia.  W  przypadku  dużych,  stworzonych 
przez  użytkownika  obiektów,  koszt  tworzenia  kopii  jest  znaczący. 
Wykorzystywane jest więcej pamięci niż faktycznie potrzeba i program działa 
wolniej.
Rozmiar  obiektu  stworzonego  przez  użytkownika  na  stosie  jest  równy  sumie 
wielkości jego zmiennych wewnętrznych. Każda zmienna wewnętrzna również 
może być kolejnym obiektem stworzonym przez użytkownika. Przekazywanie 
tak złożonego i dużego obiektu i kopiowanie go na stos może bardzo obciążać 
system  i  spowalniać  działanie  programu,  przy  jednoczesnym  wzroście 
zapotrzebowania na pamięć.
Występuje tutaj jeszcze jeden, dodatkowy koszt. 

Każda kopia obiektu jest wykonywana za pomocą specjalnego konstruktora, a 
mianowicie  konstruktora  kopiującego.  Kiedy  taki  chwilowy  obiekt  jest 
kasowany (np. w momencie wyjścia z funkcji) to zostaje wywołany destruktor 
klasy,  do  której  ten  obiekt  należy.  Jeśli  obiekt  jest  wartością  zwracaną,  to 
również musi być najpierw stworzony, a następnie skasowany.
W  przypadku  dużych  obiektów,  zarówno  konstruktor  jak  i  destruktor, 
pochłaniają dużo czasu procesora i pamięci. 

Przykład:

Rzeczywisty  obiekt  byłby  dużo  większy, 
ale  ten  przykład  dostatecznie  dobrze 
pokazuje  jak  często  są  wywoływane 
konstruktory  i  destruktory  w  trakcie 
normalnej pracy programu.

Ponieważ  Funkcja1()  pobiera  obiekt  klasy  ZwyklyKot  przez  wartość,  dlatego 
na stosie musi zostać stworzona kopia obiektu. Zostaje wywołany konstruktor 
kopiujący.  Wartość  zwracana  z  Funkcja1()  nie  jest  przypisywana  do  żadnego 
obiektu,  zatem  obiekt  tworzony  w  momencie  wyjścia  z  funkcji  jest 
natychmiast  wyrzucany  z  pamięci  poprzez  wywołanie  destruktora.  Ponieważ 
Funkcja1()  się  skończyła,  dlatego  lokalna  kopia  obiektu  również  ulega 
skasowaniu poprzez wywołanie destruktora.

W funkcji Funkcja2 () parametr jest przekazywany przez wskaźnik. Jak widać 
na  wydruku,  nie  jest  tworzona  żadna  kopia  obiektu.  Funkcja2  ()  wypisuje 
komunikat  i  zwraca  wskaźnik  do  obiektu  klasy  ZwyklyKot.  Znowu  nie  jest 
wywoływany ani konstruktor ani destruktor klasy.

Jak  widać,  wywołanie  funkcji  Funkcja1  (),  ze  względu  na  przekazywanie 
parametrów przez wartość, spowodowało dwukrotne wywołanie konstruktora 
i  destruktora,  w  przeciwieństwie  do  funkcji  Funkcja2  (),  której  wywołanie 
odbywało się bez uczestnictwa konstruktora i destruktora klasy.

Przekazywanie stałych (const) wskaźników

Mimo  że  przekazywanie  wskaźników  jest  bardzo  efektywne,  to  jest  ono 
jednocześnie  bardzo  niebezpieczne.  Funkcja2  ()  (z  ostatniego  programu)  nie 
ma prawa zmieniać przekazanego obiektu, który aktualnie jest przekazywany 
w  formie  adresu.  Takie  rozwiązanie  niesie  ze  sobą  niebezpieczeństwo 
nieświadomej  (spowodowane  błędem  programisty)  zmiany  oryginalnego 
obiektu,  w  przeciwieństwie  do  przekazywania  przez  wartość,  gdzie  obiekt 
oryginalny jest "bezpieczny".
Przekazywanie przez wartość, to jakby dawanie do muzeum fotografii dzieła 
sztuki,  a  nie  oryginalnego  dzieła.  Jeśli  ktoś  zniszczy  kopie  to  oryginał  i  tak 
zostanie  nienaruszony.  Przekazywanie  przez  referencje  można  porównać  do 
wysyłania do muzeum swojego, domowego adresu i zaproszenia do oglądania 
własnych zasobów.

Rozwiązaniem  tego  problemu  jest  przekazywanie  stałych  (const) 
wskaźników. Takie posunięcie zabezpiecza przed użyciem metod, które nie są 
zadeklarowane jako const, przez co mogą zmieniać obiekt. 

Przykład:

W  tym  przykładzie  konstruktor  kopiujący  nie  jest  nigdy  wywoływany, 
ponieważ  obiekt  jest  przekazywany  do  funkcji  przez  wskaźnik  i  nie  jest 
wykonywana jego kopia.

Parametr  i  wartość  zwracana  zostały  zadeklarowane  tak,  aby  funkcja 
pobierała  stały  wskaźnik  (const)  do    stałego  (czyli  również  const)  obiektu  i 
żeby zwracała również stały wskaźnik do  stałego obiektu. Ponieważ zarówno 
parametr jak i wartość zwracana są przekazywane przez wskaźnik, to nie jest 
tworzona  żadna  kopia  obiektu  i,  co  się  z  tym  ściśle  wiąże,  nie  jest 
wywoływany konstruktor kopiujący. Wskaźnik występujący w funkcji Funkcja2 
()  jest  stały  i  nie  mamy  możliwości  wykorzystania  go  do  wywołania  funkcji 
UstawWiek () (zadeklarowanej bez użycia słowa kluczowego const). 

Gdybyśmy usunęli komentarz to kompilator 
zgłosiłby błąd.

Kiedy wykorzystywać referencje, a kiedy 
wskaźniki?

Programiści  C++  preferują  referencje.  Są  łatwiejsze,  bardziej  eleganckie  i 
pozwalają na lepsze ukrycie szczegółów implementacyjnych.

  Jednak  raz  stworzona  referencja  nie  może  być  przypisana  do  innego 
obiektu. 

  Jeżeli  chce  się  mieć  wskazanie  najpierw  na  jeden  obiekt,  a  następnie  na 
drugi, trzeba wykorzystać wskaźniki. 

  Referencje  nie  mogą  być  puste  (null)  i  jeżeli  jest  możliwość,  że  obiekt 
będzie  pusty  to  wykorzystanie  referencji  w  takim  przypadku  jest  błędem, 
trzeba użyć wskaźnika.

Inny problem pojawia się przy wykorzystaniu operatora  new. Jeżeli  new nie 
jest  w  stanie  zarezerwować  pamięci  na  stercie  to  zwraca  pusty  (null) 
wskaźnik.  Referencja  nie  może  być  pusta  dlatego  nie  wolno  inicjalizować 
referencji  do  zarezerwowanej  pamięci  zanim  nie  upewnimy  się,  że  wskaźnik 
nie jest pusty. 

Przykład:

Oto przykładowa sekwencja instrukcji, która prawidłowo obsługuje tworzenie 
referencji do pamięci na stercie:

int *pInt = new int; 
if (pInt != NULL)
{
  int &rInt = *pInt;
}

Nie zwracaj referencji do obiektów lokalnych 

Często,  kiedy  programista  pozna  referencje,  to  wykorzystuje  je,  gdzie  się 
tylko  da.  Można  wtedy,  mówiąc  prostym  językiem,  "przedobrzyć". 
Pamiętajcie,  że  referencja  jest  zawsze  odnośnikiem  do  innego,  istniejącego 
obiektu. Jeżeli przekazuje się referencje do lub z funkcji zawsze zadajcie sobie 
pytanie,  czy  obiekt,  do  którego  się  dana  referencja  odnosi,  będzie  nadal 
istniał.

Przykład:

Ten  program  nie  skompiluje 
się  pod  kompilatorami  firmy 
Borland.  Kompilatory  firmy 
Microsoft skompilują ten kod, 
ale trzeba zaznaczyć, że jest 
to błędne podejście.

Funkcja 

deklaruje 

lokalny 

obiekt 

klasy 

ZwyklyKot 

i 

inicjalizuje  jego  wagę  i  wiek. 
Następnie  zwraca  referencje  to 
tego, 

lokalnego 

obiektu. 

Niektóre kompilatory wychwycą 
ten  oczywisty  błąd  i  nie 
pozwolą 

na 

uruchomienie 

programu.  Inne  skompilują  to 
bez 

zastrzeżeń, 

ale 

efekt 

działania takiego programu jest 
nieprzewidywalny.
Kiedy 

Funkcja 

ulegnie 

zakończeniu,  to  lokalny  obiekt, 
oFilemon, zostanie wyrzucony z 
pamięci. Referencja zwrócona z 
funkcji 

odnosiłaby 

się 

do 

nieistniejącego  obiektu  co  jest 
oczywiście 

sprzeczne 

z 

definicją referencji. 

Zwracanie referencji do obiektu na stercie

Można  rozwiązać  stworzony  w  poprzednim  programie  problem  poprzez 
zmianę  Funkcja  tak,  aby  tworzyła  obiekt  klasy  ZwyklyKot  na  stercie.  Dzięki 
temu, po zakończeniu funkcji, taki obiekt będzie nadal istniał.
Pojawia  się  tutaj  kolejny  problem:  Co  zrobić  z  pamięcią  zarezerwowaną  dla 
obiektu oFilemon po zakończeniu wszystkich operacji. 

Ten program się kompiluje i pozornie działa. Jednak jest to 
klasyczna, programistyczna bomba zegarowa z opóźnionym 
zapłonem!

Funkcja  Funkcja  ()  nie  zwraca  już  referencji  do 
lokalnego 

obiektu. 

Teraz 

pamięć 

jest 

rezerwowana  na  stercie  i  przypisywana  do 
wskaźnika. 

Adres 

przechowywany 

przez 

wskaźnik  jest  wypisywany,  a  następnie  są 
zwracane  referencje  do  obiektu  przez  niego 
wskazywanego.

Wartość  zwracana  z  funkcji  jest  przypisywana 
do  referencji  obiektu  klasy  ZwyklyKot.  Obiekt 
ten  wykorzystujemy  do  odczytania  wieku  kota. 
Dowodem na to, że referencja zadeklarowana w 
main  ()  odnosi  się  do  obiektu  stworzonego  na 
stercie jest odczytanie adresu tej referencji. Jest 
on taki sam jak adres wypisany w Funkcja().

 

Ale 

jak 

teraz 

zwolnić 

zarezerwowaną  pamięć?  Nie 
można  skasować  referencji  za 
pomocą 

delete. 

Jedyne 

nasuwające  się  rozwiązanie 
polega 

na 

zadeklarowaniu 

kolejnego 

wskaźnika 

i 

zainicjowaniu 

go 

adresem 

odczytanym  z  rKot.  W  ten 
sposób 

możemy 

zwolnić 

zarezerwowaną 

pamięć. 

Jednak i tu pojawia się kolejny 
problem.  Do  jakiego  obiektu 
odnosi  się  rKot?  Jak  już 
mówiliśmy,  referencja  musi 
odnosić  się  do  istniejącego 
obiektu.  Jeśli  jest  inaczej 
(obiekt  jest  null)  to  program 
jest nieprawidłowo napisany.

Istnieją trzy rozwiązania tego problemu: 

  Pierwsze  polega  na  zadeklarowaniu  obiektu  klasy  ZwyklyKot  i 
zwrócenie go z funkcji Funkcja () przez wartość.

 Drugie idzie dalej i polega na zadeklarowaniu w funkcji Funkcja () 
obiektu  klasy    ZwyklyKot  na  stercie  i  zwróceniu  wskaźnika  do  tego 
obiektu.  Funkcja  wywołująca  będzie  wtedy  miała  możliwość 
skasowania wskaźnika.

 Trzecie, najbardziej eleganckie, polega na zadeklarowaniu obiektu 
w  funkcji  wywołującej  i  przekazaniu  go  do  funkcji  Funkcja  ()  przez 
referencje.