Fonksiyonlar

1. Fonksiyonlar

Bundan sonraki bölümlerdeki kullanacagimiz derleyici Borland Turbo C++ 4.5 tir. Fazla zorlanmayacaginizi umut ediyorum. Kolay anladiginiz yerlere lütfen dikkat ediniz. Hata yapma olasiliginiz daha da çok artmaktadir. Yapacaginiz hatalar programin çökmesine, belki de sistemin zarar görmesine sebep olabilir. Lütfen vermis oldugum uyarilara ve tavsiyelere uymaya çalisin. Sizin de tavsiyeniz olursa bana bildiriniz[IMG]http://www.************/images/smilies/smile.gif[/IMG]. Haydi kolay gelsin...
1. Fonksiyonlara Giris:

Fonksiyonlarin programlama hayatina girmesi ile daha büyük boyutta sistemlerin tasarimi mümkün hale gelmistir. Fonksiyonlar ile alakali derslerimizde, fonksiyonlarin tanimlanmasi ve kullanimi hakkinda bilgi edineceksiniz. Fonksiyonlar konusu size her ne kadar ilk bakista "Fonksiyon" adi altinda bir konu gibi gelse de, aslinda bir alt programdir. Hatta programimizin içine, kodlamamizin daha kolay ve gelistirilebilir hale gelmesini saglayan programciklar da diyebiliriz.
Daha önce baska bir programlama dili gördüyseniz (yüksek seviyeli diller), bu konuda fazla zorlanmayacaksinizdir. Diger yüksek seviyeli dillerdeki fonksiyon kullanimina çok benzemektedir. Hiç bilmediginizi farz ederek konuya giris yapalim.
Fonksiyon Nedir? Örnegin, y=F(x) fonksiyonu; Bu matematiksel fonksiyon parametre olarak aldinan deger üzerinde bir islem gerçeklestirip, bir sonuç degerini döndürür. Mesela F(x)=x^3+5 seklinde bir fonksiyonumuz olsun, x=2 için F(x)=13 olur. Burada x fonksiyonun parametresi, 13 ise fonksiyonun geri döndürdügü degerdir. Simdi de bu matematiksel ifadeyi kodlarimizla yorumlayalim.
Int x;
x=F(2,5)
//buradan da " int f(2,5) " gibi görebiliriz... Dikkat edersek ikinci satirda, daha önce islemedigimiz bir kod var. Int x, F(2,5) degerine esitlenmistir. Simdi bir fonksiyonun nasil yazildiginin kalibini çikartabiliriz.
<Döndürdügü deger> <Fonksiyonun adi> ( <parametre listesi> ) {

<ifadeler>
} Buradaki parantezlere ve küme isaretlerine dikkat ediniz. Simdi yukarda yazdigimiz kalibi biraz açalim.
<Döndürdügü deger> : Fonksiyon her hangi bir tipte deger döndürebilir. Bu bilesen fonksiyonun döndürecegi degerin tipini ifade eder. (örnegin, int, dounle, float v.s v.s )
<Fonksiyonun adi> : Yapmak istedigimiz islemin adidir. Örnegin bir asal sayi fonksiyonu yazacagiz. Burada yazacagimiz fonksiyonun adini belirtiyoruz. Benim size tavsiyem AsalSayi veya asal_sayi seklinde kullanmanizdir. Okunabilirlik açisindan size avantaj saglayacaktir.
<parametre listesi> : Fonksiyonun kullanacaga parametrelerin tipleri ile siralanir. Örnegin, FonksiyonAdi(int x, double y) gibi.
<ifadeler> : Fonksiyonun kullanacagi tanimlamalar ve kodlardan olusan kisimdir. Nasil biz main() { kodlar } seklinde kullaniyorsak. Bunu da ona benzetebiliriz. Ama main() i bunlarla karistirmayiniz.
Simdi bu fonksiyon kalibina uygun bir kod yazalim. Örnegin, Faktoriyel bulma islemini ele alalim. Biz bir sayinin Faktörüyelini nasil bulurduk?
n!=n(n-1)(n-2)...1 Yani, 1 den n e kadar olan sayilarin çarpimidir.
long Faktoriyel(int n) {
return n*Faktoriyel(n-1);
} Evet, burada fonksiyonumuzu tanimladik. Sanirim yukaridaki blokla karsilastirinca, ne kadar kolay oldugunu sizde görmüssünüzdür. Simdi bu Faktoriyel fonksiyonumuzu nasil bir programda kullanacagiz? Hemen devamini yazayim.
long Faktoriyel(int n) {
return n*Faktoriyel(n-1);
}
void main() {
cout<<"5! (Bes Faktoriyel)= "<<Faktoriyel(5);
} Iste gördügünüz gibi ne kadar basit degil mi? J Fonksiyonumuzu tanimladik. Sonra programimizda n`e 5 degerini verdik. Faktoriyel fonksiyonu hesaplayip bize söyledi.
Biraz da yaygın yapılan hatalardan ve dikkat etmemiz gereken noktalardan bahsedelim. Kodlama yaparken fonksiyon adini belirttigim sekilde yazarsaniz 30-40 sayfalik kodlarda hata bulmaniz ve de fonksiyonlarin yerini belirlemeniz açisindan büyük kolaylik olucaktir. Yukarida verdigimiz x=F(2,5) fonksiyonununu göz önünde tutalim. Görüldügü gibi F(2,5) degeri x e atanmistir. Hiç bir zaman Fonksiyonun aldigi deger sola yazilmaz. Ayrica bir Fonksiyon çagrisi, baska bir fonksiyonun çagrisi olabilir. Örnegin, x=F(a,F(a,5) gibi. Burada F Fonksiyonun iki parametresi vardir a ve F(a,5) dir. Bu durumda öncelikle parametreler hesaplananacagi için F(a,5) in degeri ile a nin degeri F te parametreler olarak kullanilir.

Tanımlayıcının Görünürlüğünün Kontrolü ve Kendini Çağıran Fonksiyonlar

2. Tanımlayıcının Görünürlüğünün Kontrolü ve Kendini Çağıran Fonksiyonlar

Bir değişkenin görünürlüğü değişkenin etki dizinini gösterir. Bir yerel değişken, tamamen, bir fonksiyon içinde kullanılır. Onun görünürlüğü fonksiyonun içi ile sınırlıdır. Değişkenin görünürlüğü ve ulaşılabilirliğinden sadece fonksiyonun içinde bahsedilebilir. Buna "Scope Kuralları" da denir. Şimdi bunu bir örnek ile izah edelim;
#include <iostream.h>
void main(){
int i=5;
{
int i=1;
cout<<"İçerideki i: "<<i<<endl;

cout<<"Dışarıdaki i: "<<::i<<endl;
}
} Görüldüğü gibi İçerdeki i:1, Dışarıdaki i:5 şeklinde bir çıktı verecektir. Main ide bir fonksiyon gibi görürsek (gerçi özel bir fonksiyondur), denilmek isteneni anlayacaksınızdır.
Kendini tekrarlama, bir fonksiyon kendini çağırdığında oluşur. Başlangıçta bu sonsuz döngü gibi gözükür, ancak öyle değildir. C++ kendini çağırmayı destekler. Bunu bir fonksiyonun döndürdüğü değeri bulabilmesi için içindeki bir parametrenin de fonksiyon olması gibi değerlendirebiliriz. Hani başta vermiştik ya: F(x,F(x,y) gibi...

İnline Fonksiyonlar

3. İnline Fonksiyonlar

C++ `ın C ye ek olarak getirmiş olduğu bir özellikte inline fonksiyonlardır. Anlamak için basit bir örnekle başlayalım. Örneğin öyle bir program yazıcağız ki, aşırı miktarda kare alma işlemi yapmamız gerekecek ve bunun için herhangi bir fonksiyon çağırmıyor olalım. Bu durumda define komutu ile derleyiciye şu şekilde bir komut veririz:
#define kare(x) x*x İşlemin sonunda ; olmamasına dikkat ediniz. Kullanımına gelince de,
y=kare(x); bu durumda derleyici derleme aşamasında bütün kare(x) `leri x*x olarak yorumlayacaktır. Burada dikkat edilmesi gereken yer, #define topla(x,y) x+y ve kullanımda da z=topla(x,y)*topla(x,y); işte işlem sırasının vermiş olduğu hatayı görüyorsunuzdur. Tabi bunu da parantezlerle ayıracağız. Şimdi bunu C++ tam uyarlarsak, inline kelimesini, bir direktif olarak yada C++ derleyicisine fonksiyonu tek satıra koyması önerisi olarak düşünebiliriz. Derleyici bir çok nedenden dolayı bunu kabul etmeyebilir. Mesela, Fonksiyon çok uzun olabilir, Döngü içeren bir fonksiyon, değişken tanımı içeren bir fonksiyon, kendini çağıran bir fonksiyon her zaman inline olmaz.
//kup.cpp
//Kupun hacmini bulma
#include <iostream.h>

//inline fonksiyonumuz
//------------------
inline double kup( const double x)
{

return x * x * x;

}
//---------------------

int main()
{
cout << "Kübün bir kenar uzunluğunu giriniz: ";

double kenar;

cin >> kenar;
cout << "Kenar" << kenar << "olan kübün hacmi = "
<< kup (kenar) << endl;
return 0;
}

Fonksiyon Yüklemesi ve Prototipleri

4. Fonksiyon Yüklemesi ve Prototipleri

Şimdi C++ `ın getirmiş olduğu başka bir özellikten daha bahsedeceğiz. Aynı isimli fonksiyonların farklı işlemler yapabilmesi. Aynı şekilde çağrılacaklardır, fakat derleyici bunların farklı fonksiyonlar olduğunu anlayacaktır. Tabi bunun şartları var. Fonksiyonların tipleri yada bunların sıraları farklı olmalıdır. Fonksiyonların başında kalıbın tanımını yaparken, parametre listesinden bahsetmiştik. Bu parametreler belli değerler döndürürler, işte derleyicide bu döndürdüğü değerlere yani imzalarına göre bunların farklı fonksiyonlar olduğunu anlayacaktır. Tabi bunların sıraları da farklı fonksiyonlar gibi gözükmelerini sağlayacaktır. Hemen olayı anlamak için örnek verelim.
double Ortalama(int *dizi, int uzunluk){
//kodlar
}
double Ortalama(double*dizi, int uzunluk){
//kodlar
} Görüldüğü gibi bu iki fonksiyon da bir birinden farklıdır. Her ne kadar isimleri aynı olsa da...
Fonksiyon tanımlamasının fonksiyon kullanılmadan önce yapılmış olması gerekmektedir. Fonksiyonlarımızı header başlığı altından çağırabiliriz. Mesela ben daha önce bir Faktoriyel fonksiyonu yazip bunu Fakt.h olarak saklıyorum. Programımı yazarken #include <Fakt.h> diyerek bunu çağırıyorum ve programda yazdığım "5'in faktoriyelini al" dediğim zaman direk Fakt.h taki fonksiyonda işlemi yapıp aldığı değeri programa verir. Mümkün olduğunda C++ ın kendi kütüphanelerindeki hazır fonksiyonları kullanmaya çalışacağız. Var olan bir fonksiyonu yeniden yazmanın pek bir anlamı olmaz. İleride kütüphanelerdeki fonksiyonları da mümkün olduğunca göreceğiz.

Fonksiyonları Referans ile Çağırma

5. Fonksiyonları Referans ile Çağırma

Daha önceki örneklerimizde fonksiyona parametre olarak geçilen bir değer olarak çağırmıştık. Şimdi ise onu referanslar ile çağıracağız. Bunu çok uzatmadan direk örnek üzerinde anlatalım.
//referans.cpp
//fonksiyonlarda referans

#include <iostream.h>

void deneme(int &x, int &y);

int main()
{
int x,y;
cout<<" iki sayı giriniz:";
cin>>x>>y;

cout << "Denemeden önceki:\n";
cout << "X: " << x << endl;
cout << "Y: " << y << endl;
deneme(x, y);
cout << "\nDenemeden sonraki:\n";
cout << "X: " << x << endl;
cout << "Y: " << y << endl;
return 0;
}

void deneme(int &x, int &y)
{
int deger = x;
x = y;
y = deger;
} Referans parametresi (&) dir. Bu sayede fonksiyona argüman yerine o argümanın adresini yolluyoruz. Fonksiyon bu sefer verdiğimiz değere, o adresi kullanarak ulaşır. Bu çok yüksek değerleri fonksiyona gönderdiğimizde kullanacağımız yöntem olmalıdır.

Void Tipi ve Main() Fonksiyonu

6. Void Tipi ve Main() Fonksiyonu

Öncelikle void tipinden bahsedelim, aslında buna tam olarak tip de diyemeyiz. Bir nevi "tipimsi" olarak adlandırabiliriz. Daha önce çoğu programımızda void i kullandık. Fakat ne işe yaradığından pek bahsetmemiştik. Derleyici genelde void i bir tipe ait bir değer olarak görür fakat, void bir tip olmadığından dolayı döndürülemez.
Void x: //bu hatalıdır
Void fonksiyon(); // Şayet fonksiyon geri değer döndürmüyorsa kullanılır
Void *isaretci; //isaretci nesnesi herhangi bir tipe sahip değilse bunu kullanır.
//Burda geri değer döndürmeyen bir fonksiyonu ele alıyoruz. void EkranaYaz(void) {
cout<<"Ekran çıktısı";
}

main() {
EkranaYaz();
return 0;
} Burada EkranaYaz fonksiyonumuzun bir parametresi yoktur, bunu derleyiciye void olarak belirttik ve bir değer döndürmedik. Bunun içindir ki zaten return ifadesini kullanmadık (fonksiyonun içinde). Fakat bazı fonksiyonlarda return`ü kullanabilir, bu return ifadesi de işlevi sonlandırmak amacı taşır.
Main() Fonksiyonu ve Bilgi Geçilmesi:

Main() fonksiyonumuz diğer fonksiyonlardan biraz daha özel bir yapıya sahiptir. İçine bazı özel parametreler alır. Bunlar argc, agrv[], getenv[] adındadır. Bunların yanında env[] parametresi de bulunmaktadır, fakat biz tercihen getenv[] yi kullanacağız. Şimdi main() in parametreler almış halini yazalım.
Main( int agrc, char* agrv[], char* getenv[]) {

//kodlar

} Şeklindedir. Şimdi bunu bir örnek ile pekiştirelim:
#include <iostream.h>

main(int argc, char *argval[],char *getenv[])
{
int i = 0;

while (getenv[i])
{
cout << getenv[i++]<<endl;

}
} Burada main() fonksiyonu içinde agrc girilen parametre sayısını, agrv girilen parametrede tutulan sözcüklerin sayısını tutmaktadır. getenv de işletim sisteminin belli değişkenlerini tutar.

Dizilere Giriş

1. Dizilere Giriş

Diziler, "indisleri olan değişkenler" olarak adlandırılırlar. Diğer bir deyişle, birden fazla tek düze veri tipi içeren değişkenlerdir. Diziler birbirine bitişik bellek gözleri kullanılarak oluşturulurlar. Bunu biraz daha açarsak: farz edelim ki elimizde üç tane kutu var, birinde yeşil kalemler, birinde kırmızı kalemler ve birinde de mavi kalemler olsun. Bu kutucukları 1,2,3 diye adlandırdığımızı düşünelim. Biz diziler ile numarasını bildiğimiz kutucuğun içindeki malzemeyi alabileceğiz. Daha doğrusu numarasını vermiş olduğumuz kutunun içindeki bilgiyi bilgisayar okuyacaktır.
Not: For döngüsü dizi elemanlarına ulaşmak için en çok kullanılan yöntemdir.
Dizilerin indislerden oluştuğunu söylemiştik. Diğer yüksek seviyeli dillerle karşılaştırıldığında arasındaki fark ilk elemanın indisi daima sıfır (0) olmasıdır.
for(int i=0; i<boyut; i++) Burada dikkat etmek istediğimiz "int i=0" kısmıdır. Görüldüğü gibi indisin ilk aldığı değeri sıfır (0)`dan başlatıyoruz. Bu kısmı unutmayınız. Genellikle yapılan en büyük hatalardan biridir.
Bir dizi tanımlayıcısı -adı-, dizinin ilk elemanının adresini tanımlayan adrestir. Bunu şöyle izah edelim; elimizde bir dizi var ve ilk elemanı karakter ise biz "char DiziAdi[boyut]" şeklinde tanımlarız. Tam sayı ise "int DiziAdi[boyut]" şeklinde olur.
Dikkat edilmesi gereken diğer bir konu da: dizi adı hiçbir zaman (=) işaretinin solunda bulunmaz. Bu yukarıda söylediklerimi anlamamış olabilirsiniz. Onun için alt kısmı okuyup bir daha tekrar etmenizi tavsiye ederim.

Dizilerin Tanımlanması ve Değer Atama

2. Dizilerin Tanimlanmasi ve Deger Atama

Int a[10]; Seklinde bir diziyi tanimlayabiliriz. Bunu daha genel bir kaliba dökersek.
<tip> <dizi adi> [<boyut>]; halini alir. Birde boyutlarinin arttirilmis halini verelim.
<tip> <dizi adi> [<boyut1>][<boyut2>][<boyut3>]....[<boyutn>]; n boyutlu dizi[IMG]http://www.************/images/smilies/smile.gif[/IMG].
<tip>: Yukarida söylemis oldugumuz "int DiziAdi[boyut]" olayidir.
<dizi adi>: Kurallara uygun herhangi bir isim olabilir. Genellikle dizilerinizin amacina uygun isimler kullaniniz.
[<boyut>]: Dizinin kaç eleman içerdigini gösterir. 5 elemanli ise [5] seklinde yazariz.
Basta " int a[10]; " almistik. Simdi bunu degisik bir formda yazalim
const int boyut=10;
Int a[boyut]; Önce boyut adinda bir sabiti tanimladik ve deger atadik sonrada bunu dizi içine çagirdik.
Dizilere Deger atama:

Bu yöntemleri madde madde verelim,
1. Duragan ve global (erisilen) dizilerde yaratildiklari anda içerik otomatik olarak belirlenebilir. Programin taniminda erisilen tüm degiskenler, otomatik olarak sifir yapilir.
2. Duyuru sirasinda sabit degerler belirtilerek belirlenebilir.
3. Programin çalismasi sirasinda indisler kullanilarak her elemana tek tek veri kopyalanabilir.
1. maddenin örnegi #include <iostream.h>

const int boyut=5;
int GlobalDizi[boyut];

main() {

//"satatic" yerel degiskende tanimlanmasina ragmen tüm program boyunca
//geçerlidir. Ancak sadece tanimlandigi fonksiyon tarafindan erisilebilir.

static int DuraganDizi[boyut];

for(int i=0; i<boyut;i++)
cout<<GlobalDizi[i];
return 0;
} Programin çiktisinada göreceginiz gibi, dizi aratilirken indislere ait eleman bloklari temizlenmis ve sifir degerlerini almistir.
Burada bir konuya daha dikkat çekmek istiyorum. Çok yaptigimiz hatalardan biri olarak da, dizi duyurusunu yaparken belirttigimiz degerden fazla sayida deger girmemizdir.
int DiziAdi[5]={1,8,9,5,4,6};Görmüs oldugunuz gibi bes tane dedik ama alti tane yazdik. !!! hata !!!. Bu tür hatalar için elimizde kullanabilecegimiz bir kalip var.
char DiskOkunmuyor[ ] = "Disk okunmuyor";
char DosyaYok[ ]= "Dosya Yok"; Bunu yaptigimizda derleyici, tüm degerleri içerebilecek en büyük diziyi olusturur

Dizi Boylarının Dinamik Hesaplanması

3. Dizi Boylarının Dinamik Hesaplanması "sizeof()"

sizeof() fonksiyonu, nesne için bellekte gerekli olan byte`ların sayısını belirtir. Sizeof() fonksiyonu dizilerde kullanılabilir.
#include <iostream.h>

void main() {
int a[5];
float b[10];
cout<<"dizinin boyutu: "<<sizeof(a)<<'\n';
cout<<"dizinin boyutu: "<<sizeof(b);
} Evet burda da görmüş olduğumuz gibi dizinin bellekte kaplayacağı byte`ları hesapladı.
Birde bu konuyla beraber "&" operatörünün bir dizi bile olsa değişkene nasıl uygulandığını görebiliriz.
#include <iostream.h>

void main() {
int a[10];
cout<<"sizeof(int) is"<<sizeof(int)<<endl;
for(int c=0; c<10; c++)
cout<<"&a["<<c<<"]="<<&a[c]<<endl;
} Programı derledikten sonra "sizeof(int) is 2 ya da sizeof(int) is 4" diyecektir. Bu değişiklik int in mikroişlemcilere bağlı olarak 2 veya 4 byte olabilmesinden kaynaklanmaktadır.

Diziler ve Sözcükler (strings)

4. Diziler ve Sözcükler (strings)

C++ da sözcükler için farklı bir tip yoktur. Sözcükler ile ilgili işlemler diziler yardımı ile kolaylıkla yapılabilir. Dikkat edilmesi gereken bir kural vardır. Sözcüklerin (strings) son elemanları "\0" değerini alır (null terminator). Burdan da anlayacağımız gibi son karakter boş dizgiyi belirtiyorsa stringtir. Şuna da dikkat edilmelidir ki string sabitlerinin sonuna "\0" koymamıza gerek yoktur. Derleyici bunu otomatik olarak yapacaktır.
Char sozcuk[7]="Deneme";
Char sozcuk[7]='D', 'e', 'n', 'e', 'm', 'e', '\0'}; Bu dizilerin içerikleri tamamen aynıdır. Hazır söz gelmişken şuna da değinelim. '\n', '\t', '\0' v.s, bunlar birer karakter olarak okunur. Ben önceleri iki diye okurdum[IMG]http://www.************/images/smilies/smile.gif[/IMG]
#include <stdlib.h>
#include <iostream>
#include <string>
using namespace std;

int main()
{
string Cevap = "";
cout << "Hazirmisin?";
cin >> Cevap;
if( ( Cevap == "evet" ) || ( Cevap == "Evet" ))
{
cout << "Ee Tamam... ne gec ti eline?[IMG]http://www.************/images/smilies/smile.gif[/IMG] " << endl;
}
else
{
cout << "Zorlamaya devam et!" << endl;
}
cout << "Hazirmisin? " << endl;
cin >> Cevap;
if( ( Cevap[0] == 'e' ) || ( Cevap[0] == 'E' ) )
{
cout << "Ee Tamam... ne geçti eline?[IMG]http://www.************/images/smilies/smile.gif[/IMG]" << endl;
}
else
{
cout << "Zorlamaya devam et!" << endl;
}

system("pause");
return 0;
} Bu, sanırım bu konudaki en zor örneğimiz. Şimdi örnek üzerinde biraz konuyu konuşmaya devam edelim. Zaten diğer if, else bloklarından ve cout, cin gibi komutlardan bahsetmeyeceğim. string Cevap = ""; bir sabitimizle işleme başladık. if( ( Cevap[0] == 'e' ) || ( Cevap[0] == 'E' ) ) burası sanırım tanıdık geldi[IMG]http://www.************/images/smilies/smile.gif[/IMG] Evet şimdi burda Cevap[1] i çağırmış olsaydık 'v' veya 'V' değerlerini alıcaktık. Tabi burada index değerinin yani dizideki ilk değerin 0 ile başladığını bir daha gördük. Şimdi bu örnekle alakalı olarak da Diziler ve Fonksiyonlar konusuna geçelim....