18.08.19/06:49

aceminin C++ köşesi

Başlatan data_grrr, 27.02.07/12:04

« önceki - sonraki »

0 Üye ve 1 Ziyaretçi konuyu incelemekte.

data_grrr

27.02.07/12:04 Son düzenlenme: 28.02.07/09:12 data_roze
Bu başlıkta C++ öğrenirken, basitten başlamak dikkati ile öğrendiklerimi yazmaya başlıyorum.

C++

Detay: C++, C dilinin bir sonraki versiyonudur. Bu nedenle ++ eklenmiş ismine. ++ bir espridir aslında. C dilinde '++' herhangi bir şeye 1 ekle demektir. C++, C'ye bir ekle demek oluyor yani :)

Bütün C++ programları ifadelere (statements) dayanır.
Bir ifade içinde komutların bulunduğu bir cümle olarak da adlandırılabilir. Her ifade sonunda bir noktalı virgül ile biter.

Program ilk ifadenin ardından gelen { işareti ardından çalışmaya başlar ve her defada bir ifade çalıştırmaya devam ederek ilerler.

Programın çalışmasına etkisi olmayan iki şey vardır.

1- Yorumlar: Bunlar // işareti ardından ifadelerin ne anlama geldiğini anlatmak için yazılan yorumlar olabilir ya da istediğiniz herhangi bir şey. Program çalışırken // işareti ardından gelen şeyleri dikkate almayacaktır.

2- Boşluklar: Program içerisinde istediğiniz kadar boşluk bırakabilirsiniz, bunlar dikkate alınmaz. Sadece bir kelimenin ortasında yazılması doğru olmaz ama kelimelerin arasında bulunabilir.



Deklarasyon İfadeleri:

Deklarasyon bir değişken tanımlayan bir ifadedir.

Bir değişken bir çeşit değerin içine konacağı depodur. Değişkenler bir rakam ya da harf, karakter gibi değerler içerebilir.

Değişkenler aşağıdaki tipte cebir formüllerinde ifade edildikleri gibidir, kullanımları buna dayanır.

x = 5
y = 2 * x

İkinci deyimde (expression), y, x'in 2 katına eşitlenmiştir ama x'in değeri nedir?
x değişkeni burada bir değer için depo vazifesi görür. y = 2 * x deyimi, birinci deyimde x'e atanan değere göre y'nin alacağı değerin sonucunu değiştirir. Yani x'e istediğimiz değeri atayabiliriz (-1, 20, 0) gibi.

Cebirde x = 5 gibi bir ifade ile işleme başlamanız doğrudur. C++'ta (c plas plas) ise x'e bir değer atamadan önce programa x'in bir tür depo olduğu bildirilmelidir (makinalar aptaldır evet, siz x'in bir depo olduğunu söylemezsiniz bunu anlayamazlar)

C++'ta bir değişkenin bir tipi ve bir de ismi vardır.

Yukarıdaki örnekte 'x' değişkenin ismi olur, değişken isimleri A-Z ve a,z arasındaki karakterler ile başlamalıdır, bu ilk karakterden sonra isterseniz rakam, alt çizgi kullanabilirsiniz. Bu isim istediğiniz kadar uzun olabilir.

Püf noktası: İsimlerin küçük harfle başlaması gelenektir. Ve ayrıca mantıklı isimler verilmesi programcı açısından iyi bir şeydir.
'arabaninhizi' gibi.

Tip ise değişkenin ne tipte değer taşıyabileceğini belirtir. Örneğin x'in tamsayı deposu olarak kullanılmasını istiyorsak programa başlamadan önce x'in tamsayı değişkeni olduğu bildirilmelidir. Bu da;

int x;

ile olur. int, integer'in (ingilizce tamsayı) kısaltılmış halidir. Yukarıdaki ifade "x, tamsayı (integer) değerleri taşıyabilen bir değişkendir" der.

-----------------------------------------------------------------------------------------------------------------------------
Ekrana Yazı Yazdırma:

cout ve cin ile başlayan satırlar girdi (input) ve çıktı(output) ifadeleri olarak bilinir. Programcılar kısaltmalardan hoşlanır bu nedenle in ve out olarak kısaltılmıştır bunlar.

cout (siiaut) ise gerçek anlamıyla c'nin (programlama dilinin) çıktı aygıtı demektir (yani normal koşullarda monitör).

cin de benzer şekilde c'nin girdi aygıtı demek oluyor ki bu da klavye vs. olabilir.

sadece bir ekrana yazdırma ifadesi ise şöyle oluşur:

cout << "merhaba" ;

türkçesi (sondan başlayarak):

'Bu bir ifadedir (en sondaki noktalı virgülden anladı bunu) ve tırnak içindeki kelimeyi c'nin çıktı aygıtına yaz.'

Burada ekrana 'yaz' diyen '<<'  işaretidir.


Deyimler ve Hesaplama yaptırma:

Neredeyse bütün programlarda o veya bu şekilde dört işlem gibi hesaplamalar yapılır.
C++'ta bir deyim, hesap yaptıran bir ifadedir.

Yani bir deyim, bir değeri olan ifadeye denir ve bir operatör o deyime değer kazandıran komuta denir.

Örnekle daha iyi gözükür bu:

100 + 50 örneğinde 100 + 50, 150 değerine sahip olan bir deyimdir.
Deyimin içinde bulunan + işareti ise 150'yi yaratan komuttur.

Deyimlerin Sonuçlarını Bir Değişken İçerisinde Saklamak (Daha sonra kullanılabilmeleri için):

Eşittir terimi konuşma dilinde iki farklı anlama gelebilir.

1- Aynı değere sahip olan iki şeyin eşit olduğunu belirtmek için.
'100 kuruş eşittir 1 lira'
2- Matematikteki gibi atama yapmak için.
X, Y'nin 2 katına eşittir.

yani:
X = Y * 2

burada eşit işareti iki tarafında eşit olduğunu göstermek için değil X'e Y * 2'nin sonucunu atamak için yapılmıştır. Bu nedenle programcılar bu farkı belirtmek için buradaki gibi eşit işaretlerine atama operatörü derler. 

Tam olarak türkçede şunu söyler bu ifade:

'Eşit işaretinin sağ tarafındaki deyimin sonucunu sol taraftaki değişkenin içine kaydet.'

Bu nedenle asla x eşittir y çarpı iki denmemelidir. doğru şekli x'e y*2 nin değeri atanır demektir. Program yazarken bunun katkısını göreceksiniz.

Artık bu bilgilerle basit bir program yazabiliriz. Ama nerede yazacağız biz bunları? Bir sonrakine :)
----------------------------------------------------------------------------------------------------------------------------

asya

data
sana yürekten bir "bravo" demek istiyorum. günlerdir benim gibi konuya çok ilgisi olmayanların bile ilgisini çekebilecek, bilgisayarla ilgili birçok bilgiyi  bizimle paylaştın ve bunu sürdürüyorsun. teşekkürler.

data_grrr

Evet, en son nerede yazacağız bunları demiştim.

Benim kendim de kullandığım yazılımın adı Dev-C++. Dev-C++ Windows için yazılmış özgür bir geliştirme ortamı sunar ve Genel Kamu Lisansı (GPL) ile dağıtımı, herşeyi serbesttir. Bu yazılımı edinmek için şu linke tıklayın: (9 megabyte indireceksiniz).

http://kent.dl.sourceforge.net/sourceforge/dev-cpp/devcpp-4.9.9.2_setup.exe

İndirdiğiniz dosyaya çift tıklayıp kuruluma başlayın.
Standard olarak bir kurulum klasörü seçiliyor ve dil ayarı yapılıyor (dili ingilizce yapmanızı tavsiye ederim).

İlk Programa Başlayalım:


C++ kodu yazmak normal metin editörüne yazmaktan çok da farklı değildir. Kodu programda açılan beyaz bir alanda yani yeni bir kaynak dosyasında yazacağız. Yeni bir kaynak dosyası açmak için:

1. Üstte bulunan File Menüsüne tıklayın.
2. New'ü tıklayın.
3. Source File'ı tıklayın.

Kodu yazacağınız dosya açılmıştır.

Peki ne yazacağız şimdi?...

Her C++ programının bir ölçüde standart bir çerçevesi yani kodu yazmaya başlamadan önce yazmanız gerekli olan şeyler bulunur.
Bu çerçeve aşağıdakine benzer (çizgiler arasına yazıyorum kodları karışmasın diye) ve bunu yeni açtığınız kaynak dosyasına olduğu gibi yazın. (kopyalayadabilirsiniz buradan ama yazın). Renkler kodu Dev-C++'ta yazdığınızda göreceğiniz renklerdir. Kolaylık sağlarla okumada.

----------------------------

#include <iostream>

using namespace std;

int main()
{

system("PAUSE");
return 0;
}
----------------------------

Bu çerçeveyi üstünkörü inceleyim:

#include <iostream>
Yazdığımız programda cout, cin gibi ekrana çıktı, klavyeden girdi sağlayan komutlar kullanıyoruz. Bunları kullanmadan evvel C++'a bunları kullandığımızı bildirmemiz gereklidir. İşte cout ve cin'in olduğu kütüphanenin adı iostream'dir ve bunu include (içer) komutu ile yukarıdaki yazıldığı şekliyle programa dahil ediyoruz.

using namespace std;
Bunu şimdilik açıklamak gerekmiyor. Sadece program yazarken kolaylık sağladığını bilin.

int main()
{
}

Yazdığımız her program int main() den sonra açılan { işaretinin ardından gelen ilk ifade ile başlayacaktır ve program } işareti ile son bulacaktır. Yani programa her zaman bu işaretler arasında başlıyoruz.

system("PAUSE");
Bu ifade zorunlu değildir ama program içinde bir sonraki ifadeden devam etmek için kullanıcının bir tuşa basması gerektiğini söyletir. Mesela bu ifadeyi int main() içindeki ifadelerin en sonuna koymassak daha biz ne olduğunu anlayamadan pencere kapanır (bir sonraki ifade olan return 0; çalıştırılır örnekte olduğu gibi) ve programın ne yaptığını göremeyiz.

return 0;
int main() fonksiyonunun başarıyla çalıştığını bildiren ve } kapatma işaretinin bir öncesine yazılması gereken ifadedir.


Gerçek Bir Program Yazalım:

Artık yeni kaynak dosyası açmayı ve programın yazılacağı çerçeveyi kavradığımıza göre basit bir program yazabiliriz.

Kaynak Kod Ör 1 :
-----------------------------------------------------------------------

// Bu program kullanıcıdan iki sayı girmesini ister ve
// bunları toplayıp ekrana yazdırır.


#include <iostream>

using namespace std;

int main()
{

// Aşağıdaki ifadeler önce ilksayi isimli bir tamsayı değişkeni tanımlar
// ikinci ifadede ilk sayının ne olduğu sorusunu ekrana yazdırır
// ve sonunda bunu cin ile sorarak ilksayi değişkeni içinde saklar.


int ilksayi;
cout << "Toplanacak ilk sayiyi girin: ";
cin   >> ilksayi;

// Aşağıdaki ifadeler aynı yukardaki gibi ikinci sayiyi
// ikincisayi değişkeni içerisinde saklar.

int ikincisayi;
cout << "Toplanacak ikinci sayiyi girin: ";
cin   >> ikincisayi;

// Aşağıdaki ifade ilksayi ve ikincisayi'nin toplanıp içinde
// saklanacağı yeni bir tamsayı(int) değişkeni tanımlar.

int toplam;

// Aşağıdaki ifade ilksayi ve ikincisayi değişkenlerindeki değerleri toplar ve
// sonucu daha önce tanımlanmış toplam değişkeni içine atar.


toplam = ilksayi + ikincisayi;

// Aşağıdaki ifade toplam içine atılan değeri ekrana yazdırır
// ikinci ifadenin sonundaki << endl bir satır alta geç demektir.


cout << "Birinci ve ikinci sayinin toplami: ";
cout << toplam << endl;

// Aşağıdaki ifade programı sonlandırmak için kullanıcının bir tuşa basmasını söyletir

system("PAUSE");
return 0;

}

----------------------------------------------------------------------------

Yazmayı bitirdiğinizde Dev-C++'ın Execute menüsünden Compile&Run (Derle ve Çalıştır) seçeneğini tıklayın. İstiyorsanız programı kaydedin. Yeni bir pencerede program çalışacaktır. Derleme esnasında kodunuz aynı zamanda .exe uzantılı halde çalıştırılabilir olarak saklanacaktır yani ne zaman isterseniz onu çalıştararak da programınızı kullanabilirsiniz.




data_grrr

Değişkenleri Sabit Bir Şekilde İfade Etmek:

C++'ın en temel kavramlarından birisi 'değişken'dir. Değişken küçük bir kutuya benzer. O kutuya daha sonradan kullanmak için bir şeyler koyabilirsiniz, özellikle de sayıları. Değişken kavramı matematikten gelmiştir.

" x = 1 " , 1 değerini x değişkeni içinde saklar. Bundan böyle matematikçi x değişkinini 1'in yerine her yerde kullanabilir, x in değerini başka bir şey yapana kadar.

Değişkenler C++'ta da aynı mantıkla çalışır. Şu şekilde bir atama yapabilirsiniz:

x = 1;

Bundan böyle programda x'in değeri başka bir şey yapılana kadar, x'in kullanıldığı heryerde 1 değeri kullanılmış olacaktır.

Yalnız C++'ta değişkenleri kullanırken matematikçilerin sorun etmediği bazı detaylar da bulunur.


Değişkenleri İfade Etmek:


C++ sayısal değerleri değişken denen küçük kutularda saklar. Matematikçiler değişkenleri ifade edip kullanırken bu değişkenleri öylece yazarlar.

Matematikçinin ifadesi ile değişkenler şu şekilde yazılabilir:


(x + 4) = y / 4
x + 8 = y
x ve y nedir?

Cebir bilen herkes burada x ve y değişkenlerinin tanımlandığını görür, ama C++ bu kadar zeki değildir.
C++'ta kullanmadan önce her değişkeni programa tanıtmak gereklidir.
Aşağıdaki gibi olabilir bu:


int x;
x = 5;

int y;
y = 10;


İlk satır x adlı bir değişkenin var olduğunu ve bunun int (tamsayı) tipinde olduğunu belirtir. Yani içine tamsayı alabilecektir.
İkinci satır bu x değişkeninin içine 5 değerini at demektir.
y değişkeni için aynı işlemler tekrarlanır.

Değişkenleri programın istediğiniz yerinde tanımlayabilirsiniz, mühim olan tek şey onları kullanmadan önce tanımlamanız gerektiğidir.


Farklı Tipte Değişkenler İfade Etmek:


Matematikte değişkenlerin içinde şimdiye kadarki tamsayı değerleri saklanabildiği gibi farklı tipte değerler de rahatlıkla saklanabilir.

x = 1
x = 0.5
x = "merhaba"
x = Dünya

C++ ise bu şekilde esnek değildir ve herşeyi aynı tip değişkende saklayamaz. Her çeşit değişken için farklı tipte kutular kullanılır. Burada kutuları birbirinden farklı kılan şey büyüklükleridir. Bazı kutular öyle küçüktir ki sadece tek bir sayıyı saklayabilir. Bazı kutular daha büyüktür ve içinde cümleleri saklayabilir.

Bir değişkeni kullanmadan önce bu nedenle ne kadar büyük bir değişken kullanılacağını belirtmeniz gereklidir. Şimdiye kadar sadece int (tamsayı) değişkenleri örneği vardı. Tamsayılar bilindiği gibi kesirli bir bölümü olmayan sayılardır. C++'ta kullanılan değişkenlerin çoğu bu tipe girer.

Ama her zaman bu tipte değişkenleri de kullanamayız. Örneğin üç sayının ortalamasına ihtiyaç duyduğumuzda sonuç kesirli ise bu sonucu int değişkeni içinde saklayamayız. Çünkü int değişkenlerinin boyutu buna yetmez.

Örnek İfade:

int sOrtalama; int sDeger1; int sDeger2; int sDeger3;
nOrtalama = (sDeger1 + sDeger2 + sDeger3) / 3;


ilk satırdaki ifadeler kullanılacak 4 int değişkenini de tanımlar.
ikinci satırda 3 değişkenin ortalaması matematiksel işlemle alınır ve bu değer nOrtalama değişkeni içine atılır.

Ortalaması alınan üç değer de int tipinde olduğudan toplam da int tipinde sonuç verir. Bunların toplamı 5 ise ifadedeki gibi 5 üçe bölündüğünde matematiksel olarak 1.666 değeri ortaya çıkacaktır. Fakat bütün değişkenler int tipinde olduğundan bölüm C++ için yine int (tamsayı) olacaktır. Sonuçta C++ bölümü 1.666 olarak değil, bunu yuvarlayarak 1 olarak alır. nOrtalama değişkeni içine atılan değer de bu nedenle 1 olacaktır.

C++'ın değerlerin toplamını veya bölümünü yuvarlamadan kesirli olarak saklayabilmesi için daha büyük kutular kullanmamız gereklidir.

data_grrr

Yuvarlama Problemi Nasıl Aşılır?


int türü tamsayı değişkenlerinin çeşitli işlemlerde yuvarlanıp kesin değeri vermemesi bazı uygulamalarda hatalı sonuçlar alınmasına neden olabilir. Bu nedenle ondalık sayılar kullanılmak zorundadır. C++'da ondalık sayılar noktadan sonra sıfır olmayan sayılar alabilir. Bunun anlamı C++'da 1.0'ın değeri 1.5 kadardır. Buna denk gelen int (tamsayı) ise 1'dir.

C++'da ondalık sayı olan değişkenler ifade edilirken bunlara 'double' ismi verilir.
Örneğin bir ondalık sayı saklayacak bir değişken ifade etmek istesek:

Alıntıdouble dDeger1;


Bu şekilde dDeger1 'in ondalık sayı değişkeni olduğu ifade edilir.

3 sayının ortalaması problemini tekrar uygularsak:

Alıntıdouble dDeger;
dDeger  =  2.0 / 3.0 + 1.0 / 3.0;


yukarıdaki ifade aşağıdaki sonucu verir:

dDeger = 0.999......;   olur


AlıntıDeğişken Tipleri Tablosu:

Değişken       Örnek          Amacı
int                  1                pozitif veya negatif olabilen sayma sayısı                               
unsigned int     1U              negatif olmayan sayma sayısı                                               
long                10L            int değişkeninden daha büyük olan bir int, fark yok                   
unsigned long   10UL          negatif olmayan long int sayısı                                               
float               1.0F           double ondalık sayılar kadar hafıza yemez, ama keskin değil         
double            1.0             standart ondalık sayı değişkeni                                             
char                'c'              bir char değişkeni alfabe ya da rakam karakteri saklar içinde       
string             "bu bir dizi"  bir cümleyi dizi halinde değişkende saklamak için                       
bool               true            true (doğru), ya da false (yanlış) sonuçlarını saklar sadece




Özel Karakterler

char değişkeni içinde istediğiniz harf karakterini saklayabilirsiniz. Bununla birlikte bazı ekrana yazılmayan karakterleri de kullanabilirsiniz. Bunlar özel karakterlerdir.

' \n '     yeni bir satır karakteri
' \t '      tab karakteri (yazıldığı yerden sonrakini bir sonraki taba taşır)
' \0 '     boşluk karakteri
' \\ '     ters slaş karakteri

En sık yeni satır karakteri kullanılır. Bir dizinin ortasına yazıldığında bu karakter satırı ikiye böler ve sağında kalan bölümü bir alt satıra alır.

Alıntı"Birinci Satır\nİkinci Satır"
Bu dizi yazdırıldığında aşağıdaki gibi görünür:

AlıntıBirinci Satır
İkinci Satır


Ters Slaş  için \\ iki tane kullanılması teki olduğunda bunun özel karakterlerin kullanılmasını işaret etmesi yüzündendir. Karışmaması için iki ters slaş kullanılır.

yakýsýklý

bununla yapabileceğimiz seyler neler ?

ve ne işimize yarayabilir ?

data_grrr

Matematiksel İşlemler Yapmak

C++'ta işlem yapmanın kağıt kalemle dört işlem yapmaktan çok da bir farkı yoktur. Aradaki tek fark işlem yapmadan önce değişkenleri açıklamanız gerektiğidir. Yani bir ifadede iki sayıyı toplarsınız ve o toplam daha önceden açıkladığınız değişkenin içine konur.

ör:
Alıntı
int degisken1;
int degisken2 = 1;
degisken1 = 2 + degisken2;


satır satır incelersek
1. satır (ifade), degisken1 isimli bir integer değişkeni açıklıyor.
2. satır, degisken2 isimli bir değişken açıklıyor ve 1 değerini bunun içine atıyor.
3. satır, 2 + degisken2 işlemini yapıp 3 değerini buluyor ve bunu degisken1 değişkeninin içine atıyor.


C++'ta sayı ya da değişkenler üzerinde işlem yapılırken işlemin türünü (toplama,çıkarma) belirten operatörler (işlem işaretleri) kullanılır.

İşlem Öncelik Sırasına Göre Matematiksel Operatörler

AlıntıÖncelik Sırası    Operatör                Anlamı
1                    + (tekbaşına)         Bir şey yapmaz.
1                    - (tekbaşına)         Değeri negatif hale getirir.
2                    ++ (tekbaşına)       Değere 1 ekler, artırır.
2                    --  (tekbaşına)       Değerden 1 çıkartır, azaltır.
3                    * (iki değer arası)   çarpma
3                    /  (iki değer arası)   bölme
3                    % (iki değer arası)   mod (bölüp kalan değerini bulur)
4                    +  (iki değer arası)   toplama
4                    -  (iki değer arası)   çıkarma
5                    =,*=,+=,-=,%= (özel)  değişkene değer atama tipleri


örneğin 57'yi 24 e bölmek istiyorsak içine ondalık sayılar konulabilecek bir değişken açıklayıp (double, yada float) bölü operatörünü kullanırız.
Alıntı
float degisken = 57 / 24


İşlemde Sıralamanın Önemi

Çarpma ve bölme, toplama ve çıkarmadan önceliklidir. Örneğin:

Alıntıint degisken = 4 * 2 + 2;


degisken'e atanacak sayı bulunurken önce 4 * 2 çarpması yapılır öncelikli olduğundan. Daha sonra sonuca +2 eklenir. Toplama öncelikli olsaydı sonuç çok farklı olurdu.

Aynı şekilde matematikten bilindiği gibi parantez içine alınan işlemler önce yapılır.

Tek değerle veya değişkenle kullanılan operatörler:

Bunlar +, -, ++ ve -- 'dir.

+ ve - önündeki değerin negatif, pozitifliğini belirler.

++ ve -- ise önündeki veya arkasındaki değerlere 1 ekler veya 1 çıkarır.

Örnek:
Alıntı
int degisken = 5;   // degisken isimli bir int açıkla ve 5 değerini ata.
degisken++;         // şimdi de değerini 1 yükselt, yani 6 olsun


++ veya -- ya değişkenden, değerden önce ya da sonra kullanılır.

önce veya sonra kullanılması şöyle bir fark yaratır.

Örnek:

Alıntı// üç tane değişken açıkla
int s1, s2, s3;
// s1 ve s2 nin değeri 4 olacak
s1 = 3;
s2 = ++s1;
// s1 in değeri 4 olacak ama s3'e 3 değeri atanacak.
s1 = 3;
s3 = s1++;


kodu incelersek ilkinde ++ operatörü değişkenden önce kullanılıyor ve s1'in değeri arttırıldıktan sonra sonuç s2'ye atanıyor.
ikinci kısımda ise ++ operatörü değişkenin önünde kullanılıyor ve s1 değeri önce s3'e atanıyor ve ardından s1'in değeri 1 arttırılıyor.

Atama Operatörleri Kullanmak

Atama operatörü en basit haliyle '=' işareti, sağıda bulunan değeri solunda bulunan değişkenin içine atar.

Örneğin degisken1 isimli değişkenimizin değerini iki artırmak istiyorsak aşağıdakini yazarız.

Alıntıdegisken1 = degisken1 + 2;


yukarıdaki ifade degisken1'e 2 ekler ve sonucu degisken1'e atar.

Ama yukarıdaki gibi bir değişkenin değerini iki artırmak veya eksiltmek istiyorsak bunu daha kısa şekilde de yapabiliriz.

+= ve -= operatörleri bunu yapar. Sağındaki değeri solundaki değişkenin değerine ekler veya çıkartır. Şu ikisi aynıdır:

Alıntıdegisken1 = degisken1 + 2;
degisken += 2;






arte

data ellerine saglik. ne kadar hos bir konu :P abarttim ama birilerinin faydalanmasini isterim. bilgi cagindayiz yani

data_grrr

Mantıksal İşlemler Gerçekleştirmek

Mantıksal işlem nedir? Aslında günlük hayatımızda mantıksal işlemleri biz de yaparız. Mesela çayın içinde şeker yoksa çayı içmem mantıksal bir işlemdir. Bilgisayar programları da bu şekilde mantık kullanırlar. Yine örneğin dışarıda kar yağıyorsa ya da yağmur yağıyorsa ve trafik dünden daha tıkalıysa dışarı çıkmıyorum. Buradaki 'ya da' ve 've' nin C++'ta karşılığı AND(ve) ve OR(veya)'dur. Bilgisayarların akıllı görünmesinin tek sebebi de bu tür mantık yürütebildikleri içindir. AND ve OR u programda kullanabilmek için bazı operatör işaretleri kullanılır.

AlıntıMantıksal Operatörler Tablosu

Operatör        Anlamı
==                Eşitlik; soldaki deyim sağdaki deyimle aynı değerdeyse doğrudur.
!=                 Eşitsizlik; eşitliğin tersi
>,<               Büyüktür, küçüktür; soldaki sağdakinden büyük ya da küçükse doğru.
>=,<=           Büyük eşit, küçük eşit; eşit ya da küçük, büyükse doğru.
&&                VE; soldaki ve sağdaki deyim doğru ise doğrudur
||                VEYA; soldaki veya sağdaki deyimlerden biri doğruysa doğrudur.
!                  DEĞİL; deyim yanlışsa doğrudur.


Operatörleri inceleyelim:

Eşittir

Örneğin s isimli bir değişkenin 0 ile eşit olduğunu yazmak istiyoruz.
Alıntı
s == 0;

Yukarıdaki ifadede eğer s değişkenine önceden 0 değeri atanmışsa bu doğrudur, aksi halde yanlıştır.

s == 0 , s = 0 DEĞİLDİR. Birincisi eşitliği gösterir, ikincisi s değişkenine 0 değerini atar.

Büyük ve Küçük

iki değişken yaratıp farklı değerler atayalım ve büyüklüklerini karşılaştıralım.

int s1 = 1;
int s2 = 2;
s1 < s2;

Yukarıda görüldüğü gibi s1, s2'den küçük olduğu için üçüncü satırdaki s1 < s2; ifadesi doğrudur. Doğrudur diyoruz çünki ilerde EĞER doğru ise programdan bir şey yapmasını isteyeceğiz.

VE, VEYA

Bazen iki farklı duruma göre, ikisi de doğruysa veya en az biri doğruysa, sonucun doğru olup olmadığını merak ederiz. Örneğin:
3 sayı olsun. 1. sayı 2.den küçükse ve 2. sayı 3. den küçükse sonucun doğru olmasını isteyebiliriz. Bu durumda.

Alıntıint s1 = 1;
int s2 = 2;
int s3 = 3;
(n1 < n2) && (n2 < n3);


1, 2den, 2 de 3ten küçük olduğu için son ifade doğrudur.

Mantıksal sonucun değerini (yanlış, ya da doğru olduğunu bir değişkene kaydetme)

bool adı verilen bir değişkene mantıksal bir işlemin sonucu kaydedilebilir.  Örneğin:

Alıntıint s1 = 1;
int s2 = 2;
bool b;
b = (s1 == s2);


yukarıdaki son ifade s1 ve s2 değişkenlerindeki değerleri karşılaştırır ve eşitse 'doğru' değerini değilse 'yanlış' değerini b değişkeni içine atar.

Örnek mantıksal işlem programı (bool kullanarak):

Alıntı//Aşağıdaki program iki sayı girmemizi isteyecek ve bunları karşılaştırıp //sonucun true (doğru) veya false (yanlış) olduğunu ekrana //yazdıracak.
#include <iostream>
using namespace std;

int main()   //program buradan başlıyor her zamanki gibi
{
// birinci sayının girilmesi için
int s1;           // değişkeni yarat
cout << "Birinci değeri girin: ";       //ekrana tırnak içindekini yazdır
cin   >> s1;  // bir girdi girilmesini iste ve girdiyi s1 değişkenine at.

// ikinci sayının girilmesi için
int s2;
cout << "İkinci değeri girin: ";
cin   >> s2;

bool b;   // bir bool değişkeni yarat
b = s1 == s2;   // s1 ve s2'yi karşılaştır ve eşitliğin doğru olup
                     // olmadığını b değişkeni içine kaydet

cout << s1 << " esittir " << s2  // değişkenlerin değerini yazdır
       << " = " << b                             // doğruysa 1 yanlışsa 0 yazdır
       << endl;                        // bir boş satır yaz, satır atla yani

// programın çalışmasını kullanıcı bir tuşa basmadan bitirme
system ("PAUSE");
return 0;

}



Program çalışınca:

AlıntıBirinci değeri girin: 2
İkinci  değeri girin: 2
2 eşittir 2 = 1
Press any key to continue...

--------------
Görüldüğü gibi 2 ile 2 eşit olduğu için bool içine 1 değeri atılmıştır ve aynı şekilde bu ekrara yazdırılmıştır.

data_grrr

Program Akışını Kontrol Etmek

Şimdiye kadar verilen örnek kodlar en fazla sadece bir girdi aldı, onun üzerinde bir işlem yaptı ve çıktıyı verip programı bitirdi. Bu tür programlarda bir program akışı kontrolü yoktur, kodlar sırasıyla çalıştırılır ve bitince program biter.

Peki program akışı nedir? Daha önce mantıksal işlemleri gördük. Şimdi örneğin farklı değerleri olan iki değişkenimiz olsun. Yapmak istediğimiz program birinci değişken ikinci değişkenden büyükse ekrana 'birinci 'ikinciden büyük daha büyüktür yazsın. Büyük değilse 'ikinciden daha büyük değildir' yazsın. Yani program değişkenleri karşılaştırıp, kendi içinde kimin büyük olduğunu bulsun ve ona göre 'karar verip' ekrana kimin büyük olduğunu yazsın. Program akışı programın mantıksal işlemden sonra duruma göre ne yapacağına 'karar verme'sidir.

Dallandırma Komutları

Program akışını kontrol etmek için kullanılan en basit yöntem dallandırma ifadeleridir. Bu ifade mantıksal bir işlemin sonucuna bakıp iki yoldan hangisine devam edeceğine karar verir.

Bu işlemi yapan dallandırma ifadeleri if (eğer) ve else (değilse) dir.

AlıntıÖrnek

if ( s1 == s2)
{
     // Yol 1
     // eğer s1, s2'ye eşitse çalıştırılacak kodlar buraya yazılır
}
else
{
     // Yol 2
     // eğer s1, s2'ye eşit değilse çalıştırılacak kodlar buraya yazılır
}


Yukarıdaki örnekte önce mantıksal deyim olan s1 == s2 değerlendirilir. Eğer deyimin sonucu 'doğru' ise programın akışı if'den sonraki parantezden, yani yol 1'den devam eder. Eğer mantıksal deyim 'yanlış ' ise yani s1, s2'ye eşit değilse programın akışı else'den sonra açılan parantezin içindeki kodlara geçer. else kullanmak seçeneğe bağlıdır, eğer kullanılmazsa C++ sanki else varmış da içi boşmuş gibi davranır.

if'in kullanıldığı örnek program
(if ve else'den sonra gelen parantezlere dikkat edin)

Alıntı// if tanıtım programı
#include <iostream>
using namespace std;

int main()   //program buradan başlıyor
{
     // birinci sayının girilmesini iste
     int say1;
     cout << "Birinci sayi: ";
     cin >> say1;
     
     // ikinci sayının girilmesini iste
     int say2;
     cout << "İkinci sayi: ";
     cin >> say2;
     
     // Şimdi ne yapılacağına karar ver:
     if (say1 > say2)
     
     {
              cout << "Birinci sayi, ikinciden daha buyuktur."
              << endl;
     }
     else
     {        cout << "Birinci ikinciden buyuk degildir."
              << endl;
     }
     
     //bir tuşa basılmasını bekle programı bitirmek için
     system("PAUSE");
     return 0;
     }

--------------------
program çalışınca:

AlıntıBirinci sayi: 4
İkinci sayi: 3
Birinci sayi ikinci sayidan daha buyuktur.
Press any key to continue. . .


Programı incelersek, program önce klavyeden girdiğimiz iki değeri iki değişkenin içine atıyor ve sonra onları karşılaştırıyor. Eğer say1 say2'den büyükse if'den sonraki gelen cout << "birinci sayi ikinciden daha buyuktur." komutu çalıştırılıyor. Büyük değilse 'else' bölümüne geçiliyor ve oradaki cout << "birinci sayi ikinciden buyuk degildir." komutu çalıştırılıyor.

data_grrr

Döngüler Dönelim Dönelim

Dallanma ifadeleri ile programın kodunun bir yerinden bir başka yerine akışını kontrol etmeyi sağladık ama bu komplex programlar yazabilmek için yeterli değildir.

Düşünün ki bilgisayar ekranının sürekli olarak güncellenmesi gerekiyor. Bütün ekranın güncellenmesi için milyonlarca pikselin ekrana çizilmesi gerekiyor. Aynı kodu tekrar tekrar çalıştıramayan bir program ancak güncelleme işini yapan kodun tekrar tekrar binlerce kez yazılarak ekranın güncellenmesini sağlayabilir. Bu ise gereksiz bir zahmettir.

İşte bir komutu birden çok kere çalıştırmak için döngü ifadelerine ihtiyaç duyarız.

Bir durum doğru iken döngü yapmak:

Döngü ifadelerinin en basit formu while döngüsüdür. Aşağıdaki gibidir:

Alıntıwhile(durum)
{
    // ...durum doğruyken tekrar tekrar çalışan kod
}


Durum önce test edilir. Bu durum if degisken > 5 ya da if deg1 == deg2 ya da aklınıza gelen herhangi birşey olabilir. Eğer durum doğruysa { } işaretleri arasındaki kodlar çalıştırılır. kapanma } işaretine geldiğinde kod C++ kontrolü en başa döndürür ve işlem yeniden baştan başlar. Sonuçta C++ {} işaretleri arasındaki kodu durum doğru olduğu müddetçe tekrar tekrar çalıştırır. Bir köpek sahibi köpeği pislemeden nasıl parkta tekrar tekrar dönüyorsa aynı şeydir bu da.

Peki en başta durum 'doğru' ise durumu gelecekte 'yanlış' yapacak şey nedir? Aşağıdaki örnek bunu açıklar:

Alıntı// While Örneği
#include <iostream>
using namespace std;

int main()
{
    // döngü sayısını gir
    int donguSayisi;
    cout << "Dongu sayisini girin: ";
    cin >> donguSayisi;
   
    // şimdi girilen döngü sayısı kadar döngü yap
    while (donguSayisi > 0)
    {
          donguSayisi = donguSayisi - 1;
          cout << "Sadece " << donguSayisi << " dongu kaldi\n";
    }
   
    //bir tuşa basana kadar bekle
    system("PAUSE");
    return 0;
}


While örneği kullanıcıdan bir döngü sayısı isteyerek başlar. Bunu donguSayisi isimli değişken içinde saklar. Program daha sonra while döngüsünü çalıştırır. while önce donguSayisi > 0 durumunu test eder. Eğer donguSayisi 0'dan büyükse program döngünün içine girer ( { } arasına). Burada donguSayisi değişkeninin değerini 1 eksiltir ve donguSayisinin yeni değerini ekrana yazar. Program daha sonra döngünün başına döner ve donguSayisi'nin hala 0'dan büyük olup olmadığını test eder. Değilse döngünün dışına çıkar ve program biter.

Eğer kullanıcı negatif bir değer girmiş olsaydı program döngüyü en baştan atlardı. Çünki en başta kontrol edildiğinde değişkenin 0'dan büyük olduğu doğru olmadığı için döngüden hemen çıkardı.

Program çalışınca aşağıdaki gibi görünür:

AlıntıDongu sayisini girin: 4
Sadece 4 dongu kaldi
Sadece 3 dongu kaldi
Sadece 2 dongu kaldi
Sadece 1 dongu kaldi
Sadece 0 dongu kaldi
Press any key to continue  .  .  .


while döngüsünün biraz değişik bir formu da 'do' ile yapılır.
do .  .  . while döngüsünde do'dan sonra döngünün içindeki kod en az bir kere çalıştırılır ve sondaki while ifadesindeki durum test edilir, doğruysa döngü ikince kez tekrar çalıştırılır, doğru olduğu müddetçe devam eder bu.

do
{
     // ...döngünün içi
} while (durum);

data_grrr

Döngülerde 1 Ekleme / 1 Eksiltme Özelliği

++ ve -- olan 1 ekleme ve 1 eksiltme operatörleri programlarda bir şeyi sayan döngülerde sık sık kullanılır. Bir önceki while örneğinde bunun örneğini gördük. Aşağıda programın bu 1 eksiltme işini yapan kısmı bulunuyor. donguSayisi = donguSayisi - 1; ifadesi donguSayisi diyelim 5 ise önce bundan 1 çıkarıp onu 4 yapıyor sonra bu 4 değerini tekrar donguSayisi değişkenine atıyor. Yeni donguSayisi değeri bu durumda 4 oluyor. Bu işlem donguSayisi 0 değerine varıncaya kadar devam ediyor.

Alıntı// şimdi girilen döngü sayısı kadar döngü yap
    while (donguSayisi > 0)
    {
          donguSayisi = donguSayisi - 1;
          cout << "Sadece " << donguSayisi << " dongu kaldi\n";
    }


Daha kısa olarak yazılan başka bir versiyonu ise şöyledir.

Alıntı// şimdi girilen döngü sayısı kadar döngü yap
    while (donguSayisi > 0)
    {
          donguSayisi--;
          cout << "Sadece " << donguSayisi << " dongu kaldi\n";
    }


-- operatörünün burada yaptığı şey donguSayisi = donguSayisi - 1 ile aynıdır. Tek fark 'otomatik olarak' önüne geldiği değişkenin değerini 1 düşürmesidir. Sonuçta yaptıkları şey aynıdır. -- aynı zamanda düşürüp, değişkenin değerini tanımladığı için kodumuz daha da kısa olabilir. while (durum) içerisine doğrudan yazılabilir --.

Alıntı
    while (donguSayisi-- > 0)
    {
          cout << "Sadece " << donguSayisi << " dongu kaldi\n";
    }


Bu durumda en kısa yazılmış hali kullanmak her zaman daha avantajlıdır. Hem kolay okunur hem de kolay yazılır.

donguSayisi-- ile --donguSayisi ikisi de değişkenini düşürür. Sondaki ama değişkenin değerini düşürülmeden önce programa döndürür.

Bu programda ne gibi bir fark yaratır peki? while programı örneğinde '1' değerini girdiğimizi düşünelim. Eğer --donguSayisi kullansaydık --donguSayisi'nin değeri 0 olacaktı. while (--donguSayisi > 0) olduğu için yani değişken zaten 0'dan büyük olmadığı için kontrol asla döngüye girmeyecekti. Program baştan biterdi yani. Ama donguSayisi-- yapsaydık 0'dan büyük olup olmadığı karşılaştırılan değer 1 olduğu için, yani değişkenin değeri henüz düşürülmediği için kontrol döngüye girecekti.

For döngüleri

while da kullanılmakla beraber en çok kullanılan döngüler for döngüleridir. for döngüsünün while'a göre daha çok kullanılma nedeni okunmasının daha kolay olmasıdır.

Aşağıdaki formattadır.

Alıntıfor ( değişken; durum; yükseltme)
{
   // ...döngünün içi
}


for döngüsü parantezinin üç kısmı bulunur, değişken kısmında sayma işleminde kullanılacak olan değişken açıklanır. Değişken kısmı sadece for döngüsü ile programda ilk karşılaşıldığında çalıştırılır.

Program durum kısmından devam eder. while'daki durum bölümüyle aynısıdır bu. Durum doğru olduğu müddetçe döngüye girilir ve geri dönülür.

Döngüye bir kez girilip geri dönüldükten sonra kontrol 3. kısım olan yükseltmeye gelir. Yükseltmede -- ve ++ operatörleri kullanılarak değişkenin değeri yükseltilir veya eksiltilir. Sonra tekrar 2. kısıma gelinir ve değişkenin yeni değeri ile durum kontrol edilir, doğru ise tekrar döngüye girilir.

3 kısım da opsiyoneldir. Eğer değişken veya yükseltme kısmı yoksa C++ görmezden gelir ve döngüye girer. Eğer durum kısmı yoksa döngü sonsuza dek devam eder.

for örneği:

Alıntı// For örneği - döngü sayısını belirle.
//                 o sayı kadar döngüde kal.
#include <iostream>
using namespace std;

int main()

{
    // döngü sayısını gir
    int donguSayisi;
    cout << "Dongu sayisini gir: ";
    cin >> donguSayisi;
   
    // döngü sayısı 0'a gelene kadar say
    for (; donguSayisi > 0;)
    {
        donguSayisi = donguSayisi - 1;
        cout << "Sadece" << donguSayisi << " dongu kaldi\n";
    }
   
    // bir tuşa basılana kadar bekle
    system("PAUSE");
    return 0;
}




data_grrr

Yukarıdaki for örneğini inceleyelim. Program klavyeden bir girdi alarak bunu donguSayisi değişkenine atar. Ardından gelen for, donguSayisi değişkeni değerini sıfır ile karşılaştırır. Eğer donguSayisi sıfırdan daha büyükse kontrol for döngüsüne geçer. Kontrol for döngüsüne geçip döngünün içine girildiğinde program donguSayisi'nın değerini bir düşürür ve sonucu ekrana yazar. Bu olduktan sonra tekrar for döngüsünün başına döner program ve donguSayisinin bir eksiltilmiş yeni değerini sıfır ile tekrar karşılaştırır. Sıfırdan büyük olduğu müddetçe for döngüsü tekrarlanır.

Yalnız yukarıdaki for döngüsünün iki problemi vardır. Birincisi yok edicidir. Çünki bizim orijinal donguSayisi değişkeninin değeri ile oynar, bu değişkenin orjinal değeri bize lazım olabilir. İkincisi sayma işlemi geriye doğru büyük sayılardan küçüklere gider. Bu minik problemler sadece for döngüsü için kullanılacak ikinci bir değişken(sayaç) tanımlanarak aşılabilir. Aşağıdaki gibi:

Alıntı// For örneği 2 - sayaç kullanılarak
#include <iostream>
using namespace std;

int main()
{
    // donguSayisi değerini gir
    int loopCount;
    cout << "Dongu sayisinin degerini girin:  ";
    cin >> donguSayisi;
   
    // Döngü sayısı limitine kadar say
    for (int i = 1; i <= donguSayisi; i++)
    {
        cout <<  i << " dongu bitti\n";
    }
    // bir tuşa basılmasını bekle
    system("PAUSE");
    return 0;
}


Yukarıdaki örnek bir önceki while ve for örneği ile tamamen aynı işi yapar. Tek fark bizim orjinal donguSayisi değeri ile oynanmayıp sayma işinin sayaç değişkenine, yani örnekte 'i' olarak tanımlanan değişkene bırakılmasıdır.

donguSayisi değişkenine klavyeden bir değer atandıktan sonra kontrol for döngüsüne geçer. Burada for parantezi içinde ilk sayaç değişkeni yani 'i' tanımlanır ve 1 değeri içine atılır. Sonra 'i'nin donguSayisi'ndan küçük-eşit olup olmadığı kontrol edilir. 'i' donguSayisi'ndan küçük olduğu müddetçe döngüye girilir sonra başa dönülür ve 'i'nin değeri bir artırılır. Sonra yeniden donguSayisi'ndan küçük-eşit olup olmadığına bakılır. 'i', donguSayisi'ndan büyük olunca, yani durum yanlış olunca kontrol döngüden çıkar ve system("PAUSE"); dan devam eder program.

'i' değişkeni for döngüsünün parantez içindeki değişken kısmında tanımlandığı için bu indeks(sayaç) değişkeni sadece for döngüsünün içinde bilinir. Yani örnekte for döngüsünden çıkıldığında 'i' değişkeni örneğin return ifadesi ile beraber kullanılamaz, çünki bu ifade for döngüsü içinde değildir ya da 'i' for döngüsü dışında tanımlanmamıştır.

Yani 'i' nin faaliyet alanı for döngüsüdür sadece.