Fonksiyonlar

Oyununda iki karakter arasındaki mesafeyi on farklı yerde hesapladığını ve her seferinde aynı üç satırı kopyaladığını düşün. Formülde bir hata bulursan onu on yerde düzeltmen gerekecek! Fonksiyonlar bu sorunu çözer: kodu bir kez yazar, ona bir ad verir ve gerektiği kadar çağırırsın. Bir fonksiyonu zaten tanıyorsun: main.

Fonksiyon tanımlamak ve çağırmak

C++'ta bir fonksiyon tanımı dört bölümden oluşur: dönüş türü, ad, parantez içindeki parametreler ve süslü parantez içindeki gövde. return, sonucu fonksiyonun çağrıldığı yere geri gönderir. Hiçbir şey döndürmeyen fonksiyonun türü void'dir.

#include <iostream>
#include <string>

int square(int x) {
    return x * x;
}

void greet(std::string name) {
    std::cout << "Hello, " << name << "!\n";
}

int main() {
    greet("Leyla");
    int s = square(7);
    std::cout << "7 squared is " << s << '\n';
    std::cout << square(3) + square(4) << '\n';
    return 0;
}

Hello, Leyla!
7 squared is 49
25

Derleyici dosyayı yukarıdan aşağıya okur; bu yüzden bir fonksiyon çağrılmadan önce en azından bildirilmiş olmalıdır. Fonksiyonu main'den sonra yazmak istiyorsan en üste onun prototipini, yani gövdesiz başlığını yaz:

#include <iostream>

int cube(int x);   // declaration (prototype)

int main() {
    std::cout << cube(3) << '\n';
    return 0;
}

int cube(int x) {  // definition
    return x * x * x;
}

27

Fonksiyon aşırı yükleme

C++'ta parametrelerinin sayısı veya türleri farklı olduğu sürece aynı adlı birden fazla fonksiyon olabilir. Buna aşırı yükleme (overloading) denir. Derleyici, çağrıdaki argümanlara bakarak uygun sürümü kendisi seçer. Örnekteki a > b ? a : b ifadesi üçlü operatördür: “koşul doğruysa a, değilse b” anlamına gelir.

#include <iostream>

int maxOf(int a, int b) {
    return a > b ? a : b;
}

double maxOf(double a, double b) {
    return a > b ? a : b;
}

int maxOf(int a, int b, int c) {
    return maxOf(maxOf(a, b), c);
}

int main() {
    std::cout << maxOf(3, 8) << '\n';
    std::cout << maxOf(2.5, 1.5) << '\n';
    std::cout << maxOf(4, 9, 6) << '\n';
    return 0;
}

8
2.5
9

Varsayılan argümanlar

Bir parametreye varsayılan değer verilebilir: çağrıda o argüman yazılmazsa bu değer kullanılır. Kural şudur: varsayılan değerli parametreler listenin sonunda yer almalıdır.

#include <iostream>
#include <string>

void printPrice(std::string item, int price, std::string currency = "AZN") {
    std::cout << item << ": " << price << ' ' << currency << '\n';
}

int main() {
    printPrice("Book", 12);
    printPrice("Headphones", 40, "USD");
    return 0;
}

Book: 12 AZN
Headphones: 40 USD

Değerle ve referansla aktarma

C++ varsayılan olarak argümanın bir kopyasını aktarır: fonksiyon parametresini değiştirse bile çağıran taraftaki değişken aynı kalır. Parametre türünden sonra & yazarsan parametre bir referansa, yani asıl değişkenin başka bir adına dönüşür. O zaman fonksiyonun yaptığı değişiklikler asıl değişkeni de etkiler.

#include <iostream>

void addBonusCopy(int points) {
    points += 10;
}

void addBonus(int& points) {
    points += 10;
}

int main() {
    int score = 50;
    addBonusCopy(score);
    std::cout << "After copy: " << score << '\n';
    addBonus(score);
    std::cout << "After reference: " << score << '\n';
    return 0;
}

After copy: 50
After reference: 60

Referanslar özellikle iki durumda işe yarar: bir fonksiyonun birden fazla değişkeni değiştirmesi gerektiğinde (örneğin iki değerin yerini değiştirmek) ve büyük bir nesneyi kopyalamadan okuması gerektiğinde. İkinci durumda const std::string& yazarız: kopya oluşmaz ve fonksiyon metni değiştiremez.

#include <iostream>
#include <string>

void swapValues(int& a, int& b) {
    int temp = a;
    a = b;
    b = temp;
}

void printBanner(const std::string& text) {
    std::cout << "*** " << text << " ***\n";
}

int main() {
    int x = 3;
    int y = 8;
    swapValues(x, y);
    std::cout << "x = " << x << ", y = " << y << '\n';
    printBanner("Game over");
    return 0;
}

x = 8, y = 3
*** Game over ***