Funkcje w C++: deklaracja, definicja i wywołanie (z przykładami)

Po co istnieją funkcje

Funkcja to nazwany blok kodu, który możesz uruchomić na żądanie, wywołując go. Zamiast powtarzać tę samą logikę w kilku miejscach, piszesz ją raz, nadajesz jej nazwę i wywołujesz tę nazwę wszędzie, gdzie jej potrzebujesz. Dzięki temu programy są krótsze, czytelniejsze i łatwiejsze do poprawiania: zmieniasz logikę w jednym miejscu, a każde wywołanie dostaje aktualizację.

Przez cały czas wywołujesz już jedną funkcję: main. To punkt wejścia, od którego zaczyna się każdy program w C++. Teraz napiszesz własne. Pętle, które pojawiły się wcześniej, jak for po zakresie, często żyją wewnątrz funkcji, dzięki czemu cały fragment logiki można ponownie wykorzystać po nazwie.

Budowa funkcji

Każda funkcja ma cztery części: typ zwracany, nazwę, listę parametrów w nawiasach i ciało w klamrach.

int add(int a, int b) {   // typ zwracany | nazwa | parametry
    return a + b;         // ciało
}

• int to typ zwracany: rodzaj wartości, którą funkcja oddaje.
• add to nazwa, której używasz do wywołania.
• (int a, int b) to parametry: dane wejściowe, które dostarcza wywołujący.
• Klamry zawierają ciało, czyli kod wykonywany przy wywołaniu.

Oto ta funkcja w kompletnym programie. Zdefiniowanie jej nad main sprawia, że main ją widzi w chwili wywołania.

#include <iostream>
using namespace std;

int add(int a, int b) {
    return a + b;
}

int main() {
    int sum = add(2, 3);
    cout << "2 + 3 = " << sum << endl;
    cout << "10 + 7 = " << add(10, 7) << endl;
    return 0;
}

Wywołanie add(2, 3) uruchamia funkcję z a = 2 i b = 3, a całe wyrażenie staje się zwróconą wartością. Możesz ją zapisać w zmiennej albo użyć bezpośrednio w innym wyrażeniu, jak w drugiej linii z cout.

Zwracanie wartości

Instrukcja return robi dwie rzeczy: oddaje wartość wywołującemu i natychmiast kończy funkcję. Kod po wykonanym return się nie wykonuje: sterowanie wraca prosto do miejsca, w którym wywołano funkcję.

#include <iostream>
using namespace std;

int max2(int a, int b) {
    if (a > b) {
        return a;   // kończy tutaj, jeśli a jest większe
    }
    return b;       // osiągane tylko, gdy a <= b
}

int main() {
    cout << "max(4, 9) = " << max2(4, 9) << endl;
    cout << "max(8, 3) = " << max2(8, 3) << endl;
    return 0;
}

Typ zwracanej wartości musi pasować do zadeklarowanego typu zwracanego (albo dać się na niego skonwertować). Funkcja zadeklarowana jako int powinna zwracać int; niezwrócenie niczego albo dotarcie do końca bez return to błąd w każdej funkcji innej niż void.

Funkcje void

Nie każda funkcja wytwarza wartość. Gdy funkcja po prostu coś robi (wypisuje dane, aktualizuje stan), jej typ zwracany to void. Funkcja void może użyć gołego return;, aby wyjść wcześniej, albo po prostu dojść do zamykającej klamry.

#include <iostream>
#include <string>
using namespace std;

void greet(string name) {
    if (name.empty()) {
        cout << "Hello, stranger!" << endl;
        return;   // wyjdź wcześniej: nie ma nic więcej do zrobienia
    }
    cout << "Hello, " << name << "!" << endl;
}

int main() {
    greet("Ada");
    greet("");
    return 0;
}

Próba użycia wyniku funkcji void, czyli int x = greet("Ada");, to błąd kompilacji, bo nie ma wartości do przypisania. Częsta pomyłka to pisanie return someValue; wewnątrz funkcji void; to również kompilator odrzuci.

Deklaracje a definicje

C++ czyta plik od góry do dołu, więc domyślnie funkcja musi pojawić się przed kodem, który ją wywołuje. Gdy taka kolejność jest niewygodna, dzielisz funkcję na deklarację (zwaną też prototypem) i definicję.

Deklaracja podaje sygnaturę funkcji i kończy się średnikiem, bez ciała. Obiecuje kompilatorowi: "ta funkcja istnieje, a tak się ją wywołuje". Pełna definicja może się wtedy pojawić później, nawet po main.

#include <iostream>
using namespace std;

int square(int n);   // deklaracja (prototyp): zwróć uwagę na średnik

int main() {
    cout << "square(5) = " << square(5) << endl;
    return 0;
}

int square(int n) {  // definicja: właściwe ciało
    return n * n;
}

Bez prototypu w linii 4 kompilator natrafiłby na square(5) wewnątrz main, zanim w ogóle zobaczyłby square, i kompilacja by się nie powiodła. Prototypy to także sposób, w jaki pliki nagłówkowe pozwalają wielu plikom źródłowym współdzielić te same funkcje. Zauważ, że nazwy parametrów w deklaracji są opcjonalne: int square(int); działa równie dobrze, bo dla kompilatora liczą się tylko typy.

Częste błędy

Kilka pułapek łapie początkujących raz za razem:

• Wywołanie przed deklaracją. Jeśli dostajesz błąd "add was not declared in this scope", funkcja jest zdefiniowana poniżej pierwszego wywołania i nie ma prototypu. Przenieś definicję wyżej albo dodaj prototyp.
• Zapomniany return. Dotarcie do końca funkcji innej niż void bez return to niezdefiniowane zachowanie: wywołujący dostaje śmieci. Kompiluj z włączonymi ostrzeżeniami (-Wall), a kompilator to wychwyci.
• Definicja a wywołanie. Definicja ma ciało w klamrach i nie ma końcowego średnika. Deklaracja ma średnik i nie ma ciała. Pomylenie ich, na przykład postawienie średnika zaraz po liście parametrów funkcji, którą chcesz zdefiniować, daje mylące błędy.
• Ignorowanie wartości zwracanej. add(2, 3); w osobnej linii się skompiluje, ale obliczona suma zostanie po cichu wyrzucona. Upewnij się, że naprawdę wykorzystujesz to, co zwraca funkcja.

// Wygląda jak definicja, ale zbędny ; zamienia to w
// deklarację, po której zostaje osierocony blok: częsta literówka:
int triple(int n);   // <- ten ; kończy instrukcję
{
    return n * 3;    // n jest tu niezdefiniowane; ten blok jest teraz osierocony
}

Dalej: parametry funkcji

Widać już, że funkcje przyjmują dane przez listę parametrów, ale to dopiero początek. Następna strona omawia parametry funkcji: przekazywanie przez wartość i przez referencję, argumenty domyślne, parametry const i to, jak ten wybór decyduje, czy twoja funkcja może zmienić dane wywołującego.