Bu yazıda C++ programlama dilinde fonksiyonların temel kullanım özelliklerinden bahsedeceğim. İnline fonksiyon ve fonksiyon aracılığı ile fonksiyon çağırma gibi konuları da bu yazıda bulabilirsiniz. Ayrıca konunun anlatımının daha anlaşılır olabilmesi için pek çok kod örneği de yazı içerisinde mevcuttur.

Fonksiyonlar

Programlamada fonksiyonlar, projemiz içerişinde gerçekleştirilecek belirli işlemleri yaptırmak için oluşturduğumuz ifade dizileridir. Fonksiyonlar yeniden kullanılabilir özelikte yapılardır bu sayede, eğer bir işlemin aynı proje içerişinde çok sayıda tekrarlanması gerekiyorsa, o işlemi gerçekleştirmek için bir fonksiyon oluşturmak kurtarıcı olacaktır. Aynı zamanda fonksiyonlar projelerinizin daha anlaşılır ve müdahale edilebilir olmasında sağlayacaktır.

Fonksiyonları tanımlarken öncelikle fonksiyona girecek verileri belirleriz. fonksiyona giren veriler, fonksiyonun gerçekleştirdiği işlem aracılığı ile işlenerek belirli çıktılar oluştururlar. Bu çıktılar fonksiyonun döndürdüğü bir değer veya gerçekleştirdiği bir işlem olabilir.

Fonksiyonları tanımlarken, fonksiyonların başına döndüreceği verinin, yani fonksiyonun çıktısının veri tipini destekleyen bir veri tipi tanımlamamız gerekir. Fonksiyonu void olarak tanımlarsak fonksiyonun herhangi bir veri döndürmeyeceğini belirtmiş oluruz.

int topla ( int a, int b) { return a+b; } : Örnek olarak bu fonksiyonun adı topla, parametreleri int tipindeki a ve b değişkenleri, yapmış olduğu işlem ise a ve b değişkenlerinin değerlerini toplayıp, fonksiyonun çağrıldığı yere işlem sonucunu int tipinde döndürmektir.

topla (7, 8): Yukarıdaki fonksiyonu çağırırken, bu ifade ve benzeri uygun değişken değerlerine sahip bir ifade kullanabilirsiniz. Bu ifade bulunduğu yere 15 değerini döndürecektir. Ayrıca fonksiyon çağırma ifadelerini yazarken ifadenin üzerine fareyi götürünce, fonksiyonun hangi tip değişkenlere ihtiyacı olduğunu da görebilirsiniz.

C++ iç içe fonksiyonları desteklememektedir, yani bir fonksiyonun içerisinde yeni bir fonksiyon oluşturamazsınız. Ancak bir fonksiyonun içerisinde pek çok farklı fonksiyon çağırabilirsiniz.

Aşağıdaki kod bloğu ile welcome fonksiyonunu ana fonksiyonumuzda üç kere çağırarak, ekrana alt alta üç kere merhaba yazılmasını sağlamış olduk.

#include <iostream>

void welcome()
{
	std::cout << "merhaba\n";
}

int main()
{
	welcome();
	welcome();
	welcome();
	return 0;
}

Aşağıdaki kod bloğu ile write_character fonksiyonu main fonksiyon içerisinde beş kere çağrılarak, ekrana alt alta gelecek şekilde sırasıyla Yazilan harf : A, Yazilan harf :b, Yazilan harf :c, Yazilan harf :d, Yazilan harf: E yazdırılacak.

#include <iostream>
void write_character (char character)
{
	std::cout << "Yazilan harf:" << character << "\n";
}

int main()
{
	write_character('A');
	write_character('b');
	write_character('c');
	write_character('d');
	write_character('E');
	return 0;
}

Aşağıdaki kod bloğu ile toplama, çıkarma, çarpma, bölme, mod alma ve ekran yazdırma işlemlerini, fonksiyonları birbiri içerisinde çağırarak tek bir komut yardımıyla gerçekleştirmiş olduk. Aşağıdaki kodun ekran çıktısı altında yer almaktadır. Ayrıca başlangıçtaki veri tiplerini float tanımlayarak bölme işleminin küsuratlı bir sonuç vermesini sağlamış olduk. Eğer değişkenleri int olarak tanımladıktan sonra float bir değer döndürmeye çalışaydık, bölme işlemi sonucunun yalnızca tam sayı kısmını ekrana yazdırmış olurduk.

#include <iostream>

int topla ( int a, int b)
{
	return a + b;
}
int cıkar(int a, int b)
{
	return a - b;
}
int carp(int a, int b)
{
	return a * b;
}
float böl(float a, float b)
{
	float c;
	c = a / b;
	return c;
}
int mod(int a, int b)
{
	return a % b;
}
void calculate_all(float a, float b)
{
	int toplam, fark, carpım, modu;
        float bölüm;
	toplam = topla(a, b);
	fark = cıkar(a, b);
	carpım = carp(a, b);
	bölüm = böl(a, b);
	modu = mod(a, b);

	std::cout << "toplama isleminin sonucu:" << toplam << "\n";
	std::cout << "cikarma isleminin sonucu:" << fark << "\n";
	std::cout << "capma isleminin sonucu:" << carpım << "\n";
	std::cout << "bolme isleminin sonucu:" << bölüm << "\n";
	std::cout << "bolme isleminin kalan kismi:" << modu;
}
void main()
{
	// işlemleri 7-3 ve benzeri şekilde gerçekleştirecek
	calculate_all(7,3);
}

Yukarıdaki kodun ekran çıktısı: toplama isleminin sonucu:10
cikarma isleminin sonucu:4
capma isleminin sonucu:21
bolme isleminin sonucu:2.33333
bolme isleminin kalan kismi:1

Aşağıdaki kod bloğu ile düzgün bir altıgenin alan ve çevre hesabını yapıp ekrana yazdıran fonksiyonlar oluşturulmuştur. Aşağıdaki kodun ekran çıktısı hemen altında yer almaktadır.

#include <iostream>

float alan(float kenar)
{
	float a(kenar), ALAN;
	ALAN = (1.2247) * 3 * a * a;
	return ALAN;
}
float cevre(float kenar)
{
	float a(kenar), Cevre;
	Cevre = 6 * a;
	return Cevre;
}
void yazdır(float kenar)
{
	std::cout << "\n";
	std::cout << "Kenar uzunlugu " << kenar;
	std::cout << " olan duzgun altigenin:" << "\n";
	std::cout << "cevresi:" << cevre(kenar);
	std::cout  << "\n";
	std::cout << "Alani:" << alan(kenar);
}
void main()
{
        // uzunluk birimini ihtiyacınıza göre revize edebilirsiniz
	yazdır(5);
	yazdır(6.25);
}

Yukarıdaki kodun ekran çıktısı: Kenar uzunlugu 5 olan duzgun altigenin:
cevresi:30
Alani:91.8525
Kenar uzunlugu 6.25 olan duzgun altigenin:
cevresi:37.5
Alani:143.52

Fonksiyonlarda İleriye Dönük Bildirim

Bir fonksiyonu çalıştırabilmemiz için ilgili fonksiyonun çalıştırılmadan önce derleyici tarafından işlenmesi gerekmektedir. Bu sebepten bir fonksiyonu kullanabilmek için ilgili fonksiyonu kullanmadan önce derleyicinin fonksiyonu okumasını sağlamalıyız. Bu durumu fonksiyonu kodunuz içerisinde fonksiyonunuzu çağırma işleminin gerçekleştiği noktadan önce tanımlamak yada ileriye dönük bildirim yapmak gibi yöntemlerle sağlayabilirsiniz.

İleriye dönük bildirim, fonksiyonun tanım kısmının fonksiyon proje içerisinde kullanılmadan önce yazılması ile sağlanır. Aşağıdaki örnekte olduğu üzere kare fonksiyonu değil ama fonksiyonun tanım kısmı olan float kare (float x) kare fonksiyonu kullanılmadan önce derleyiciye bildirilerek, derleyicinin hata vermeden derleme işlemine devam edip, kare fonksiyonunu da okuyarak işlemleri doğru bir şekilde gerçekleşmesini sağladı. Aşağıdaki kod ekrana 18.18 sayısının karesi olan 330.512 sayısını yazdıracaktır.

#include <iostream>

float kare(float x);

void main()
{
	std::cout << kare(18.18);
}

float kare(float x)
{
	return x * x;
}

Aynı İsimde Farklı Fonksiyonlar Tanımlama

C++’da aynı isimde birden fazla fonksiyon tanımlayabiliriz. Aynı isime sahip fonksiyonlar tanımladığımızda, derleyicimiz fonksiyonlardan gerçekleştirilen işlem için en uygun olan fonksiyon hangisi işe onu kullanır. Eğer hangi seçeneğin daha uygun olduğuna karar veremez işe hata verecektir. Hata oluşmasını engellemek için aynı isimi kullanarak tanımladığımız fonksiyonların kullandığı veri türü, işleme giren değişken sayısı gibi özelliklerini çeşitlendirebiliriz. Aynı isime sahip farklı fonksiyonlar oluşturmak, büyük projeler sırasında kolaylık sağlayabilir.

#include <iostream>

int topla(int sayı1, int sayı2)
{
	std::cout << "iki degiskenli int fonksiyon ile:";
	return sayı1 + sayı2;
}
float topla(float sayı1, float sayı2)
{
	std::cout << "iki degiskenli double fonksiyon ile:";
	return sayı1 + sayı2;
}
int topla(int sayı1, int sayı2, int sayı3)
{
	std::cout << "uc degiskenli int fonksiyon ile:";
	return sayı1 + sayı2 + sayı3;
}
float topla(float sayı1, float sayı2, int sayı3);
void main()
{
	int a(1), b(3), c(5);
	float d = 2.5;
	float e = 7.2;

	std::cout << topla(a,b);
	std::cout << "\n";
	std::cout << topla(a,b,c);
	std::cout << "\n";
	std::cout << topla(d,e);
	std::cout << "\n";
	std::cout << topla(d,e,18);
}
float topla(float sayı1, float sayı2, int sayı3)
{
	std::cout << "ileri bildirimli uc degiskenli float fonksiyon ile:";
	return sayı1 + sayı2 + sayı3;
}

Yukarıdaki kodun ekran çıktısı: iki degiskenli int fonksiyon ile:4
uc degiskenli int fonksiyon ile:9
iki degiskenli double fonksiyon ile:9.7
ileri bildirimli uc degiskenli float fonksiyon ile:27.7

Fonksiyonlarda Varsayılan Değer Atama

Bir fonksiyona, fonksiyonu çağırırken değişken değerlerini vermezsek kullanacağı değerleri varsayılan olarak tanımlayabiliriz.

#include <iostream>

void kullanıcı(std::string kulanıcı_adı = "bilmem ne", int kullanıcı_yası = 0, float kullanıcı_boyu = 0.0)
{
	std::cout << kulanıcı_adı;
	std::cout << " isimli kullanicinin yasi ";
	std::cout << kullanıcı_yası;
	std::cout << ", boyu ";
	std::cout << kullanıcı_boyu;
	std::cout << "'dir.";
	std::cout << "\n";
}

void main()
{
	kullanıcı("Admin", 24, 1.87);
	kullanıcı();
}

Yukarıdaki kodun ekran çıktısı: Admin isimli kullanicinin yasi 24, boyu 1.87’dir.
bilmem ne isimli kullanicinin yasi 0, boyu 0’dir.

İnline Fonksiyon

İnline olarak tanımladığımız fonksiyonlar, genelde tek satırlık basit işlemler gerçekleştiren yapılar veya birtakım veriler içermektedir. Kullanıldıkları zaman derleyici fonksiyonu çağırmak yerine, fonksiyonun içerdiği ifadeyi fonksiyonun çağırıldığı yere yazar. Bu yapı sayesinde çok sık kullanılması gereken ifadelerin kullanımı kolaylaştırılabilir ve daha sonra değiştirilmesi gerekirse daha kolay değiştirilebilir. Ayrıca inline fonksiyon kullanımı doğrudan bir fonksiyonu çağırmaya karşın programın çalışma süresini kısaltabilir yani programı hızlandırabilir.

Aşağıdaki kod bloğunda çarp(3,7) yazan yerlerde sanki 3*7 yazıyormuş gibi düşünebilirsiniz. Aynısı diğer ifade içinde düşünülebilir.

#include <iostream>

inline int çarp(int a, int c)
{
	return a * c;
}
inline float böl(float a, float c)
{
	return c/a;
}
void main()
{
	std::cout << çarp(3,7);
	float e = böl(3, 7);
	std::cout << "\n" << e;
}

Fonksiyonları Fonksiyonlar Yardımı ile Çağırma

Fonksiyonları fonksiyonlar aracılığı ile çağırabilir ve ister çağırma işleminin gerçekleştirildiği fonksiyonda değişmeyen değerlerle yada çağırırken verdiğiniz değerlerle işlem yapacak şekilde oluşturabilirsiniz.

Aşağıdaki örnekte olduğu üzere çağırma fonksiyonu aracılığı ile çarp ve böl fonksiyonlarını çağırılabilmekte ve ihtiyacımız doğrultusunda bir ifade yapısı oluşturmamızı kolaylaştırmaktadır. int çağırma( int (*çağırılan)(int, int) ) ifadesinde, çağırma fonksiyonu içerisinde böl ve çarp fonksiyonlarını çağrılan ifadesi temsil etmektedir. Bu ifadede de görüldüğü üzere ifadedeki değişken tipleri ve sayıları çağrılacak fonksiyonlara göre ayarlanmıştır. Bu örnekte fonksiyon sabit olarak 15 ve 5 sayılarıyla işlem yapacak şekilde tasarlanmıştır. Aşağıdaki program ekrana 75 ve 3 yazdıracaktır.

#include <iostream>

int çarp(int a, int b)
{
	return a*b;
}
int böl(int a, int b)
{
	return a / b;
}
int çağırma( int (*çağırılan)(int, int) )
{
	return çağırılan(15,5);
}
int main()
{
	int c;
	c = çağırma(çarp);
	std::cout << c << "\n";
	c = çağırma(böl);
	std::cout << c;
}

Aşağıdaki örnekte olduğu üzere işlem fonksiyonu aracılığı ile topla ve çıkar fonksiyonları çağırılabilmekte ve ihtiyacımız doğrultusunda bir ifade yapısı oluşturmamızı kolaylaştırmaktadır. int işlem (int (*yap)( int, int ), int a, int b) ifadesinde, işlem fonksiyonu içerisinde topla ve çıkar fonksiyonlarını yap ifadesi temsil etmektedir. Bu ifadede de görüldüğü üzere ifadedeki değişken tipleri ve sayıları çağrılacak fonksiyonlara göre ayarlanmıştır. Bu örnekte fonksiyona ayrıca a ve b değişkenleri de girdi olarak verilmiş ve fonksiyonumuzun işlevselliğini arttırmıştır. Aşağıdaki program ekrana 18 ve 10 yazdıracaktır.

#include <iostream>

int topla(int a, int b)
{
	return a + b;
}
int çıkar(int a, int b)
{
	return a - b;
}
int işlem(int (*yap)( int, int ), int a, int b) 
{
	return yap(a, b);
}
int main()
{
	int c;
	c = işlem(çıkar, 25, 7);
	std::cout << c << "\n";
	c = işlem(topla, 3, 7);
	std::cout << c;
}

Aşağıdaki örnekte alternatif bir çağırma yöntemi gösterilmektedir. Bu örnekte using yerine = int(*)(int, int) ifadesi yardımı ile çağırma fonksiyonunun karmaşıklığı azaltılmıştır. int işlem(yerine y, int a, int b) ifadesinde görüldüğü üzere y fonksiyon içerisinde topla, çıkar, çarp ve böl fonksiyonlarına karşılık gelmektedir. Aşağıdaki program ekrana 18, 10, 27 ve 2 yazdıracaktır.

#include <iostream>

using yerine = int(*)(int, int);

int topla(int a, int b)
{
	return a + b;
}
int çıkar(int a, int b)
{
	return a - b;
}
int çarp(int a, int b)
{
	return a * b;
}
int böl(int a, int b)
{
	return a / b;
}
int işlem(yerine y, int a, int b)
{
	return y(a, b);
}
int main()
{
	int c;
	c = işlem(çıkar, 25, 7);
	std::cout << c << "\n";
	c = işlem(topla, 3, 7);
	std::cout << c << "\n";
	c = işlem(çarp, 9, 3);
	std::cout << c << "\n";
	c = işlem(böl, 50, 25);
	std::cout << c;
}