Wstecz: 11.1 Wstęp W górę: 11. Funkcje Dalej: 11.3 Wywołanie funkcji

---

11.2 Deklaracje i definicje funkcji

Definicja lub deklaracja dostarcza kompilatorowi informacji o funkcji: jaki jest jej typ zwracany, jaka jest liczba parametrów, jaki jest typ parametrów itd. W ten sposób, za każdym razem, gdy w dalszej części tekstu programu pojawia się użycie tej funkcji, kompilator może sprawdzić

• o którą z funkcji o tej samej nazwie chodzi (może być wiele funkcji o tej samej nazwie);
• czy wywołanie funkcji jest prawidłowe; czy na przykład ilość i typ argumentów odpowiada ilości i typom parametrów, czy typ wartości zwracanej przez funkcje jest w danym miejscu programu akceptowalny, itd. Jest to konieczne, na przykład, aby zdecydować, czy będa potrzebne konwersje argumentów lub wartości zwracanej.

Dlaczego definicja lub deklaracja, co to w ogóle jest deklaracja funkcji i do czego się przydaje?

Wyobraźmy sobie następującą sytuację: definiujemy kolejno dwie funkcje, fun1 i  fun2. Funkcja fun1 wywołuje w swej treści funkcję fun2 i odwrotnie, funkcja fun2 wywołuje w swej treści funkcję fun1:

      1.      void fun1(int k) {
      2.          // ...
      3.          fun2(k)
      4.          // ...
      5.      }
      6.  
      7.      void fun2(int m) {
      8.          // ...
      9.          fun1(m)
     10.          // ...
     11.      }

Na szczęście jest wyjście z tej sytuacji. Kompilatorowi nie jest potrzebna definicja funkcji, to znaczy nie musi wiedzieć, co funkcja robi: musi tylko wiedzieć, ile i jakie ma parametry i jaki jest jej typ zwracany. Do tego wystarczy prototyp funkcji podany w deklaracji. Deklaracja ma formę nagłówka funkcji, po którym następuje średnik zamiast ciała (treści) funkcji. Na przykład poprawnymi deklaracjami funkcji są

       string& fun1(char* c1, char* c2, bool b);
       void    fun2(int k, double d[]);
       Klasa*  fun3(Klasa* k1, Klasa* k2);

      1.      void fun2(int);
      2.  
      3.      void fun1(int k) {
      4.          // ...
      5.          fun2(k)
      6.          // ...
      7.      }
      8.  
      9.      void fun2(int m) {
     10.          // ...
     11.          fun1(m)
     12.          // ...
     13.      }

Na przykład, podane poprzednio trzy deklaracje moglibyśmy równie dobrze zapisać tak:

       string& fun1(char*, char*, bool);
       void    fun2(int, double[]);
       Klasa*  fun3(Klasa*, Klasa*);

Ponieważ na razie nasze programy i tak mieszczą się w jednym pliku, szczegóły odłożymy do rozdziału o modułach programu .

Oczywiście wszystkie deklaracje, jeśli jest ich kilka, muszą być ze sobą zgodne, czyli definiować ten sam prototyp. Definicja również musi być zgodna z deklaracjami — to znaczy nagłówek funkcji musi być zgodny z prototypem. Jak mówiliśmy, ta zgodność nie musi dotyczyć nazw parametrów formalnych funkcji, które w ogóle nie mają znaczenia w deklaracjach i do prototypu nie należą.

Nagłówek określa prototyp, czyli zewnętrzne własności funkcji. W najprostszej postaci wygląda on tak:

        Typ Nazwa ListaParam

Typ wartości zwracanej.

Musi to być typ wbudowany (jak int, char, ...), typ zdefiniowany przez użytkownika, typ pochodny (int*, Osoba& itd.), albo wreszcie typ void. Jeśli typem zwracanym nie jest void, to funcję nazywamy funkcją rezultatową. Jeśli jest to void, to funkcja w ogóle nie zwraca żadnej wartości; taką funkcję nazywamy funkcją bezrezultatową. Typ wartości zwracanej zwany jest też po prostu typem funkcji.
Typem funkcji nie może być typ tablicowy i nie może nim być typ funkcyjny; może to natomiast być typ wskaźnikowy — w szczególności wskaźnik może wskazywać na tablicę lub funkcję — lub typ referencyjny.

Nazwa.

Nazwa może być dowolna, byle nie kolidowała z którymś ze słów kluczowych, składała się tylko z liter, cyfr i znaków podkreślenia. Nie może jednak zaczynać się od cyfry.

Lista parametrów formalnych.

Lista ta jest ujętą w okrągłe nawiasy listą oddzielonych przecinkami deklaracji pojedynczych parametrów funkcji w postaci (typ1 nazwa1, typ2 nazwa2). Nie wolno stosować deklaracji zbiorczych: (typ nazwa1, nazwa2) — nie byłoby wtedy wiadomo, czy nazwa2 jest drugim parametrem typu typ, czy typem następnego, anonimowego (co jest dopuszczalne), parametru. Nazwy wszystkich parametrów muszą być różne.
Nazwy parametru można w ogóle nie podawać w deklaracjach; w definicjach również można nazwę pominąć, jeśli z argumentu wywołania skojarzonego z tym parametrem funkcja w ogóle nie korzysta, jak to często bywa w czasie tworzenia funkcji w jej wstępnych wersjach.
Lista parametrów może być pusta; obejmujących ją nawiasów pominąć jednak nie można. Jeśli lista parametrów jest pusta, to można zaznaczyć to przez wpisanie wewnątrz nawiasów słowa kluczowego void. Nie jest to jednak konieczne.
Pamiętajmy też, że poprzedzenie nazwy typu słowem kluczowym const odpowiada zmianie typu: typ int* i typ const int* to dwa różne typy. Jeśli typem parametru jest na przykład const int*, to kompilator nie zgodzi się na zmianę wartości zmiennej wskazywanej poprzez nazwę wskaźnika przekazanego jako argument (co funkcja normalnie może zrobić; przekazana jej została, co prawda, kopia adresu, ale sam adres odpowiada oryginalnej zmiennej z funkcji wywołującej).

Część nagłówka funkcji składająca się z nazwy funkcji i listy typów jej parametrów (bez nazw tych parametrów) nazywa się czasem jej sygnaturą. Typu zwracanego zwykle w sygnaturze nie uwzględnia się. Tak więc na przykład sygnaturą funkcji o prototypie

       double fun(double x, char* nap);

       fun(double, char*)

Definicja funkcji składa się z takiego samego nagłówka, tyle że teraz nie kończymy go średnikiem, tylko umieszczamy zaraz za nim, ujętą w nawiasy klamrowe, treść (ciało) funkcji, czyli sekwencję instrukcji do wykonania. Jeśli w ciele funkcji chcemy korzystać z argumentu przekazanego poprzez parametr funkcji, to oczywiście ten parametr musi mieć nazwę (którą w deklaracji mogliśmy pominąć). W programie może występować tylko jedna definicja funkcji, choć wiele deklaracji. Wyjątkiem są funkcje rozwijane, które mogą być definiowane wielokrotnie (patrz podrozdział o funkcjach rozwijanych ).

Ciało funkcji może być traktowane jak wnętrze instrukcji grupującej (złożonej). Do zakresu tej instrukcji grupującej należą również deklaracje zmiennych lokalnych opisane przez specyfikacje parametrów funkcji. Zmienne definiowane w ciele funkcji będą w czasie jej wykonywania lokalne — po wykonaniu funkcji są one usuwane. Zmiennymi lokalnymi są również zmienne wyspecyfikowane jako parametry formalne funkcji: będą one zainicjowane wartościami argumentów wywołania. Po zakończeniu wykonywania funkcji zmienne lokalne (z wyjątkiem tych zadeklarowanych jako static) będą usunięte.

Zmienne lokalne funkcji (w tym te deklarowane przez specyfikacje parametrów w nagłówku funkcji) w żaden sposób nie kolidują ze zmiennymi o tej samej nazwie w innych funkcjach. Mogą natomiast przesłaniać nazwy zmiennych globalnych, zadeklarowanych poza funkcjami i klasami. Jeśli tak jest, to niekwalifikowana nazwa występująca w ciele funkcji odnosi się zawsze do zmiennej lokalnej, natomiast dostęp do zmiennej globalnej o tej nazwie mamy poprzez operator zasięgu — czterokropek (patrz rozdział o zasięgu i widzialności zmiennych).

Nie wolno definicji funkcji zagnieżdżać, to znaczy nie można w ciele jednej funkcji definiować innej funkcji (co jest dozwolone w innych językach, jak Pascal czy Fortran 90/95). W nowym standardzie C++11 można jednak wewnątrz funkcji definiować tak zwane funkcje lambda, o których za chwilę.

Definicja (i deklaracja) funkcji może w nowym standardzie C++11 mieć inną, alternatywną, postać, a mianowicie

       auto f_nazwa(parametry) -> typ_zwracany { ciało }

      1.  #include <iostream>
      2.  using namespace std;
      3.  
      4.  auto D(int a, double b) -> decltype(a*b);   ➊
      5.  
      6.  double A(int a, double b) {                 ➋
      7.      return a*b;
      8.  }
      9.  
     10.  auto B(int a, double b) -> double {         ➌
     11.      return a*b;
     12.  }
     13.  
     14.  auto C(int a, double b) -> decltype(a*b) {  ➍
     15.      return a*b;
     16.  }
     17.  
     18.  double D(int a, double b) {                 ➎
     19.      return a*b;
     20.  }
     21.  
     22.  int main() {
     23.      cout << A(4,2.5) << " " << B(4,2.5) << " "
     24.           << C(4,2.5) << " " << D(4,2.5) << endl;
     25.  }

Definiujemy tu szereg funkcji (A, B, C, D), które są właściwie identyczne — wszystkie po prostu zwracają iloczyn swoich argumentów. Definicja funkcji A (➋) jest „normalna”. W linii ➌ użyliśmy natomiast nowej składni (auto przed nazwą, typ za listą parametrów i poprzedzony strzałką). W definicji funkcji C (➍) zamiast podawać jawnie typ „poprosiliśmy” kompilator, aby sam określił, jaki powinien być typ iloczynu argumentów (oczywiście będzie to double). Widać też, że nowej składni możemy też użyć do deklarowania funkcji (➊) — sama definicja (➎) może być zapisana zarówno w nowej jak i starej składni (wtedy oczywiście typ zwracany musi się zgadzać z tym wydedukowanym przez kompilator z deklaracji).

Forma użyta w tym przykładzie w definicji funkcji C (➍) okaże się niesłychanie użyteczna przy definiowaniu szablonów funkcji.

Powiedzmy na koniec, że deklaracje i definicje funkcji nie są instrukcjami wykonywalnymi (jak na przykład w Pythonie). Zatem kolejność, w jakiej je piszemy, nie ma znaczenia, dopóki spełniony jest warunek, że co najmniej jedna deklaracja poprzedza leksykalnie instrukcje, w których funkcja jest wykorzystywana.

---

Wstecz: 11.1 Wstęp W górę: 11. Funkcje Dalej: 11.3 Wywołanie funkcji