2. fonksiyonlar

KBUZEM
Karabük Üniversitesi
Uzaktan Eğitim Araştırma ve Uygulama Merkezi
2. HAFTA
NESNEYE DAYALI PROGRAMLAMA

BLM225
Nesneye Dayalı Programlama
2
2. Fonksiyonlar - I
C++’da alt programlara fonksiyon denilmekte ve "alt program", "prosedür", "subroutine"
sözcüklerinin karşılığı olarak kullanılmaktadır. Fonksiyonlar belirli bir amaç için yazılmış
program parçalarıdır ve programcının programını modüler hale getirmesini sağlamaktadır. Bir
C++ programı kendi içinde var olan hazır fonksiyonlar (cout, cin, sqrt(x), exp(x) …) ile
kullanıcının tanımladığı fonksiyonlardan oluşmaktadır.
Bir programı fonksiyonlar ile yazmanın bir çok nedeni vardır.
• Fonksiyonlar yapısal programlamanın temel yapı taşlarıdır. Programı küçük parçalara
ayırarak, yönetilebilir, daha anlaşılabilir programlar yazabilmeyi sağlamaktadır.
Fonksiyonlar bir başka ifade ile böl ve yönet (divide and conquer) prensibinin
uygulanmasına imkan vermektedir.
• Başka bir sebep ise yazılımın yeniden kullanılmasıdır. Bu sayede, önceden yazılmış
fonksiyonlar bloklar halinde birbirleri ardına yerleştirilerek yeni programlar
yazılabilir.
• Üçüncü sebep ise programda kodları tekrar etmekten kurtulmaktır. Kodları fonksiyon
haline getirerek paketlemek, kodların program içinde birçok noktada yalnızca
fonksiyonu çağırarak kullanılmasını sağlar.
C++’ da bir fonksiyon aşağıda gösterildiği şekilde tanımlanmaktadır.
Geri_dönüş_tipi fonksiyonun_ismi ( parametre listesi )
{
Değişken tanımları
Komutlar
Return değer
}
Kullanıcının tanımladığı her fonksiyonun, amacına yönelik bir ismi vardır. Örneğin fonksiyon
toplama işlemi yapıyorsa ismi “topla” olabilir. Fonksiyon geriye değer gönderiyorsa örneğin
toplam değerini geriye gönderiyorsa bu değer return ile geriye dönderilir.
Geri dönüş tipi fonksiyonun geriye gönderdiği değerin tipini belirtir. Örneğin int, float, char,
bool veya string olabilir. Eğer fonksiyon geriye değer göndermiyorsa geri dönüş tipi “void”
olarak belirtilir.
Parametre listesi fonksiyona gönderilen veya girilen değişkenlerin sayısını ve tipini belirtir.
Örnek olarak aşağıda tanımlanan int Kare(int x) şeklinde verilen fonksiyon kendisine
gönderilen tamsayı(int) türünde değişken değerinin karesini alarak geriye döndermektedir.
Karabük Üniversitesi Uzaktan Eğitim Araştırma ve Uygulama Merkezi
Mühendislik Fakültesi No: 215 Balıklarkayası Mevkii 78050 Karabük TÜRKİYE
2

BLM225
3
int Kare(int x)
{
int deger;
deger=x*x;
return deger;
}
Fonksiyon tanımlamalarında geri dönüş değerini yazım hatası oluşturur.
Bir değer ile dönmesi beklenen geri dönüş tipi belirtilmiş bir fonksiyonun, geri dönüş değerinin
belirtilmemesi beklenmeyen hatalara yol açabilir
Geri dönüş tipi void olarak bildirilmiş bir fonksiyonun, bir değer geri döndürmesi bir yazım
hatasıdır.
Bir fonksiyon içinde başka bir fonksiyon tanımlamak yazım hatasıdır.
Anlamlı fonksiyon isimleri ve anlamlı parametre isimleri kullanmak programları daha okunur yapar
ve yorumların çok fazla kullanılmasını engeller.
Eğer fonksiyonun tanımı main fonksiyonundan sonra yapılmış ise fonksiyon ismi parametre listesi ile
birlikte main() fonksiyounundan önce programın başlangıç kısmında kütüphane dosyalarından sonra
belirtilmelidir. Bu şekilde bildirime fonksiyon prototipi denir. Bir fonksiyon prototipi, derleyiciye
fonksiyon tarafından döndürülen verinin tipini, fonksiyonun almayı beklediği parametre
sayısını, parametrelerin tiplerini ve parametrelerin sırasını bildirir.
maksimum fonksiyonunun prototipi
int maksimum ( int, int, int );
şeklindedir.
Bu fonksiyon prototipi, maksimum fonksiyonunun int tipinde 3 argüman alacağını ve sonuç
olarak int tipinde bir sonuç döndüreceğini belirtir. Dikkat edilirse, fonksiyon prototipiyle
maksimum fonksiyonunun tanımının ilk satırı, parametrelerin isimlerinin (x, y ve z)
bulunmayışı haricinde aynıdır.
Fonksiyon içinde tanımlanan bütün değişkenler yerel değişkenlerdir. Bu değişkenler sadece
tanımlandığı fonksiyon içinde geçerlidir. Parametre belirten değişkenlerde yerel değişkendir.
Aşağıda verilen programda maksimum isimli fonksiyona üç tamsayı parametre olarak
gönderilmekte, en büyük değer geriye döndürülmekte ve ana program içinde dönen değer
ekrana yazdırılmaktadır.
3

BLM225
4
Fonksiyonlara parametre aktarım yöntemleri
Fonksiyonlara parametre aktarımı iki şekilde yapılmaktadır.
Değer ile çağırma(Call by value)
Adres ile çağırma(Call by reference)
Değer ile çağırma yönteminde fonksiyon parametrelerine değişkenlerin değeri kopyalanır.
Gerçek değişkenin değerinde herhangi bir değişiklik olmaz. Değer ile çağırma yönteminde
geriye tek bir değer gönderilmektedir.
4
//Üç tamsayının en büyüğünü bulmak
#include <conio.h>
#include <iostream>
using namespace std;
int maksimum( int, int, int ); //fonksiyon prototipi
int main( )
{
int a, b, c;
cout<< "3 tamsayı giriniz: ";
cin>>a>>b>>c ;
cout<< "Maksimum : "<< maksimum( a, b, c )<<" dirn" ;
cin.get();
return 0;
}
//maksimum fonksiyonunun tanımı
int maksimum( int x, int y, int z )
{
int maks = x;
if ( y > maks )
maks = y;
if ( z > maks )
maks = z;

BLM225
5
Adres ile çağırma
5
#include <iostream>
int add(int, int);
int main()
{
int x,y;
x=5; y=10;
cout << "Toplam = " <<add(x, y)<< endl;
return 0;
}
int add(int a, int b)
{
return a + b;
}
5
10
15

BLM225
6
Geriye birden fazla değer göndermek gerekirse veya fonksiyon içinde yapılan işlemlerin
fonksiyona gönderilen parametre değişkenini etkilemesi isteniyorsa adres ile çağırma yöntemi
kullanılır. Bu yöntem ile değişkenlerin değerleri değil adresleri fonksiyona parametre olarak
gönderilir. Aşağıda verilen programda
degistir1(….) fonksiyonunda fonksiyona a ve b değerlerin kopyası yerel değişkenler x ve y
ye geçirilmektedir . Değişim bu yerel değişkenler üzerinde olmaktadır. Fonksiyon
sonlandığında yerel değişkenlerde yok olmaktadır. Dolayısı ile a ve b değişkenleri yer
değişmemiş olmaktadır.
Degistir2 (…) fonksiyonunda ise a ve b değişkenlerinin adresleri fonksiyona
geçirilmektedir. adreslerin içindeki değerler yer değiştiğinden ve fonksiyondan çıktıktan
sonrada bu değişken adresleri kaybolmayacağından değişim işlemi gerçekleşmektedir.
6
#include <iostream>
void degistir1( int x, int y )
{
int gecici;
gecici = x;
x = y;
y = gecici;
}
void degistir2( int *x, int *y )
{
int gecici;
gecici = *x;
*x = *y;
*y = gecici;
}
int main( )
{
int a, b;
a = 12;
b = 27;
cout<< "degistir1 fonk dan once a : "<<a<<" b : "<<b<<endl;
degistir1(a, b);
cout<< "degistir1 fonk dan sonra a : "<<a<<" b : "<<b<<endl;
degistir2(&a, &b);// Argumanları aktarırken, baslarina & konur
return 0;
}

BLM225
7
Aşağıda verilen programda ise birden fazla değer fonksiyondan geriye dönderilmektedir.
7
#include <iostream>
void hesapla( int x, int y , int *top, int *fark, int *carp)
{
*top=x+y;
*fark=x-y;
*carp=x*y;
}
int main( )
{
int a, b,top1,fark1,carp1;
a = 3;
b = 10;
hesapla(a,b,&top1,&fark1,&carp1);
cout<< "toplam : "<<top1<<endl;
cout<<" fark : "<<fark1<<endl;
cout<<" carp : "<<carp1<<endl;
return 0;
}

BLM225
8
Fonksiyonlara Parametrelerin Referans Olarak Gönderilmesi
Bir önceki derste fonksiyonlara pointerler kullanarak parametre aktarımı gerçekleştirilmişti.
Bilindiği gibi pointerler bir değişkenin adresini tutan başka bir değişkendir. Aşağıda verilen
programda
void degistir2( int *x, int *y );
şeklinde verilen fonksiyona dışardan iki değişkenin adresi gönderilmektedir. Bu adreslerin
içinde yer alan değerler adreslerden yararlanarak yer değişmektedir.
C++'da ampersand (&) simgesini kullanarak değişkenler için referanslar tanımlamak
mümkündür. Bir değişken için referans tanımlanması aynı bellek gözüne ikinci bir isim
vermek demektir. Referans, bir başka ifade ile bir değişkenin diğer ismi gibi davranan bir
göstericidir.
degistir2 fonksiyonu
void degistir3( int& x, int& y ) ;
8

BLM225
9
şeklinde tanımlanırsa x ve y kendisine gönderilen değişken ile aynı bellek alanını
kullanacaktır. Böylece x ve y de yapılan değişiklik kendisine gönderilen parametre
değişkenlerin değerini(içeriğini) değiştirecektir. Referans ile parametre aktarımı yapılan bir
fonksiyonun çağrılması yazım şekli olarak değer ile çağırmada olduğu gibi yapılabilmektedir.
Böylece yazım ve kullanımda kolaylık sağlamaktadır.
C'de anaprogramdan parametre olarak gönderilen bir verinin orijinal değerinin fonksiyon
içinde değişmesi isteniyorsa o verinin adresinin parametre olarak fonksiyona gönderilmesi
gerekir.
Büyük boyutlu veriler bir fonksiyona parametre olarak aktarılırken değerleri yerine
adreslerinin aktarılması tercih edilir. Çünkü değer olarak aktarılması durumunda büyük
boyutlu verinin tamamı yığına kopyalanacaktır. Bu da hem bellekte fazla yer harcanmasına
hem de programın yavaşlamasına neden olacaktır.
Yerel değişkenler referans ile döndürülemez!. Yerel değişkenler sadece tanımlandıkları
bloğun içinde veya bir fonksiyonun içinde tanımlandıklarından fonksiyondan çıktıktan sonra
bellekten atılırlar.
int& fonk(int a, int b ) // Referans ile veri geri döndürülecek
{
int x; // Yerel değişken.
x=a+b;
return x; // Hata! x'nin adresi artık yok.
}
int* fonk(int a, int b ) // Adres ile veri geri döndürülecek
{
x=a+b;
return &x; // Hata! x'nin adresi artık yok.
}
Bu fonksiyonun doğru olanı yerel değişkenlerin değer ile geri dönderilmesidir..
int fonk(int a, int b ) // Değer geri döndürülecek
{
x=a+b;
return x; // Doğru! x'nin değeri dönderiliyor
}
Aşağıda verilen programı inceleyiniz.
9
#include <iostream>
//Pointer ile parametre aktarımı
void degistir2( int *x, int *y )
{ int gecici;
gecici = *x;
*x = *y;
*y = gecici;
}
//Referans ile parametre aktarımı
void degistir3( int& x, int& y )
{ int gecici;
gecici = x;
x = y;
y = gecici;
}
int main( )
{ int a, b;
a = 12;
b = 27;
degistir2(&a, &b);
degistir3(a, b);// Argumanları aktarırken, baslarina & konur
return 0;
}

BLM225
10
int fonk(const int &a, const int &b ) şeklinde tanımlanan fonksiyonda a ve b sabit
referanslardır. Dolayısı ile fonksiyon içinde değerleri değiştirilemez.
int fonk(const int &a, const int &b )
{ int x; x=a+b;
a++; b++; //hata çünkü sabit referansın değeri değiştirilemez
return x;
}
10

BLM225
11
Fonksiyon Parametrelerin varsayılan başlangıç değerleri
Fonksiyonlar tanımlanırken parametrelerin varsayılan başlangıç değerleri de verilebilir.
Böylece fonksiyon çağrıldığında parametre kullanılmamış ise kullanılmayan parametrenin
varsayılan değeri fonksiyon için de kullanılır. Parametre değeri verilmiş ise bu takdirde bu
değer fonksiyon içinde kullanılacaktır.
Aşağıda ki örnek programı inceleyiniz.
divide ( ) şeklinde fonksiyon çağrıldığında a değişkeni 8 ve b değişkeni 2 değerini alacak ve
fonksiyonda buna göre değerler hesaplanacaktır. Sonuç 4 olacaktır.
divide (12) şeklinde fonksiyon çağrıldığında a değişkeni 12 ve b değişkeni 2 değerini alacak
ve fonksiyonda buna göre değerler hesaplanacaktır. Sonuç 6 olacaktır.
divide (21,3) şeklinde fonksiyon çağrıldığında ise a=21 ve b=3 değerini alacak ve
fonksiyonda buna göre değerler hesaplanacaktır. Sonuç 7 olacaktır.
Aşağıda verilen fonksiyon üç değişik parametre almaktadır. b ve c parametreleri başlangıç
değeri olarak 2 ve 5 değerlerini almaktadır.
void Topla (int a, int b=2, int c=5) { … }
11
#include <iostream>
int divide (int a=8, int b=2)
{
int r;
r=a/b;
return (r);
}
int main ()
{
cout << divide ( )<<endl;
cout << divide (12)<<endl;
cout << divide (21,3)<< endl;
cin.get( );
return 0;
}

BLM225
12
Bu fonksiyon aşağıdaki gibi üç farklı şekilde çağrılabilir:
Topla(5); //a=5 b=2 c=5
Topla(5,6); //a=5 b=6 c=5
Topla(5,6,7) //a=5 b=6 c=7
Topla(7, , 4); // Hata ikinci parametre eksik bırakılmış. Parametre atlanmamalı sırası ile
verilmelidir.
inline fonksiyonlar(Makrolar)
C dilinde makroları tanımlamak için önişlemcinin #define direktifi kullanılmaktadır. C++ da
ise makrolar normal fonksiyonlar gibi yazılabilmektedir. Ana program içinden bir fonksiyon
ismi ile karşılaşıldığında (fonksiyon çağrıldığında) fonksiyonun bellekte yerleştiği alana bir
dallanma gerçekleştirilir. Bu sırada dönüş adresi ve bazı işlemci kaydedici içerikleri yığına
saklanır. Fonksiyon tanımında yer alan komutlar icra edildikten sonra yığından dönüş adresi
ve kaydedici içerikleri alınarak ana programda kalınan noktadan devam edilir. Fonksiyon her
çağrıldığında bu işlem tekrar edilir. Görüldüğü üzere fonksiyon bellekte bir kez yer
kaplamaktadır. Ancak her fonksiyon çağrısında yığına değer atma ve çekme gibi fazladan
işlemler yapılmaktadır. Bu ise zaman kayıplarına neden olmaktadır. Zaman kısıdının önemli
olduğu uygulamalarda bu önem arzeder.
Makrolarda ise, çağrının yapıldığı her yere makronun kodu eklenir. Bu durumda her makro
çağrısı programın boyunun uzamasına neden olacaktır. Ancak fonksiyonu çağırma yani başka
bir koda gitme, geri gelme ve parametre aktarımı olmadığından makro çağrıları normal
fonksiyon çağrılarına göre daha daha hızlı gerçekleşecektir. Özellikle hızlı çalışmasını
istediğimiz ve kodu kısa olan program parçalarını makro olarak oluşturmak doğru olacaktır.
Şekil 4.1 de normal ve makro olarak çağrılan fonksiyonun bellekteki durumları
görülmektedir.
12

BLM225
13
Şekil 4.1 a) Normal fonksiyon çağrısı b) makro çağrısı
Bir fonksiyonu marka olarak tanımlamak için Fonksiyon tanımının başına inline ifadesi yazılır.
inline int kare (int a)
{
return a*a;
}
Rastgele sayı üretimi
C++ da rasgele sayı üretmek için stdlib.h dosyasında tanımlanmış bulunan
int rand(void) ;
şeklinde tanımlanmış fonksiyon kullanılır.
#include <stdlib.h> başlık dosyası rand fonksiyonunun çağırılması durumunda kaynak koda
dahil edilmelidir.
13

BLM225
14
rand fonksiyonu her çağırıldığında [0, RAND_MAX] aralığında rasgele bir tamsayı değerini
geri döndürür. RAND_MAX stdlib.h başlık dosyası içinde 32767 olarak tanımlanmıştır.
Aşağıda verilen programda 0 ile 32767 arasında 10 adet rasgele sayı üretilerek ekrana
yazdırılmaktadır :
Rasgele sayı üreticilerinin (random number generator) kullandıkları başlangıç değerine tohum
değeri (seed) denir. rand fonksiyonunu içeren programı her çalıştırdığımızda aynı tohum
değerinden başlayacağı için aynı sayı zinciri elde edilecektir. İşte ikinci fonksiyon olan srand
fonksiyonu, rasgele sayı üreticisinin tohum değerini değiştirmeye yarar:
void srand (unsigned seed);
srand fonksiyonuna gönderilen her sayı değeri rand() fonksiyonunun ürettiği rasgele sayı
zinciri değişecektir.
14
#include <conio.h>
#include <iostream.h>
#include <iostream>
int main()
{
int k;
for (k = 0; k < 10; ++k)
{
cout<< rand()<<endl;
}
getch();
return 0;
}
#include <iostream>
int add(int, int);
int main()
{
int k;
srand(100);
for (k = 0; k < 10; ++k)
return 0;
}

BLM225
15
Aşağıda verilen kullanımda time fonksiyonu bilgisayarın zaman değerini geriye dönderip
srand() fonksiyonunda kullanıldığında tohum değeri sürekli farklı bir değer alacağından aynı
rasgele sayı zincirinin üretilmesinin de önüne geçilmiş olmaktadır.
srand(time(0));
srand fonksiyonunun bu şekilde çağırımı derleyicilerin çoğunda randomize isimli bir makro
olarak tanımlanmıştır. Yukarıdaki fonksiyon çağırımı yerine bu makro da çağırılabilir.
randomize();
15
#include <iostream>
#include <time.h>
int add(int, int);
int main()
{
int k;
srand(time(0));
for (k = 0; k < 10; ++k)
return 0;
}

BLM225
16
Programlarda bazen belirli bir aralıkta rasgele sayı üretmek isteyebiliriz. Bu durumda mod
operatörü kullanılabilir :
rand() % 2 Yalnızca 0 ya da 1 değerini üretir.
rand() % 6 0 - 5 aralığında rasgele bir değer üretir
rand() % 6 + 1 1 - 6 aralığında rasgele bir değer üretir.
rand() % 6 + 3 3 - 8 aralığında rasgele bir değer üretir.
Bu fonksiyon değişkenlere rasgele başlangıç değerleri vermek için kullanılabilir.
#include <conio.h>
#include <iostream>
int toplama(int a, int b)
{
int toplam;
toplam=a+b;
16

BLM225
17
a=a+1;
return toplam;
}
int main()
{
int x, y; x=5; y=3;
cout<<"toplam="<<toplama(x,y)<<endl;
cout<<"x="<<x<<endl;
cout<<"y="<<y<<endl;
getch();
return 0;
}
#include <conio.h>
#include <iostream>
int toplama(int& a, int b)
{
int toplam;
toplam=a+b;
a=a+1;
return toplam;
}
int main()
{
int x, y; x=5; y=3;
cout<<"toplam="<<toplama(x,y)<<endl;
getch();
return 0;
}
#include <conio.h>
#include <iostream>
int toplama(int *a, int b)
{
17

BLM225
18
int toplam;
toplam=*a+b;
*a=*a+1;
return toplam;
}
int main()
{
int x, y; x=5; y=3;
cout<<"toplam="<<toplama(&x,y)<<endl;
getch();
return 0;
}
// bu örneğin değişken takibini bir kağıda yapın. Kağıdın resmini çekim mail ile bana
// gönderin. tabiki kağıdın üstüne isminizi yazın.
// ödevleri şuan aktif olan 9 kişi gönderebilir.
#include <conio.h>
#include <iostream>
void calculate( int x, int y , int *add,
int *dif, int *mul)
{
*add=x+y;
*dif=x-y;
*mul=x*y;
}
18

BLM225
19
int main( )
{
int a, b,addi,diff,mult;
a = 3; b = 10;
calculate(a,b,&addi,&diff,&mult);
cout<<"Total: "<<addi<<endl;
cout<<"Difference : "<<diff<<endl;
cout<<"Multiple: "<<mult<<endl;
getch();
return 0;
}
#include <iostream>
#include <conio.h>
double ondalik(double d)
{
if (d>0) {
while(d>=1)
{ d=d-1; }
}
else {
while(d<-1)
{ d=d+1; }
}
return d;
}
int main()
{
double d;
cout<<"ondalık sayı giriniz: ";
cin>>d;
cout<<ondalik(d)<<endl;
getch();
return 0;
}
19

2. fonksiyonlar

Recommended

Recommended

More Related Content

What's hot

What's hot (10)

More from karmuhtam

More from karmuhtam (18)

2. fonksiyonlar