Temel Bilgiler



C++ bilindiği gibi programlama dünyasında en çok ilgi gören C dilinden türemiştir. C++'ı klasik C dilinden farklı yapan yanı; Nesne Yönelimli Programlamayı da ( Object Oriented Programming) C'nin sözdizimi kurallarıyla birlikte desteklemesidir. Normalde C ile sadece yapısal programlama yaparken C++ dili ile hem yapısal hem de nesne yönelimli programlar yazabilirisiniz. C++ diline başlarken önce dilin C'den gelen ve temel olan özelliklerini öğrenmek gerekir. Örneğin, değişken tanımlama, atama ve diğer basit aritmektik işlemler, kontrol yapıları ve döngüler gibi.

Teknolojinin ulaştığı son noktadaki programlama dillerinden olan C ve C++, bir çok yeni ve güçlü özellikleri içerir. Derslerimiz devam ettikçe bunların teker teker içine gireceğiz. C dilinin özelliklerinin %80 i C++'da da mevcuttur (bu karşılaştırma şahsi görüşümdür). Zaten C++, C'nin üst gurubudur. Bunu şöyle sıralayabiliriz. C, C++ ve C# dır.

C dilinin avantajları, az komut kümesinden oluşması ve bu komutların diğer yüksek seviyeli dillere nazaran daha hızlı çalışmasıdır. Ayrıca C deki kütüphaneler sayesinde fonksiyon tanımlamanıza gerek kalmadan işlemlerinizi yapmak mümkün olacaktır. Bu konuda çok detaya inmeden, programlamaya geçmek istiyorum. Çünkü, programlamaya başladığımızda her örnekten sonra o an kullandığımız programın içinde geçen fonksiyon, hata, değişken, belirleyiciler, kısıtlamalar, notasyonlar v.s gibi bilgilerden ara ara bahsedeceğim. Yalnız çok önemli olan bir konuya burada değinmek istiyorum. C nin avantajlarını programlamayla birlikte görmek güzel ama C nin dezavantajlarını programlamadan önce bilmeliyiz ki bunlardan sakınalım. Öncelikle Tanımlayıcılardan bahsetmek istiyorum. Her derleyici ve assmbley için değişkenleri, sabitleri, etiketleri ve fonksiyon adlarını tanımlama kuralları vardır. Bu notasyonlara, tanımlayıcı denir. C++ da tüm tanımlayıcılar a, . . . , z - A, . . . , Z harfleri ile ya da alt çizgi "_" ile başlar. Bundan sonra rakam, harf, ya da alt çizgi kullanılabilir. ANCI C uyumlu derleyiciler 31 karaktere kadar tanımlayıcı kabul ederler fakat tanımlayıcının ilk sekiz karakterini kullanmayı kendimize alışkanlık etmeliyiz. Dikkat etmemiz gereken özelliklerden biri de kullandığımız ifadelerdeki büyük küçük harflerdir. C ve C++ büyük ve küçük harf duyarlılığına sahiptir. Kullandığımız ifadeleri birbirinden farklı ve aynı ifade olarak kullanıyorsak programımız hata verecektir. Bunu bir örnekle anlatayım:



Code:
Program
PROGRAM
progRAM
ProgRamBu şekilde tanımlarsak hepsi birbirinden farklı ifadeler olarak C++ da okunacaktır. Biz Şunu alışkanlık edinmeliyiz; tanımlayıcılarımızın baş harfi büyük olacak. Büyük ve küçük harf kombinasyonlarının kullanılması ile önceden yapılan tanımlamalar bazen işi zorlaştırabilir. Eğer bu değişkenlerden birini kullanmak isterseniz, bu zamana kadar nasıl tanımladığınızı bilmeniz gerekir. Örneğin printf()`in PRINTF() olarak çağrılması durumunda " bilinmeyen tanımlayıcı " (Unknown identifier) hata mesajı vererek sizi uyarır. Buna benzer olarak %f ve %F kullanımı hata verdirecektir. Programlamayı yaparken bunlara dikkat etmemiz gerekecek. Çünkü bir değişkeni veya tanımlayıcıyı başta nasıl kullandıysanız üç, dört sayfa kod yazdıktan sonrada aynı şekliyle kullanmak zorundasınızdır. İşte burada en büyük handikap yaşanacaktır. Çünkü C/C++ derleyicileri her zaman hatanın nerde olduğunu göstermez. Bunu programcı kendisi satır satır takip ederek bulacaktır. Bundan dolayı bu söylediklerime baştan dikkat etmemiz gerekiyor.

Tavsiyeler:
İyi bir programlama yapabilmek için benim size olan tavsiyelerim; daha az kod kullanarak daha çok işlem yapabilme. Gerçi bunu yapsak zaten profesyonel oluruz . Zaten C++ `ın paradigması da buradan geliyor. Aslında C++ da yapabileceğimiz tüm programları C de yapma olanağımız var ama bu bize hem fazla kod yazmayı gerektirecek hem de zaman kaybetmemize sebep olacak. Zaten bunlardan kaçındığımız için C++ diyoruz. Elimizde nesneye yönelik bir dil varken ve kullanacağımız fonksiyonlar içinde hazır olarak mevcutsa, tabi bize de bunun keyfini sürmek kalıyor. Tavsiyelerimden biride derslerde verdiğimiz örneklerin dışında aynı algoritmaya benzer farklı örnekler yapın. Öğrenmenin en iyi yolu yanlış yapmaktır. Bunu şöyle izah edeyim: eğer yanlış yapıyorsanız ve de o yanlışın kaynağını bulup düzeltebiliyorsanız, o an onu öğrenmişsiniz demektir. Tabi örnekler sizin için alıştırma olacaktır ve hafızanızda kalıcı bir yer tutacaktır. Bunca kodu başka türlü hafızada tutamayız. İlk başlarda sık sık not alınız, mümkün olduğunca da bol örnek yapınız. Örneklerinizi de kendiniz düşünüp kendi hayal gücünüzle oluşturursanız eminim bu işi başaracaksınızdır. Başta çok zor gelebilir ama başarı ter dökülmeden olmaz. Bu kısmı fazla uzatıp sizi daha başlamadan C/C++ dan uzaklaştırmak istemiyorum.






İlk programımız!


kütküt atıyov galbimm


Code:
// ilk1.cpp
// Ekrana "Bu benim ilk programım" yazdırıyoruz
#include <iostream.h>

int main()
{
cout << "Bu benim ilk programım";

return 0;
}
Şimdi Yazdığımız programı inceleyelim:

"//" işaretini açıklama satırlarında kullanıyoruz. C++ derleyicisi bu notasyonla başlayan satırı okumaz. Bununla birlikte daha uzun cümlelerimiz olursa bunları da " /* */ " notasyonunun içinde yazıcağız. Bu özellik de C den bize kalma. Demiştik zaten C `nin tüm özelliklerini C++ içerir. Fakat biz genelde " // " yi kullanacağız.

#include <iostream.h> : Bu bizim C++ da bulunan kütüphane dosyamızı çağırmaya yarıyor. Ben size şöyle tarif edeyim. iostream.h kütüphanesindeki hazır olan " cout " fonksiyonunu çağırıyor. Yani buda bizim fazla kod yazmamıza engel oluyor. .h ile biten dosyalar kütüphane dosyalarıdır. Bunu şuna da benzetebiliriz. Farz edelim ki elimizde bir alet çantası var içinden tornavidayı çağırdığımızda vida sıkacağızdır. Bu da ona benziyor. C++ da ki hazır kütüphanelerde bir çok hazır fonksiyonlar vardır. İlerde Bu hazır fonksiyonlar işimizi görmemeye başlayınca kendi kütüphanemizi yapmaya başlayacağız. Tabi bu seviyeye geldiğimizde olayı hemen hemen kavramış olacağız, tabi neden olmasın öyle değil mi?

Daha sonraki satır her C++ programında mutlaka bulunması gereken bir satırdır. Her C++ programında main() fonksiyonu olmak zorundadır; bu fonksiyonumuzun önünde ise o fonksiyonun dönderdiği değişkenin veri tipi olmalıdır. Tabi ki C++ fonksiyonlar ve onların dönderdikleri değerler konusunu da ileride işleyeceğiz.

Bir sonraki satırda ise; C++ fonksiyonlar ve kod blokları " { } " parantezleri arasında bulunmalıdır. main de bir fonksiyon ise onun içindeki kodlar doğal olarak { } parantezleri arasındadır.

Program derlenip çalıştırıldığında ise ( Turbo C++ 3.1 kullanıyorsanız ctrl+f9 kısa yoluyla programı çalıştırabilirsiniz (Run) ) karşımıza "Bu benim ilk programım" yazısı çıkacaktır. İşte bu yazıyı ekrana veren komut da iostream.h kütüphanesindeki cout fonksiyonudur.

Önemli bir nokta ise C++ dilinde her satır ifadenin sonuna " ; " koymak zorundayız. Bundan farklı olarak #include satırlarının ve bir kaç farklı satırın arkasına " ; " gelmez. Bunları ileride göreceğiz.

Return 0 : programımızın (aynı zamanda main fonksiyonumuzun) çıkış noktasıdır. Eğer return ile 0 değeri dönderirsek programımızın güvenle çıktığını işletim sistemine bildirmiş oluruz. Bu sayede güvenle programımızın çalıştığını göreceğiz.

Şimdi size bir örnek daha vereceğim bununla da aynı çıktıyı elde edeceğiz. Arasındaki farkları eminim basit olarak sizlerde göreceksinizdir.



Code:
// ilk2.cpp
// Ekrana "Bu benim ilk programım" yazdırıyoruz
#include <stdio.h>
main()
{
printf("Selam bu benim ilk programım.\n");
return 0;
}
Evet şimdi burada çok fark varmış gibi gözüküyor aslında ama öyle değil. Sadece kütüphanemiz stdio.h oldu ve ekrana yazdır fonksiyonumuzda printf oldu. Bu özellik C den kalma. Bunlar diğer program ile aynı işlevi görüyor. Buradaki fark " \n " notasyonu. Bu noptasyon bir sonraki satıra geçmek için kullanılır. Bu notasyonlara Escape dizileri denir. Tablo olarak bunları size veriyorum. Son yazdığımız ilk2.cpp de yerlerine koyarsanız çalışacaktır.




Değişkenler



Şimdi bize yine çok lazım olacak bir özellik de değişken tanımlamak ve atama yapmaktır. Bunu bir örnek üzerinde anlatmak istiyorum. Örneğimiz;


Code:
// degisken.cpp
// Burda değişken tanımlamayı göreceğiz.
// Aynı zamanda verilen bir sayıyı kendisi ile carpma 2.2=4 gibi

#include <iostream.h>
#include <stdio.h> // kütüphane dosyamız
main()
{
int i; // Değişken tanımlama
cout << "Bir sayı giriniz: ";
cin >> i;
i=i*i;
cout << "sonuc: " << i ;
return 0;
}
Burada bundan önce yaptığımız programlardan farklı olarak int i kullandık, yani değişken tanımladık.

Değişken Nasıl Tanımlanır?
Değişkenleri tanımlamak için aşağıdaki şema kullanılır.

[Veri Tipi] [Değişken Adı];

Örneğin

int sayi;

Şimdi degisken.cpp örneğindeki int i; kısmını anlamışsınızdır. Burada değişkenlere değinmek istiyorum. Biz yukarda İçinde sayı tutan bir değişkeni tanımladık. Benzer olarak aşağıdaki tanımlamalar da vardır.

char c;

int i;

float f;

double d;

unsigned int ui;

Burada [Veri Tipi] [Değişken Adı]; bu kalıba göre tanımlama yaptığımız için önce Veri Tiplerini inceleyelim






Veri Tipleri



1) İnt tip.
Integer = Tamsayı


Tamsayıları içerir. Bellekte 2 Byte tutar. DOS'ta ve Win3.1'de 16 bit uzunlugunda ama Windows9x, WinNT, Win200 ve WinXP 32 bit uzunluğundadır.

Değer aralıkları Short ve long için değişir.

Örnek: 5, -20, 1 gibi.


2) Sort tip.
Tam sayıları içerir. 16 bit uzunluğundadır.

signed: -32768 ile +32767 arasinda değer alır, unsigned: 0 ile 65535 arasinda değer alır.

3) Long tip.
Tam sayılar içerir. 32 bit uzunluğundadır.

signed: -2147483648 ile +2177483647 arasinda değer alır, unsigned: 0 ile 65535 arasinda değer alır.

4) Gerçel Tipler (Float, Double, Long double)
Gerçel sayıları içerirler.

float : Bellekte 4 Byte yer tutar. 3.4E-38 ile 3.4E+38 aralığında değer alır. Hassasiyet 7-8 basamaktır.

double : Bellekte 8 Byte ter tutar. 1.7E-308 ile 1.7E308 aralığında değer alır. Hassasiyet 15-16 basamaktır.

long double : doublenin tipinin daha genişidir.1.2E-4932 ile 1.2E-4932 aralığında değer alır. Hassasiyet 19-20 basamak.

5) Char Tip
Char : Karakter

Alfanumerik karakterleri içerir. Ve ya 8 bit uzunluğunda tamsayı.

signed: -128 ile 127 arasinda değer alır, unsigned: 0 ile 255 arasında değer alır.

Örneğin: ' 0,1,2,3,4,5,6,7,... ' , ' *,-,+,... ' , 'a,b,c,....,A,B,C,D,,,,, '

6) Bool tip.
true(dogru) = 1 veya false(yanlis) = 0 değerini alır. Eski derleyiciler bu türü desteklemeyebilir. Yeni ANSI C++ standardında eklenmiştir. Bu soyut matematik gördüyseniz. "p V q" ya benzer ( matematikçiyiz, konuşturalım azıcık). Değer aralığı ise ya 1 dir (doğru) yada 0 dır (yanlış).

7) Enum tip.
enum sıralanmış değerleri tutar. Short int ile aynı değeri taşır.

Başta Fazla Detaya inip sizi bunaltmak istemiyorum. Çünkü C++ dili başlarda karmaşık gelen bir dildir. Bu da zaten kendisini yüksek seviyeli bir dil yapıyor . Ben size Bu dilin temel özelliklerini anlatarak basit programlar yapmayı göstereceğim.

Bu temel bilgileri aldıktan sonra programlamaya geçebiliriz. Derleyici Olarak ben Turbo C++ 3.1 i tavsiye ederim. Şu an bununla başlar iseniz işiniz daha kolay olacaktır (bence). İlerde Borland a geçeceğiz.

Değişken tanımlama konusunda bir konuya daha değinmek istiyorum. Değişkenlere değer atama ve aynı anda bir çok değişken tanımlamamız C++ da mümkündür.

char c = 'c';

int i = 5;

Daha sonradan değer atama:

char c;

int i;

c = 'c ';

i = 5;

Bir de aynı anda bir çok değişken tanımlayalım.

Örneğin:

int x , y , z;

x = y = z = 5;

x,y,z' nın değeri 5 oldu

Bir sonraki derste ise değişkenlerle birlikte bir de Operatörleri ele alacağız.






Program Kontrol ve Döngü Komutları



Daha önceki bölümlerde, standart veri tiplerini öğrendik, bununla birlikte diğer dillerde olmayan fakat C/C++`a özgü işlemleri de tanıdık. Şimdi ise C/C++ mantıksal kontrol yapılarını öğreneceğiz. Bu komutların bir çoğu diğer yüksek seviyeli dillerde de mevcuttur. Örneğin; if, if-else, switch, for, while ve do-while döngüleri. Fakat ?:, break, ve continue komutları gibi yalnızca C/C++`a özgü kontrol komutları da vardır. Ne demiştik C++ , C yi kapsar. O halde C de olan tüm mantıksal kontrol yapıları C++ da da mevcuttur.

Programlar (algoritmalar) üç temel blok kullanılarak gerçekleştirilebilirler. Bunlar; artarda, bir koşula bağlı olarak ve sonlu sayıda yineleme (döngü) dür.

Biz şimdi bu Mantıksal ifadeleri teker teker ele alacağız. Hem Bu sayede hepsine daha çok yer vermiş olacağız ve de örneklerle bunu pekiştireceğiz. Şimdiye kadar geldiğimiz bölümleri iyi bilip, Mantıksal ifadelerin yapılarını da öğrendiğimizde, bayağı bir yol kat etmiş olacağız.




If Komutu



if komutu anlaşılması ve yazılımı en basit olanıdır. if komutu, bir grup komutun koşullu olarak yürütülmesi amacıyla kullanılır. Buna bir örnek verecek olursak; düşünün ki bir sınav yapılıyor ve 50 ve üzeri alanlar geçecek. Bunun için if i kullanırsak not 50 ye eşit veya büyükse (büyük eşit) geçer not olacak.


Code:
//not.cpp
// 50 ve 50 den yukarsı geçiyor.
#include <iostream.h>

main()
{
int not;
cout << "Notu yazınız:";
cin >> not;

if ( not >= 50 )
cout << "Geçtiniz!";

}
Sanırım bu örnekte ne dediğimi anlamış olacaksınız


Code:
if ( not >= 50 )
cout << "Geçtiniz!";

if (ifade)
{
Komut;
Komut;
...
}
Burda görüldüğü gibi if (ifade) ve sonraki komutlarda { } bloğunun içine yazılır. Şimdi if`e bir de şu açıdan yaklaşalım. if in kelime anlamı "eğer" dir. Mantık şudur: eğer belirtilen parametre doğruysa, if komutu, if ten sonra gelen bloktaki fonksiyonları gerçekleştirir. Doğru değilse, if den sonraki bloğu yok sayar. Burada bir detaya daha inmek istiyorum. Ne demiştik, mantık işlemlerinde olay ya doğrudur (1) ya da yanlıştır (0). Şimdi yukarıdaki if in genel kullanım şekline tekrar bakalım. Bunu, eğer parametre doğru ise kullanabiliriz. Bir de bunun tersini düşünelim. Bit bazında işlemlerde sanırım ( ! ) bunu görmüştük. Her bir biti ters çevirir.



Code:
if (!ifade)
{
komut (yanlış (0));
Komut (yanlış (0));
....
}
Derdimi anlamış olduğunuzu ümit ediyorum . Ama bence buranın üstünde biraz daha duralım. Çünkü bunu anlarsak diğerlerinde zorlanmayız. Son yaptığımızda ifadeyi tersine çevirdik

Code:
//pozitif.cpp
// Bunada açıklama yaptırmayın[IMG]http://www.*****.com/images/smilies/smile.gif[/IMG] ( yapamadımda)
#include <iostream.h>
main()
{
int x;
cout << "Bir sayı girin:" ;
cin>> x;
if ( x > 0 )
cout << "Pozitif" ;
}
Aynısının negatif ini de siz yapın. Şimdi bir de iç içe if örneğine bakalım:



Code:
//gecti.cpp
// Buna açıklama yapmıycam!
#include <iostream.h>
main()
{
int not;
cout << "Notunuzu giriniz:";
cin >> not;
if ( not> 50)
cout << "Geçtiniz!" ;
if (not < 50)
cout << "Kaldınız!" ;
if ( not==50)
cout << "zar zor geçtin [IMG]http://www.*****.com/images/smilies/smile.gif[/IMG]";
}
Anlamış olduğunuzu umut ederek if komutunu burada bitiriyorum






If-else Komutları



if-else komutu iki işlemden hangisinin uygulanacağına karar verir. Else kısmı seçimlidir, gerekmiyorsa kullanılmayabilir. Yazılım kuralı ile şöyledir;


Code:
if ( ifade)
komut1;
else
komut2;daha genel şekliyle


Code:
if ( ifade )
{
komut1;
komut2;
...
}
else
{
komut1;
komut2;
...
}
Sanırım artık açıklama yapmama gerek kalmayacak. Şimdi örneklerle bunu pekiştirmeye çalışalım.


Code:
//tekcift.cpp
//sayı tekmi çiftmi onu görüceğiz
#include <iostream.h>
main()
{
int sayi;
cout<< "Bir sayı giriniz:";
cin >> sayi;
if (sayi %2==1 )
cout <<"tek";
else
cout << "çift" ;
}

Bir örnek daha verelim:


Code:
//ifelse.cpp
#include <iostream.h>
main()
{
int not;
cout<< "Notu giriniz:";
cin >> not;
if (not >= 50)
cout << "Geçti!";
else
cout << "Kaldı!";
}
if kısmından anlatmaya başlayacağım. Eğer notumuz 50 ye eşit veya 50 den büyük ise geçiyoruz aksi halde kalıyoruz.

Bir de bir if-else in altında bir tane daha if-else kullanalım.



Code:
//sinav.cpp
// alt alta if-else
#include <iostream.h>
main()
{
int not;
cout<< "Not`u giriniz:";
cin >> not;
if (not >= 50)
cout << "Geçtiniz!";
else
{
cout <<"Bütten alınan not:";
cin >>not;
if( not>=60 )
cout << "Geçtiniz!";
else
cout <<"Kaldınız!";

}
}
Burada da şunu inceledik: diyelim ki sınava girdik ve notumuzu öğrendik, notu giriyoruz 50 nin altındaysa kalıyoruz. ve bütünleme sınavına giriyoruz. Bütte de geçer not en az 60. Sanırım bu basit örneklerle olayı iyice kavramışızdır. if-else i de burada bitiriyoruz.






?: Komutu



Bu komut, yalnızca C++ a özgüdür. Kendine özgü bir yazılımı ve mantıksal kullanımı vardır. if-else komutunun kısaltılmışıdır. Fakat, tüm if-else komutları yerine kullanılmaz. Yalnızca karşılaştırma sonrası, tek komut kullanılan uygulamalar için geçerlidir. Bu söylediklerimizi örnek üstünde gösterelim


Code:
//tekcift.cpp
//tekcift.cpp yi bu sefer ?: ile yapıyoruz
#include <iostream.h>
main()
{
int sayi;
cout<< "Bir sayı giriniz:";
cin >> sayi;
cout << (sayi %2==1 ? "tek" : "çift") ;
}
Kullanış biçimi: cout << (sayi %2==1 ? "tek" : "çift") ; çok basit ama dikkat edelim. Her zaman kullanmıyoruz.




Switch-case Komutları



Switch Case deyimi işlev bakımından if deyimine çok benzemektedir. Çok sayıda if işlem blokları kullandığımızda programın okunurluğu azalacak ve programı izlemek zorlaşacaktır. Programımızın bir değerini bir çok değerle karşılaştırmak gerektiğinde switch komutunu kullanacağız. Switch seçeneği ile değişkenin durumuna göre bir çok durum içersinden bir tanesi gerçekleştirilir. İstersek de if deyimi ile switch case' yi birlikte kullanabiliriz. Switch in yaptığı iş kısaca, ifadenin değerini sırayla sabitlerle karşılaştırarak ve her satırı işlemektir.




Code:
switch( Kontrol Değişkeni )
{
case Sabit1 : komut1;
case Sabit2 : komut2;
.
.
.
default : Komutson;
}
Buna en basit örneğimizi verelim


Code:
//switch.cpp
// switch-case yi öğreniyoruz.

#include <iostream.h>

main()
{
int i;
cout<< " 1 ile 4 arası sir sayı giriniz:";
cin>>i;
switch(i)
{

case 1 :cout<<"1 Girdiniz"; break;
case 2 :cout<<"2 Girdiniz"; break;
case 3 :cout<<"3 Girdiniz"; break;
case 4 :cout<<"4 Girdiniz"; break;

default:cout<<"1 ile 4 ten farklı";
}
}

Burada gördüğümüz gibi i değişkenine bağlı olarak program işliyor. Case'lerinin aldığı değere göre kendinden sonra gelen komutları işliyorlar. Burada daha önce görmediğimiz break komutunu gördük. Buna ilerde daha detaylı olarak değineceğim. Fakat biraz bahsetmek istiyorum. Programımızda değişkene 1 değerini verdiğimizi farz edelim. Case 1 adlı satırı geçip ondan sonraki komut dizisini işleme soktuk. Bu işlemin tamamlanması için break komutu kullanılıyor. Yazılımda break komutu goto gibi işlev görür ve derleyiciye switch komutundan çıkması için talimat verir. Sorunu ortadan kaldırmak için her durum için break deyimi eklemeliyiz (tavsiye). Ne demiştik; bir çok karşılaştırma olduğunda switch'e ihtiyaç duyuyoruz. Karşılaştırmaların hiç biri olmadığı anda da ortaya default tan sonraki satırın işlenmesi kalıyor. Sanırım bu örnekte basit olarak anlamış olacağız.

Daha karmaşık bir örnek verecek olursak:



Code:
//ucgen.cpp
// Program gireceğimiz ölçülere göre üçgenin Alan, Yükseklik ve Tabanını bulur
// switch-case örneğimiz.

#include <iostream.h>

int main()
{
char secenek;
float alan, yukseklik, taban;

cout << "Program gireceğimiz ölçülere göre üçgen'in Alan,
Yükseklik ve Tabanını bulur!\n" << endl
<< " A ---> Alan : Bulmak için yükseklik ve tabanı gireceğiz:" << endl
<< " h ---> Yükseklik : Bulmak için alan ve tabanı gireceğiz:" << endl
<< " t ---> Taban : Bulmak için alan ve yüksekliği gireceğiz:" << endl
<< endl << endl;
cout<< "Seçeneğiniz? ---> A, h, t :";
cin>> secenek;

switch(secenek)
{
case 'a':

case 'A':
{
cout<< endl <<endl <<"Yükseklik: ";
cin>> yukseklik;
cout<<endl << "Taban: ";
cin >> taban;

alan = 0.5 * taban * yukseklik;

cout<<endl << endl << "Alanı: " << alan << endl;

break;
}

case 'h':
case 'H':
{
cout<< endl << endl <<"Alanı: ";
cin>> alan;
cout<<endl << "Tanabı: ";
cin >> taban;

yukseklik = 2.0 * alan / taban;

cout << endl << endl << "Yükselik: " << yukseklik << endl;
break;
}

case 't':
case 'T':
{
cout << endl <<endl <<"Alanı: ";
cin >> alan;
cout << endl << "Yüksekliği: ";
cin >> yukseklik;

taban = 2.0 * yukseklik / alan;

cout << endl << endl <<"Tabanı: " << taban << endl;
break;
}
}
return 0;
}
Gayet basit bir örnek değişkenleri tanımladık. Caseleri koyduk ve caselerden sonra gelecek komut satırlarını yerleştirdik. Bu program göründüğü gibi zor değildir.



kolay gelsin.







While Döngüsü



İçlerinde anlatımı ve anlaşılması en kolay olan döngüdür. While döngüsü, döngü sayısının belli olmadığı zamanlarda kullanılır.



Code:
while ( koşul )
Komut;While döngüsü, içinde bulunan ifade doğru olduğu sürece altındaki komut veya komut bloğu yürütülür. Eğer yanlış ise kontrol bir sonraki komut veya komut bloğuna geçer.

While döngüsü daha genel şekliyle:


Code:
while ( ifade )
{
komut;
komut;
komut;
.
.
.
}
Burada bir şeye dikkat etmenizi istiyorum. Çoklu komutlar kullandığımızda " { } "parantezleri gereklidir


Code:
// while1.cpp
// while döngüsünü kullandık
// girdiğimiz sayıdan 100 e kadar olan sayıları topladık

#include <iostream.h>

main()
{
int x, y;
y= 0;
cout<< " Bir Sayı Giriniz ( Sayı 100 den küçük olucak ) : ";
cin>>x;
while (x< 101)
{

y =y+x;
x =x+1;


}

cout<< "Toplam= "<< y;
}

Burada önce x ve y yi tanımladık. y=0 değerini verdik. Sonra klavyeden girilen değerin x olduğunu yazdık. while (x< 101) işte burada ifademiz x< 101. Şimdi bu koşul sağlanıncaya kadar döngümüz devam edecek. While' den sonraki bloğa geçtiğimizde ise. y` ye x i ekliyoruz ve x in değerini her seferinde 1 arttırıyoruz. Sanırım bu basit örnekte döngünün basit yapısını ve mantığını anlamış oldunuz.

Döngünün verilen ifade veya koşula göre sağlanması döngülerin en önemli konusudur. Eğer bir döngüden çıkılmazsa o döngü sonsuza gider. Buna da "sonsuz döngü" denir. Döngüler konusunda en çok rastlayacağımız hata da budur.Şimdi buna bir örnek verelim. Fakat, şimdiden uyarıyorum, sonsuz döngü yapıldığında bilgisayarınız kilitlenebilir. Onun için buna şimdiden hazır olun. Zaten bir sefer denediğimizde ne demek istediğimi anlayacaksınızdır.



Code:
//sonsuz.cpp
//while döngüsü ile sonsuz bir döngü yaptık

#include <iostream.h>

main()
{
int x=1;
while(x)

cout<< "x= "<< x++<< endl;

}

Burada neden sonsuz bir döngü oldu? Evet işte x ifadesini koşula bağlamadık. Şayet while(x<10) demiş olsaydık. 1,2,3,4,5,6,7,8,9 a kadar x sayısı sıralanacaktı.



Code:
//klavye.cpp
//while döngüsü ile klavyeden girilen sayı

#include <iostream.h>

main()
{
int x, y = 0;

while (y< 20)
{
cin>>x;
y = y+x;
}
cout<< "Toplam= "<< y ;
}



[Tüm Bölümler]HTMLAutoCADPhotoshopFlashC++CSSJavaScriptVisual BasicFireworks


While Döngüsü



İçlerinde anlatımı ve anlaşılması en kolay olan döngüdür. While döngüsü, döngü sayısının belli olmadığı zamanlarda kullanılır.

while ( koşul )
Komut;
While döngüsü, içinde bulunan ifade doğru olduğu sürece altındaki komut veya komut bloğu yürütülür. Eğer yanlış ise kontrol bir sonraki komut veya komut bloğuna geçer.

While döngüsü daha genel şekliyle:
while ( ifade )
{
komut;
komut;
komut;
.
.
.
}
Burada bir şeye dikkat etmenizi istiyorum. Çoklu komutlar kullandığımızda " { } "parantezleri gereklidir.

// while1.cpp
// while döngüsünü kullandık
// girdiğimiz sayıdan 100 e kadar olan sayıları topladık

#include <iostream.h>

main()
{
int x, y;
y= 0;
cout<< " Bir Sayı Giriniz ( Sayı 100 den küçük olucak ) : ";
cin>>x;
while (x< 101)
{

y =y+x;
x =x+1;


}

cout<< "Toplam= "<< y;
}
Burada önce x ve y yi tanımladık. y=0 değerini verdik. Sonra klavyeden girilen değerin x olduğunu yazdık. while (x< 101) işte burada ifademiz x< 101. Şimdi bu koşul sağlanıncaya kadar döngümüz devam edecek. While' den sonraki bloğa geçtiğimizde ise. y` ye x i ekliyoruz ve x in değerini her seferinde 1 arttırıyoruz. Sanırım bu basit örnekte döngünün basit yapısını ve mantığını anlamış oldunuz.

Döngünün verilen ifade veya koşula göre sağlanması döngülerin en önemli konusudur. Eğer bir döngüden çıkılmazsa o döngü sonsuza gider. Buna da "sonsuz döngü" denir. Döngüler konusunda en çok rastlayacağımız hata da budur.Şimdi buna bir örnek verelim. Fakat, şimdiden uyarıyorum, sonsuz döngü yapıldığında bilgisayarınız kilitlenebilir. Onun için buna şimdiden hazır olun. Zaten bir sefer denediğimizde ne demek istediğimi anlayacaksınızdır.

//sonsuz.cpp
//while döngüsü ile sonsuz bir döngü yaptık

#include <iostream.h>

main()
{
int x=1;
while(x)

cout<< "x= "<< x++<< endl;

}
Burada neden sonsuz bir döngü oldu? Evet işte x ifadesini koşula bağlamadık. Şayet while(x<10) demiş olsaydık. 1,2,3,4,5,6,7,8,9 a kadar x sayısı sıralanacaktı.

//klavye.cpp
//while döngüsü ile klavyeden girilen sayı

#include <iostream.h>

main()
{
int x, y = 0;

while (y< 20)
{
cin>>x;
y = y+x;
}
cout<< "Toplam= "<< y ;
}
Bu programda da klavyeden girilen sayıların toplamı 20' den büyük olunca program Toplam olarak söylüyor. Sanırım basit While yapısını anladınız. Şimdi birazda karmaşık programcıklar yapalım.

1. Örnek: Girilen altı not'un ortalamasını alıyor.



Code:
#include <iostream.h>

int main()
{
int toplam,
sayac,
not,
ortalama;

toplam = 0;
sayac = 1;

while ( sayac <= 6 )
{
cout << "Notu giriniz: ";
cin >>not;
toplam = toplam + not;
sayac = sayac + 1;
}

ortalama = toplam / 6;
cout << "Sınıf ortalaması = " << ortalama << endl;

return 0;

}

Bu örneğimizde yine toplam, sayac, not, ortalama gibi değişkenleri tanımladık. ( toplam =0 ; ve sayac = 1; ) de değişkenlere ilk değerlerini atadık. While döngüsünün içinde sayac değişkenimizi altı defa işlemesini söyledik. Sonra alttaki toplam ve sayac bölümlerinde ise toplam a not' u ekliyoruz, her seferinde de sayac değerini bir arttırıyoruz ve sayac değeri 6' ya gelince while döngümüz duruyor. Program sonra toplamı alıp altıya böler bu sayede ortalamayı alır, sonrada çıktısını gerçekleştirir.

2. Örnek:


Code:
//faktoriyel.cpp
// while ile faktoriyel hesaplama

#include <iostream.h>
int main()
{
int sayi;
long int faktoriyel=1;
cout << "Bir sayı giriniz: ";
cin >> sayi;
cout << sayi << " `in Faktöriyeli: ";
while (sayi > 1)
faktoriyel *= sayi--;

cout << faktoriyel << endl;
return 0;
}
Bu örnekte sanırım fazla açıklama yok. Sizden istediğim, üç kişinin maaşını girdikten sonra onların alacağı toplam maaş ve ödemeleri gereken toplam vergiyi bulmanız. Bunu yaparsanız buraya kadar olanlardan bir şeyler anlamışızdır.





For Döngüsü



For döngüsünün çalışması, döngünün kontrol değişkenine başlangıç değerinin atanması ile başlar. Aşağıda vereceğimiz ilk değer atama cümlesinden kastımızda budur. Yani bu kısımda başlangıç tanımları yapılır. For döngüsünün başlangıç adımıdır. Bu kısımda yapılan bir değişken tanımındaki değişkenin ömrü, for döngüsünün sonunda biter. Sonra döngü koşul kısmına gelinir ve bu test edilir. Şayet değeri !0, doğru (1) olduğunda döngü içindeki komutlar uygulanır. Arttırma ise for döngüsü işleminin sonunda meydana gelir. for içindeki tüm deyimler meydana geldikten sonra uygulanır.

Genel yapısı:



Code:
for ( ilk değer atamalar, koşul, arttırma)
cümleBunu daha da genellersek, diğerlerinde de olduğu gibi cümleler birden fazla olduğunda komut bloğu arasına alınacaktır.



Code:
or ( ilk değer atamalar, koşul, arttırma)
{
cümle1
cümle2
cümle3
...
}Bu söylediklerimizi bir örnek üzerinde izah edelim.

Code:
//for.cpp
// for döngüsüyle bir örnek.


#include <iostream.h>
int main ()
{
for (int n=10; n> 0; n--)
{
cout << n << " -> ";
}
cout<< "Bitti!";
return 0;
}

Ben sadece for (int n=10; n>0; n--) bu kısmı anlatacağım, diğer kısımlar apaçık gözüküyor zaten. For diyip () imizi açtık. Sonra içine ilk basamağımız olan değişken tanımlamamızı yaptık. İnt n=10; Bu bizim yukarıda bahsettiğimiz ilk değer atamalar kısmı. Daha sonra koşulumuzu yazdık. n>0; bunu test ettik ve !0 yani doğru (1) çıktı. Sonrada n-- yi yazdık. Genel tanımda yazdığımız arttırma kısmı. Aslında buna yenileme komutları desek daha doğru olur. Biz bu örnekte örneğin azaltma yaptık. Neyse umarım bu for örneğini anlamışsınızdır.

C++ da yapacağımız çoğu örnekte for u kullanacağız. C++ 'nın en güçlü yanlarından biriside for döngüsüdür. For döngüsünün başında yani ilk değer atama kısmında birden çok değişken tanımlayıp değer atıyorsak bunları virgül ( , ) ile bir birinden ayırmalıyız. İlk değer atamadan koşul bölümüne geçtiğimizde ve koşul bölümünden arttırma ya geçerken noktalı virgül ( ; ) kullanmalıyız. Tabi kullandığımız bu üç kısım seçimlidir istersek boş bırakabiliriz. Fakat, noktalı virgüller ( ; ) konulması zorunludur.

1.Örneğimiz:



Code:
//factoriyel_for.cpp
//for döngüsüyle faktöriyel hesap.


#include <iostream.h>

int main()

{
int fac, sayi;

cout<<"Sayıyı giriniz: ";
cin>>sayi;
fac=1;

for (int j=1; j<=sayi; j++)
{
fac=fac*j;
}

cout<<"Sonuc: \a"<< fac;
return 0;

}

Bu örneğimiz oldukça basit. Bildiğimiz matematiksel faktöriyel işlemini C++ kodları olarak yazdık. (\a yı kullandım bip! demesi için ).

2.Örneğimiz:


Code:
//carpim_for.cpp
// iç içe for döngüsüyle çarpım tablosu


#include <iostream.h>


main()
{
cout<<"Çarpım Tablosu! \n"<<endl;
int x,y;
for (x=1; x<=10; x++)
{
for (y =1; y<=10; y++)
cout<<" "<<x*y;
cout<<"\n";
}
}

Bu örneğimizde ikinci örneğimize benziyor. İçinde for, while ve if de var. While ve if' in içindeki matematiksel ifadeleri biliyorsak örnek gayet basit gelicektir. Burada bırakmak istiyorum. Bir sonraki ders görüşmek üzere







Break Komutu



Break komutunu, swtich komutundan çıkmak için önceki derslerimizde görmüştük. Komutun kendine özgü bir kullanımı daha vardır. Break komutu bir döngünün içinde çalıştırılırsa o an o döngü biter. Bir goto gibi işlem gördüğünü de söyleyebiliriz. Break kullanınca program döngüyü bitirir ve döngünün sonundaki satırdan çalışmaya devam eder. Bir örnek verelim.



Code:
//break.cpp
//break komutunu kullandik.


#include <iostream.h>

main()

{

for (int x = 1; x <= 10; x++) {
if (x == 7) {
break;
}
cout<< x << " ";
}
}

İşte örneğimizde gördüğünüz gibi. X 7'ye eşit olunca break; döngüyü bitiriyor ve döngüden sonraki satırı çalıştırmaya başlıyor.






Exit Fonksiyonu



Hayati hata durumlarını ele almak için exit() fonksiyonundan yararlanılır. Bu hatalar main() fonksiyonunu return ile normal olarak sonlandırılmadan önce oluşabilir. Exit() fonksiyonu, durum değerini bir tam sayı parametre olarak döndürür.

Exit() ile özel bir değerin gönderilmesi bazı işlemler yapması için kullanılabilir. Örneğin program komut satırında kullanılıyorsa ve durum değeri bazı hataları gösteriyorsa, işletim sistemi bunları mesaj olarak yazabilir. Exit() fonksiyonu programı sonlandırmanın yanında, tüm bekleyen yazma işlemlerini tamamlar ve açık tüm dosyaları kapatır.

Exit() fonksiyonunu kullanırken kullanmamız gerek kütüphaneler ise process.h ve stdlib.h tır.

__________________

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. 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.




Alıntı:
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.


Alıntı:
<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.


Alıntı:
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.


Alıntı:
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;


Alıntı:
#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:



Alıntı:
#define kare(x) x*x

İşlemin sonunda ; olmamasına dikkat ediniz. Kullanımına gelince de,


Alıntı:
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.



Alıntı:
//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.


Alıntı:
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.



Alıntı:
//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.



Alıntı:



[Tüm Bölümler]HTMLAutoCADPhotoshopFlashC++CSSJavaScriptVisual BasicFireworks


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.

Alıntı:
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.



Alıntı:
Main( int agrc, char* agrv[], char* getenv[]) {

//kodlar

}



Şeklindedir. Şimdi bunu bir örnek ile pekiştirelim:


Alıntı:
#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.

__________________