C++

[arsenik_x]

C++ Temelleri


Bu makale daha önce azda olsa programlama konusunda deneyimli (C yada visual basic yada pascal) kullanıcılar tarafından okunacağı varsayılarak hazırlanmıştır. Bu makaleyi anlayabilmeniz için azda olsa program akışını ve denetimini kavrıyabiliyor olmanız gerekmektedir. Eğer daha önce yukarıda belirtilen dillerde program yazmış ve dallandırma,altprogram,veri tipleri,girdi,çıktı ve veri tabanı gibi kavramlar size yabancı gelmiyor ise makalenin devamını gönül rahatlığı ile okuyabilirsiniz.

C++ oldukça karmaşık bir yapıya sahip somut öğelere sahip bir programlama dilidir ancak bu karmaşık yapının arkasında güçlü bir dil yatmaktadır C++ ile birlikte MFC kullanımını öğrenmek için gerekli adımları birlikte atacağız.

MFC Nedir?

MFC (Microsoft Foundation Class Library) Visual C++ kullanarak Windows uygulamaları geliştirmek için tasarlanmış bir araçlar kütüphanesidir.MFC sizin özelleştirmeniz ve kendinize uyarlamanız için hazırlanmış Windows uygulamaları topluluğudur. C++ ile program yazmaya başladığınızda MFC den büyük ölçüde yararlanacaksınız.

Veri Tipleri

C++ dilinde sıkça kullanılan temel veri tipleri şunlardır:

Bool :Bool veri tipi true ve false değerlerini alır. programlama da true doğru yada 1 false ise yanlış yada 0 gibi algılanır.
Char :ASCII karakterler ve küçük sayma sayılarını tanımlamak için kullanılır.
Int :Sayma sayılarını tanımlamak için kullanılır.
Long :Int gibi Sayma sayılarını tanımlamak için kullanılır.
Float :Ondalıklı (virgül ile ayrılmış) sayıların tanımlanmasında kullanılır.
Enum :Sıralanmış değerlerin tanımlanmasında kullanılır.
Double :Ondalıklı sayılar için kullanılır.
Void : Değer almamış
Long Double : Ondalıklı sayılar

Veri Tipi Uzunlukları

Bool : 0 <-> 1
Char : -128 <-> 127
Enum : -2,147,483,648 <-> 2,147,483,647
Int : -2,147,483,648 <-> 2,147,483,647
Long : -2,147,483,648 <-> 2,147,483,647
Float : 3.4E +/- 38
Double : 1.7E +/- 308
Long Double : 1.2E +/- 4932

Unsigned Değer :

Unsigned veri tiplerine işaretsiz değer atanmasında kullanılır, Unsigned değer atandığında tipin negatif değerleri atılır ve pozitif değerlere eklenir örneğin Unsigned Char 0-255 arasında bir değer alacaktır Char' ın pozitif alacağı değer 127 olmasına rağmen Unsigned tanımlandığında negatif kısım pozitif deer aralığına eklenir.

Değişkenler
C++ de değişken tanımlama : C++ de değişken tanımlama değişkenin tipi ve adının belirtilmesiyle yapılır.


[Atanan Veri Tip] [Değişken Adı];

Örnek : diyelimki girdiğimiz sayısal değeri tutacak bir değişken tanımlamamız gerekiyor bu durumda tanımlamamız şu şekilde olmalı :

int sayi;
buradaki örnekte sayi adıyla bir değişken tanımladık ve bu değişkenin tipi olarak int 'verdik artık sayi değişkenine int tipinin izin veridiği büyüklükte sayıal değer atanabilir.

Örnekler :

int rakam;
int no;
char isim;

tanımlamadan sonra ";" ün eklendiğine dikkat edin, bu konuya ilerki bölümlerde yer verilecek.


Değişken tanımlarken nelere dikkat etmeliyiz?

Öncelikle C++ (veya C) dilleri büyük küçük harf duyarlıdır yani "c" ve "C" harfleri iki farklı şekilde algılanır değişken tanımlanırken bu ayrıntı gözden kaçırılmamalıdır,

Aşağıdaki örnekerde verilen değişken tanımlamaları birbirinden farklıdır :

int c;
int C;
int Sayi;
int sayi;
char S;
char s;

Değişkenler tanımlanırken boşluk karakteri kullanılmaz ve mutlaka değişken adı harf yada "_" karakteri ile başlamalıdır, harf yada _ karakteriyle başlayan değişkenlerin geri kalan kısmı alfa sayısal yada sayısal karakter olabilir ancak değişken isimlerinde işlem operatörleri kullanılamaz.

Değişkenlere değer atama işlemi = operatörü ile yapılır, değişkene değer atama işlemini istersek tanımlama esnasında yapabilir yada tanımlamadan sonra değer atayabiliriz.

Tanımlama Sırasında Değer Atama için Örnekler :

Int Sayi = 1000;
Char isim = "Veli";

Tanımlamadan sonra değer atama:

Sayi = 1000;
isim = "Veli";

Eğer istersek aynı anda aynı tipte birden fazla değişken tanımlayabilir hatta bu değişkenlere aynı anda değer atayabiliriz.

int sayi1,sayi2,sayi3;
sayi1=sayi2=sayi3=1000;

yukarıdaki tanımlamada 3 ayrı değişken tanımlanıp her 3 değişkenede 1000 değeri atandı.

C++' de Açıklama Ekleme

İyi bir programcı başarılı programlar üretmenin yanında düzenli ve yığın oluşturmamış kodlama sistemi kullanmayı bilmelidir, ayrıca kendi yazdığımız programı başka bir programcı kolaylıkla anlayabilmeli yada üzerinden uzun bir süre geçtikten sonra kendi yazdığımız program kodlarına baktığımızda hangi satırda ne işlem yaptırdığımızı anlayabilmeliyiz işte bu noktada program geliştirmenin en önemli unsurlarından biri olan Açıklamalar karşımıza çıkar , Açıklama program kod kısmında bize açıklayıcı bilgiler verir daha sonra kodu tekrar açıp düzenlemek istediğimizde bu açıklamalardan yararlanırız.

Açıklamalar Nasıl Kullanılır

C++ editörü açıklama metinlerini iki ayrı şekilde alayabilir, ilk kullanım C den hatırladığımız // açıklama aracıdır, C++ // işaretlerinden sonraki bütün yazılanları satır boyunca açıklama olarak anlar ve kod icrasında bu yazılanları yok sayar.

Örnek :

// C++ da açıklama örneğidir, bu bölüm C++derleyicisi tarafından icra edilmez

İkinci kullanım ise C++ ye özgü olan /* ve */ karakterleri arasında açıklama belirtme şeklidir. Bu şekilde bir açıklama /* karakteriyle başlar ve */ karakterlerini görene dek aıklama olarak algılanır ve program içerisinde icra edilmez.

Örnek:


/* C++ 'a özgü açıklama yapılmaktadır bu satırlar C++ tarafından icra edilmezler,
ayrı bir satıra geçilse bile bu satırlarda icra edilmezler
bu satırdan sonrası C++ derleyicisi tarafından icra edilir */

C++ Programlamaya giriş

Bir C++ programında olması gereken açıklamaların,tip tanımlamalarının ve değişken tanımlama kurallarının ne olduğunu öğrendik, artık ufakta olsa bir c++ programı yazma zamanı geldi, Şimdi öğrendiğimiz bütün bilgileri kullanarak ufak bir program yazalım.

editör kısmına aşağıdaki kodları yazın:

// Bu bizim ilk C++ programımız
/*Programımızın başında öncelikle kütüphane dosyamızı tanımlıyoruz..*/
#include "iostream.h"
void main( )
{
int deger = 10;
cout << deger << " değeri görüntülendi." << endl;
}




Ne Yaptık : Yukarıdaki ilk program deneyimimizde ilk defa farklı komutlar kullanarak gerçek bir program yazdık, bu program hiçbir işimize yaramaz ama öğrenmemiz açısından oldukça güzel bir örnek. şimdi bu programı satır satır açıklayalım :

İlk Satırda // karakterleriyle başlayarak bu satırın bir açıklama olduğunu C++ ye bildirdik böylece programımızın icrasında bu satır göz ardı edilecek.
İkinci satırda yine bir açıklama metni kullandık. ancak bu kez /* ve */ karakterlerini kullandık.

üçüncü satırda mutlaka C++ programlarında bulunması gereken kütüphane dosyası tanımını yaptık, Bu tanımlamayı yapmamızın nedeni C++ programlarında kullanılan fonksiyon ve veri tiplerinin tanımlı olduğu kütüphane dosyalarının programımızda kullanılmasıdır, eğer bu tanımlamayı yapmaz isek gerekli fonksiyonları kullanamayız ilerleyen bölümlerde çok farklı tanımlamalar göreceğiz.
Kütüphane tanımlamaları #include "[Kütüphane adı]" şeklinde yapılır

dördüncü satırda ilerde daha ayrıntılı göreceğimiz fonksyion tanımlama işlemi yapılıyor c kodları fonksiyonlardan oluşur yukarıda da main fonksiyonu ile program kodlarını yazmaya başlıyoruz.

beşinci satırda { karakteriyle fonksiyonu açıyoruz ve içerisine gerekli komutları yazıyoruz.
altıncı satırda deger adında bir int tipli değişken tanımlıyoruz ve bu değişkene 10 değerini atıyoruz.

yedinci satırda cout komutuyla ekrana bilgi yazdırıyoruz, cout komutundan sonra yazdığımz << karakterlerinden sonra gelen değişkenin değeri ekrana aktarılır, endl komutu ise satırın bittiğini derleyiciye söyler ve bir alt satıra geçilir.

en son satırda ise } karakteriyle fonksiyonumuz sonlanır.


Fonksiyonlar

Fonksiyonlar program içerisinde icra edilerek belli değerleri döndüren yada belli işlemleri yapan kod bloklarıdır, yukarıdaki örnekte main fonksiyonu bize bir mesaj iletmekle görevli bir fonksiyon olarak verildi çoğu zaman fonksiyonlar çok karmaşık sorgu ve dallanmalar içerebilir en basit anlatımla fonksiyon bir çok görevin icra edildiği kod bloklarının birleşmesidir. Eğer fonksiyon kullanmadan kod yazmaya çalışsaydık yazdığımız program çok karmaşık ve içinden çıkılamaz bir hal alırdı yukarıdaki örnekte çok kısa bir program yazdık oysa onbinlerce satırdan oluşan bir programda fonksiyonlar vazgeçilmez kodlama sistemidir. Program icrasında oluşacak hataları bulmak için Fonksiyonların kullanılması şarttır aksi alde bir hatanın nerede oluştuğunu bulmak saatlerimizi belkide günlerimizi alırdı.

Ayrıca fonksiyonlar sayesinde bir işlemin bir kaç defa tekrarlanmasında büyük rol üstlenirler bu kodların her defasında yeniden yazılmasındansa bir fonksiyonun gerektiğinde tekrar tekrar çağrılması daha mantıklıdır.

bir fonksiyonun yapısı aşağıdaki gibidir.

Değer_Tipi Fonksiyon_İsmi (Parametreler)
{
Tanımlama ve komutlar dizisi
}


Yukarıdaki anlatımda

Değer_Tipi : Fonksiyonlar kendilerinden istenilen işi bitirdiklerinde bir değer döndürürler, geri dönen değer burada tanımlanan tipte bir değerdir.
Fonksiyon_İsmi : Tanımlanan her fonksiyon bir isim almalıdır başka bir kod bloğundan bu fonksiyonun çağrılması için fonksiyonun ismi kullanılır
Parametreler : Fonksiyonun icrası sırasında bazı parametreler gönderilebilir, fonksiyon içindeki bazı değişkenler bu parametrelere atanabilir ancak parametre atamak zorunlu değildir, ilerki bölümlerde bu konu ayrıntılı ele alınacaktır


al7nt7

[red_hacker]

TEMEL BILGILER



C++ bilindigi gibi programlama dünyasinda en çok ilgi gören C dilinden türemistir. C++'i klasik C dilinden farkli yapan yani; Nesne Yönelimli Programlamayi da ( Object Oriented Programming) C'nin sözdizimi kurallariyla birlikte desteklemesidir. Normalde C ile sadece yapisal programlama yaparken C++ dili ile hem yapisal hem de nesne yönelimli programlar yazabilirisiniz. C++ diline baslarken önce dilin C'den gelen ve temel olan özelliklerini ögrenmek gerekir. Örnegin, degisken tanimlama, atama ve diger basit aritmektik islemler, kontrol yapilari ve döngüler gibi.

Teknolojinin ulastigi son noktadaki programlama dillerinden olan C ve C++, bir çok yeni ve güçlü özellikleri içerir. Derslerimiz devam ettikçe bunlarin teker teker içine girecegiz. C dilinin özelliklerinin %80 i C++'da da mevcuttur (bu karsilastirma sahsi görüsümdür). Zaten C++, C'nin üst gurubudur. Bunu söyle siralayabiliriz. C, C++ ve C# dir.

C dilinin avantajlari, az komut kümesinden olusmasi ve bu komutlarin diger yüksek seviyeli dillere nazaran daha hizli çalismasidir. Ayrica C deki kütüphaneler sayesinde fonksiyon tanimlamaniza gerek kalmadan islemlerinizi yapmak mümkün olacaktir. Bu konuda çok detaya inmeden, programlamaya geçmek istiyorum. Çünkü, programlamaya basladigimizda her örnekten sonra o an kullandigimiz programin içinde geçen fonksiyon, hata, degisken, belirleyiciler, kisitlamalar, notasyonlar v.s gibi bilgilerden ara ara bahsedecegim. Yalniz çok önemli olan bir konuya burada deginmek istiyorum. C nin avantajlarini programlamayla birlikte görmek güzel ama C nin dezavantajlarini programlamadan önce bilmeliyiz ki bunlardan sakinalim. Öncelikle Tanimlayicilardan bahsetmek istiyorum. Her derleyici ve assmbley için degiskenleri, sabitleri, etiketleri ve fonksiyon adlarini tanimlama kurallari vardir. Bu notasyonlara, tanimlayici denir. C++ da tüm tanimlayicilar a, . . . , z - A, . . . , Z harfleri ile ya da alt çizgi "_" ile baslar. Bundan sonra rakam, harf, ya da alt çizgi kullanilabilir. ANCI C uyumlu derleyiciler 31 karaktere kadar tanimlayici kabul ederler fakat tanimlayicinin ilk sekiz karakterini kullanmayi kendimize aliskanlik etmeliyiz. Dikkat etmemiz gereken özelliklerden biri de kullandigimiz ifadelerdeki büyük küçük harflerdir. C ve C++ büyük ve küçük harf duyarliligina sahiptir. Kullandigimiz ifadeleri birbirinden farkli ve ayni ifade olarak kullaniyorsak programimiz hata verecektir. Bunu bir örnekle anlatayim:

Program
program
PROGRAM


Bu sekilde tanimlarsak hepsi birbirinden farkli ifadeler olarak C++ da okunacaktir. Biz Sunu aliskanlik edinmeliyiz; tanimlayicilarimizin bas harfi büyük olacak. Büyük ve küçük harf kombinasyonlarinin kullanilmasi ile önceden yapilan tanimlamalar bazen isi zorlastirabilir. Eger bu degiskenlerden birini kullanmak isterseniz, bu zamana kadar nasil tanimladiginizi bilmeniz gerekir. Örnegin printf()`in PRINTF() olarak çagrilmasi durumunda " bilinmeyen tanimlayici " (Unknown identifier) hata mesaji vererek sizi uyarir. Buna benzer olarak %f ve %F kullanimi hata verdirecektir. Programlamayi yaparken bunlara dikkat etmemiz gerekecek. Çünkü bir degiskeni veya tanimlayiciyi basta nasil kullandiysaniz üç, dört sayfa kod yazdiktan sonrada ayni sekliyle kullanmak zorundasinizdir. Iste burada en büyük handikap yasanacaktir. Çünkü C/C++ derleyicileri her zaman hatanin nerde oldugunu göstermez. Bunu programci kendisi satir satir takip ederek bulacaktir. Bundan dolayi bu söylediklerime bastan dikkat etmemiz gerekiyor.

[red_hacker]

Ilk programimiz!
// ilk1.cpp
// Ekrana "Bu benim ilk programim" yazdiriyoruz
#include <iostream.h>
int main()
{
cout << "Bu benim ilk programim";

return 0;
}
Simdi Yazdigimiz programi inceleyelim:
"//" isaretini açiklama satirlarinda kullaniyoruz. C++ derleyicisi bu notasyonla baslayan satiri okumaz. Bununla birlikte daha uzun cümlelerimiz olursa bunlari da " /* */ " notasyonunun içinde yazicagiz. Bu özellik de C den bize kalma. Demistik zaten C `nin tüm özelliklerini C++ içerir. Fakat biz genelde " // " yi kullanacagiz.

#include : Bu bizim C++ da bulunan kütüphane dosyamizi çagirmaya yariyor. Ben size söyle tarif edeyim. iostream.h kütüphanesindeki hazir olan " cout " fonksiyonunu çagiriyor. Yani buda bizim fazla kod yazmamiza engel oluyor. .h ile biten dosyalar kütüphane dosyalaridir. Bunu suna da benzetebiliriz. Farz edelim ki elimizde bir alet çantasi var içinden tornavidayi çagirdigimizda vida sikacagizdir. Bu da ona benziyor. C++ da ki hazir kütüphanelerde bir çok hazir fonksiyonlar vardir. Ilerde Bu hazir fonksiyonlar isimizi görmemeye baslayinca kendi kütüphanemizi yapmaya baslayacagiz. Tabi bu seviyeye geldigimizde olayi hemen hemen kavramis olacagiz, tabi neden olmasin öyle degil mi?

Daha sonraki satir her C++ programinda mutlaka bulunmasi gereken bir satirdir. Her C++ programinda main() fonksiyonu olmak zorundadir; bu fonksiyonumuzun önünde ise o fonksiyonun dönderdigi degiskenin veri tipi olmalidir. Tabi ki C++ fonksiyonlar ve onlarin dönderdikleri degerler konusunu da ileride isleyecegiz.

Bir sonraki satirda ise; C++ fonksiyonlar ve kod bloklari " { } " parantezleri arasinda bulunmalidir. main de bir fonksiyon ise onun içindeki kodlar dogal olarak { } parantezleri arasindadir.

Program derlenip çalistirildiginda ise ( Turbo C++ 3.1 kullaniyorsaniz ctrl+f9 kisa yoluyla programi çalistirabilirsiniz (Run) ) karsimiza "Bu benim ilk programim" yazisi çikacaktir. Iste bu yaziyi ekrana veren komut da iostream.h kütüphanesindeki cout fonksiyonudur.

Önemli bir nokta ise C++ dilinde her satir ifadenin sonuna " ; " koymak zorundayiz. Bundan farkli olarak #include satirlarinin ve bir kaç farkli satirin arkasina " ; " gelmez. Bunlari ileride görecegiz.

Return 0 : programimizin (ayni zamanda main fonksiyonumuzun) çikis noktasidir. Eger return ile 0 degeri dönderirsek programimizin güvenle çiktigini isletim sistemine bildirmis oluruz. Bu sayede güvenle programimizin çalistigini görecegiz.

Simdi size bir örnek daha verecegim bununla da ayni çiktiyi elde edecegiz. Arasindaki farklari eminim basit olarak sizlerde göreceksinizdir.



Sor:
// ilk2.cpp
// Ekrana "Bu benim ilk programim" yazdiriyoruz
#include <stdio.h>
main()
{
printf("Selam bu benim ilk programim.\n");
return 0;
}



Evet simdi burada çok fark varmis gibi gözüküyor aslinda ama öyle degil. Sadece kütüphanemiz stdio.h oldu ve ekrana yazdir fonksiyonumuzda printf oldu. Bu özellik C den kalma. Bunlar diger program ile ayni islevi görüyor. Buradaki fark " \n " notasyonu. Bu notasyon bir sonraki satira geçmek için kullanilir.

[red_hacker]

Simdi bize yine çok lazim olacak bir özellik de degisken tanimlamak ve atama yapmaktir. Bunu bir örnek üzerinde anlatmak istiyorum. Örnegimiz;




Sor:
// degisken.cpp
// Burda degisken tanimlamayi görecegiz.
// Ayni zamanda verilen bir sayiyi kendisi ile carpma 2.2=4 gibi

#include <iostream.h>
#include <stdio.h> // kütüphane dosyamiz
main()
{
int i; // Degisken tanimlama
cout << "Bir sayi giriniz: ";
cin >> i;
i=i*i;
cout << "sonuc: " << i ;
return 0;
}





Burada bundan önce yaptigimiz programlardan farkli olarak int i kullandik, yani degisken tanimladik.

Degisken Nasil Tanimlanir?

Degiskenleri tanimlamak için asagidaki sema kullanilir.

[Veri Tipi] [Degisken Adi];

Örnegin
int sayi;
Simdi degisken.cpp örnegindeki int i; kismini anlamissinizdir. Burada degiskenlere deginmek istiyorum. Biz yukarda Içinde sayi tutan bir degiskeni tanimladik. Benzer olarak asagidaki tanimlamalar da vardir.

char c;
int i;
float f;
double d;
unsigned int ui;

Burada [Veri Tipi] [Degisken Adi]; bu kaliba göre tanimlama yaptigimiz için önce Veri Tiplerini inceleyelim.

[red_hacker]

1) Int tip.

Integer = Tamsayi

Tamsayilari içerir. Bellekte 2 Byte tutar. DOS'ta ve Win3.1'de 16 bit uzunlugunda ama Windows9x, WinNT, Win200 ve WinXP 32 bit uzunlugundadir.

Deger araliklari Short ve long için degisir.

Örnek: 5, -20, 1 gibi.

2) Sort tip.

Tam sayilari içerir. 16 bit uzunlugundadir.

signed: -32768 ile +32767 arasinda deger alir, unsigned: 0 ile 65535 arasinda deger alir.

3) Long tip.

Tam sayilar içerir. 32 bit uzunlugundadir.

signed: -2147483648 ile +2177483647 arasinda deger alir, unsigned: 0 ile 65535 arasinda deger alir.

4) Gerçel Tipler (Float, Double, Long double

Gerçel sayilari içerirler.

float : Bellekte 4 Byte yer tutar. 3.4E-38 ile 3.4E+38 araliginda deger alir. Hassasiyet 7-8 basamaktir.

double : Bellekte 8 Byte ter tutar. 1.7E-308 ile 1.7E308 araliginda deger alir. Hassasiyet 15-16 basamaktir.

long double : doublenin tipinin daha genisidir.1.2E-4932 ile 1.2E-4932 araliginda deger alir. Hassasiyet 19-20 basamak.

5) Char Tip

Char : Karakter

Alfanumerik karakterleri içerir. Ve ya 8 bit uzunlugunda tamsayi.

signed: -128 ile 127 arasinda deger alir, unsigned: 0 ile 255 arasinda deger alir.

Örnegin: ' 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 degerini alir. Eski derleyiciler bu türü desteklemeyebilir. Yeni ANSI C++ standardinda eklenmistir. Bu soyut matematik gördüyseniz. "p V q" ya benzer ( matematikçiyiz, konusturalim azicik). Deger araligi ise ya 1 dir (dogru) yada 0 dir (yanlis).

7) Enum tip.

enum siralanmis degerleri tutar. Short int ile ayni degeri tasir.

Basta Fazla Detaya inip sizi bunaltmak istemiyorum. Çünkü C++ dili baslarda karmasik gelen bir dildir. Bu da zaten kendisini yüksek seviyeli bir dil yapiyor . Ben size Bu dilin temel özelliklerini anlatarak basit programlar yapmayi gösterecegim.

Bu temel bilgileri aldiktan sonra programlamaya geçebiliriz. Derleyici Olarak ben Turbo C++ 3.1 i tavsiye ederim. Su an bununla baslar iseniz isiniz daha kolay olacaktir (bence). Ilerde Borland a geçecegiz.

Degisken tanimlama konusunda bir konuya daha deginmek istiyorum. Degiskenlere deger atama ve ayni anda bir çok degisken tanimlamamiz C++ da mümkündür.

char c = 'c';
int i = 5;

Daha sonradan deger atama:

char c;
int i;
c = 'c ';
i = 5;


Bir de ayni anda bir çok degisken tanimlayalim.

Örnegin:
int x , y , z;
x = y = z = 5;
x,y,z' nin degeri 5 oldu


Bir sonraki derste ise degiskenlerle birlikte bir de Operatörleri ele alacagiz.

[red_hacker]

Bunu bir örnek üzerinde anlatmak istiyorum. Örnegin; x + y ''de x ve y operand + ise operatördür. Bu bir aritmetiksel operatördür. Matematikte islemler operatörler ve operandlar ile anlatilir.

Operatörleri öncelikle türlerine göre ayiralim:

1) Aritmetiksel operatörler + , - , * , / , % , ++ , --

2) Karsilastirma operatörleri < , > , <=, >= , ==, !=

3) Esitleme operatörleri = , += , -=, *= , /= , %= , <=, >>=, &=, != , ^=

4) Mantiksal Operatörler ! , || , &&

5) Bit bazinda islem yapan operatörler & , ! , ^ , ~ ,

Aritmetiksel (Matematiksel) Operatörler:
Matematiksel ifadeleri günlük hayattaki biçimde bilgisayarda yazamadigimiz için belli kurallara uymamiz gerekir. Bu kisim önemli oldugu için biraz genis yer verecegim. Kullandigimiz matematiksel islemler ve anlamlari söyledir:

C++ islemi: Aritmetik operatör:
Toplama +
Çikarma -
Çarpma *
Bölme /
Modulus(mod) %
Bir arttirma ++
Bir azaltma --





Bu operatörle verilen iki veya daha fazla operand toplanabilir. Yazilis sekli Asagidaki gibidir.

degisken1 + degisken2

Eger bu iki degiskeni Sonuç gibi baska bir degiskene atarsak esitleme operatörüyle asagidaki gibi yapariz.

Sonuç = degisken1 + degisken2

Buna bir örnek verelim.


Sor:
// toplama.cpp
//Vize ve final notlarinindan geçme notunu hesaplama

#include <iostream.h>
#include <math.h>

main()
{
int vize, final, ort;
vize = 10;
final = 80;
ort = vize * 0.4 + final * 0.6;
cout<< "Geçme notunuz: " << ort;
}



Burada çarpma operatörünü de kullandik sanirim, artik digerlerinin de ne oldugunu kavramis oldunuz. Bir örnekte isi ucuza getirdim . Fakat bir artma ve bir azalmaya örnek verelim. Bu bana çok lazim olmustu.

Burada dikkat etmemiz gereken olay " ++ " operatörünü degiskenin önüne yazmaniz gerektigidir. Bu sayede degisken bir arttirilarak isleme konur. Arkasina konursa degisken islenir, sonra bir arttirilir. " -- " operatöründe ise ayni sekilde de bir azaltma yapilir.



Sor:
// carpim.cpp
// x i bir arttirip y yi bir azaltip çarptik.

#include <iostream.h>

main()
{
int x = 5;
int y = 10;
cout << "x = " <<x << endl;
cout << "y = " << y << endl;

cout <<"++x * --y = " << ++x * --y ;

}



Iste bir fark daha yakaladik bunu da hemen örnek üzerinde anlatalim. Sanirim buraya kadar geldigimiz yerlerde int i , çarpma islemini, bir arttirip azaltmayi gördük, ama diyeceksiniz ki " endl " ne oluyor? Hemen açiklayayim; Satir sonunu belirterek yeni satira geçmemizi saglar, bir nevi " \n " Escape operatörü gibi bir isleve sahiptir.

Karsilastirma Operatörleri:
Operatör C++ örnegi Anlami
> x > y x, y'den büyüktür
< x < y x, y'den küçüktür
>= x >= y x, y'den büyüktür veya y'ye esittir
<= x <= y x, y'den küçüktür veya y`ye esittir
== x ==y x, y'ye esittir
!= x != y x, y'ye esit degildir


Bunlarin teker teker ne oldugunu söylemeye gerek yok. Ifadeler gayet basittir. Burada dikkat etmemiz gereken önemli bir sey var: " >=, <=, ==, !=" notasyonlarini kullanirken iki notasyon arasinda bosluk birakmamaliyiz. Buna dikkat edelim!

Esitleme ( Atama) Operatörleri:
Bunlarida liste halinda verelim.

Operatör C++ örnegi Anlami
= x = y x`in degeri y'ninkine atanir
+= x += y x`e x+y'nin degeri atanir.
-= x -= y x`e x-y`nin degeri atanir.
*= x *= y x`e x*y'nin degeri atanir.
/= x /= y x`e x/y`nin degeri atanir
%= x %= y x`e x%y'nin degeri atanir.
<<= x <<= y x`e x<<y'nin degeri atanir.
>>= x >>= y x`e x>>y'nin degeri atanir.
&= x &= y x`e x&y'nin degeri atanir.
!= x != y x`e x!y'nin degeri atanir.
^= x ^= y x`e x^y'nin degeri atanir.

[red_hacker]

if komutu anlasilmasi ve yazilimi en basit olanidir. if komutu, bir grup komutun kosullu olarak yürütülmesi amaciyla kullanilir. Buna bir örnek verecek olursak; düsünün ki bir sinav yapiliyor ve 50 ve üzeri alanlar geçecek. Bunun için if i kullanirsak not 50 ye esit veya büyükse (büyük esit) geçer not olacak.



Sor:
//not.cpp
// 50 ve 50 den yukarsi geçiyor.
#include <iostream.h>

main()
{
int not;
cout << "Notu yaziniz:";
cin >> not;

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

}



Sanirim bu örnekte ne dedigimi anlamis olacaksiniz.





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

if (ifade)
{
Komut;
Komut;
...
}





Burda görüldügü gibi if (ifade) ve sonraki komutlarda { } blogunun içine yazilir. Simdi if`e bir de su açidan yaklasalim. if in kelime anlami "eger" dir. Mantik sudur: eger belirtilen parametre dogruysa, if komutu, if ten sonra gelen bloktaki fonksiyonlari gerçeklestirir. Dogru degilse, if den sonraki blogu yok sayar. Burada bir detaya daha inmek istiyorum. Ne demistik, mantik islemlerinde olay ya dogrudur (1) ya da yanlistir (0). Simdi yukaridaki if in genel kullanim sekline tekrar bakalim. Bunu, eger parametre dogru ise kullanabiliriz. Bir de bunun tersini düsünelim. Bit bazinda islemlerde sanirim ( ! ) bunu görmüstük. Her bir biti ters çevirir.




Sor:
if (!ifade)
{
komut (yanlis (0));
Komut (yanlis (0));
....}






Derdimi anlamis oldugunuzu ümit ediyorum . Ama bence buranin üstünde biraz daha duralim. Çünkü bunu anlarsak digerlerinde zorlanmayiz. Son yaptigimizda ifadeyi tersine çevirdik.




Sor:
//pozitif.cpp
// Bunada açiklama yaptirmayin ( yapamadimda)
#include <iostream.h>
main()
{
int x;
cout << "Bir sayi girin:" ;
cin>> x;
if ( x > 0 )
cout << "Pozitif" ;
}





Aynisinin negatif ini de siz yapin. Simdi bir de iç içe if örnegine bakalim:



Sor:
//gecti.cpp
// Buna açiklama yapmiycam!
#include <iostream.h>
main()
{
int not;
cout << "Notunuzu giriniz:";
cin >> not;
if ( not> 50)
cout << "Geçtiniz!" ;
if (not < 50)
cout << "Kaldiniz!" ;
if ( not==50)
cout << "zar zor geçtin ";
}




Anlamis oldugunuzu umut ederek if komutunu burada bitiriyorum.

[red_hacker]

if-else komutu iki islemden hangisinin uygulanacagina karar verir. Else kismi seçimlidir, gerekmiyorsa kullanilmayabilir. Yazilim kurali ile söyledir;




Sor:
if ( ifade)
komut1;
else
komut2;
daha genel sekliyle

if ( ifade )
{
komut1;
komut2;
...
}
else
{
komut1;
komut2;
...
}



Veya lojik olarak baktigimizda sanirim daha iyi anlayacaksiniz




Sor:
if (ifade)
blok_dogru (1);
else
blok_yanlis (0);



Sanirim artik açiklama yapmama gerek kalmayacak. Simdi örneklerle bunu pekistirmeye çalisalim.




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





Bir örnek daha verelim:



Sor:
//ifelse.cpp
#include <iostream.h>
main()
{
int not;
cout<< "Notu giriniz:";
cin >> not;
if (not >= 50)
cout << "Geçti!";
else
cout << "Kaldi!";
}




if kismindan anlatmaya baslayacagim. Eger notumuz 50 ye esit veya 50 den büyük ise geçiyoruz aksi halde kaliyoruz.

Bir de bir if-else in altinda bir tane daha if-else kullanalim.




Sor:
//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 alinan not:";
cin >>not;
if( not>=60 )
cout << "Geçtiniz!";
else
cout <<"Kaldiniz!";

}
}





Burada da sunu inceledik: diyelim ki sinava girdik ve notumuzu ögrendik, notu giriyoruz 50 nin altindaysa kaliyoruz. ve bütünleme sinavina giriyoruz. Bütte de geçer not en az 60. Sanirim bu basit örneklerle olayi iyice kavramisizdir. if-else i de burada bitiriyoruz.

[red_hacker]

Bu komut, yalnizca C++ a özgüdür. Kendine özgü bir yazilimi ve mantiksal kullanimi vardir. if-else komutunun kisaltilmisidir. Fakat, tüm if-else komutlari yerine kullanilmaz. Yalnizca karsilastirma sonrasi, tek komut kullanilan uygulamalar için geçerlidir. Bu söylediklerimizi örnek üstünde gösterelim:




Sor:
//tekcift.cpp
//tekcift.cpp yi bu sefer ?: ile yapiyoruz
#include <iostream.h>
main()
{
int sayi;
cout<< "Bir sayi giriniz:";
cin >> sayi;
cout << (sayi %2==1 ? "tek" : "çift") ;
}




Kullanis biçimi: cout << (sayi %2==1 ? "tek" : "çift") ; çok basit ama dikkat edelim. Her zaman kullanmiyoruz.

[red_hacker]

Switch Case deyimi islev bakimindan if deyimine çok benzemektedir. Çok sayida if islem bloklari kullandigimizda programin okunurlugu azalacak ve programi izlemek zorlasacaktir. Programimizin bir degerini bir çok degerle karsilastirmak gerektiginde switch komutunu kullanacagiz. Switch seçenegi ile degiskenin durumuna göre bir çok durum içersinden bir tanesi gerçeklestirilir. Istersek de if deyimi ile switch case'' yi birlikte kullanabiliriz. Switch in yaptigi is kisaca, ifadenin degerini sirayla sabitlerle karsilastirarak ve her satiri islemektir.




Sor:
switch( Kontrol Degiskeni )
{
case Sabit1 : komut1;
case Sabit2 : komut2;
.
.
.
default : Komutson;
}





Buna en basit örnegimizi verelim




Sor:
//switch.cpp
// switch-case yi ögreniyoruz.

#include <iostream.h>

main()
{
int i;
cout<< " 1 ile 4 arasi sir sayi 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 farkli";
}
}




Burada gördügümüz gibi i degiskenine bagli olarak program isliyor. Case''lerinin aldigi degere göre kendinden sonra gelen komutlari isliyorlar. Burada daha önce görmedigimiz break komutunu gördük. Buna ilerde daha detayli olarak deginecegim. Fakat biraz bahsetmek istiyorum. Programimizda degiskene 1 degerini verdigimizi farz edelim. Case 1 adli satiri geçip ondan sonraki komut dizisini isleme soktuk. Bu islemin tamamlanmasi için break komutu kullaniliyor. Yazilimda break komutu goto gibi islev görür ve derleyiciye switch komutundan çikmasi için talimat verir. Sorunu ortadan kaldirmak için her durum için break deyimi eklemeliyiz (tavsiye). Ne demistik; bir çok karsilastirma oldugunda switch''e ihtiyaç duyuyoruz. Karsilastirmalarin hiç biri olmadigi anda da ortaya default tan sonraki satirin islenmesi kaliyor. Sanirim bu örnekte basit olarak anlamis olacagiz.

Daha karmasik bir örnek verecek olursak:




Sor:
//ucgen.cpp
// Program girecegimiz ölçülere göre üçgenin Alan, Yükseklik ve Tabanini bulur
// switch-case örnegimiz.

#include <iostream.h>

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

cout << "Program girecegimiz ölçülere göre üçgen''in Alan,
Yükseklik ve Tabanini bulur!\n" << endl
<< " A ---> Alan : Bulmak için yükseklik ve tabani girecegiz:" << endl
<< " h ---> Yükseklik : Bulmak için alan ve tabani girecegiz:" << endl
<< " t ---> Taban : Bulmak için alan ve yüksekligi girecegiz:" << endl
<< endl << endl;
cout<< "Seçeneginiz? ---> 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 << "Alani: " << alan << endl;

break;
}

case ''h'':
case ''H'':
{
cout<< endl << endl <<"Alani: ";
cin>> alan;
cout<<endl << "Tanabi: ";
cin >> taban;

yukseklik = 2.0 * alan / taban;

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

case ''t'':
case ''T'':
{
cout << endl <<endl <<"Alani: ";
cin >> alan;
cout << endl << "Yüksekligi: ";
cin >> yukseklik;

taban = 2.0 * yukseklik / alan;

cout << endl << endl <<"Tabani: " << taban << endl;
break;
}
}
return 0;
}





Gayet basit bir örnek degiskenleri tanimladik. Caseleri koyduk ve caselerden sonra gelecek komut satirlarini yerlestirdik. Bu program göründügü gibi zor degildir.

[red_hacker]

Içlerinde anlatimi ve anlasilmasi en kolay olan döngüdür. While döngüsü, döngü sayisinin belli olmadigi zamanlarda kullanilir.

while ( kosul )
Komut;
While döngüsü, içinde bulunan ifade dogru oldugu sürece altindaki komut veya komut blogu yürütülür. Eger yanlis ise kontrol bir sonraki komut veya komut bloguna geçer.

While döngüsü daha genel sekliyle




Sor:
while ( ifade )
{
komut;
komut;
komut;
.
.
.
}





Burada bir seye dikkat etmenizi istiyorum. Çoklu komutlar kullandigimizda " { } "parantezleri gereklidir.



Sor:
// while1.cpp
// while döngüsünü kullandik
// girdigimiz sayidan 100 e kadar olan sayilari topladik

#include <iostream.h>

main()
{
int x, y;
y= 0;
cout<< " Bir Sayi Giriniz ( Sayi 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 tanimladik. y=0 degerini verdik. Sonra klavyeden girilen degerin x oldugunu yazdik. while (x< 101) iste burada ifademiz x< 101. Simdi bu kosul saglanincaya kadar döngümüz devam edecek. While'' den sonraki bloga geçtigimizde ise. y` ye x i ekliyoruz ve x in degerini her seferinde 1 arttiriyoruz. Sanirim bu basit örnekte döngünün basit yapisini ve mantigini anlamis oldunuz.

Döngünün verilen ifade veya kosula göre saglanmasi döngülerin en önemli konusudur. Eger bir döngüden çikilmazsa o döngü sonsuza gider. Buna da "sonsuz döngü" denir. Döngüler konusunda en çok rastlayacagimiz hata da budur.Simdi buna bir örnek verelim. Fakat, simdiden uyariyorum, sonsuz döngü yapildiginda bilgisayariniz kilitlenebilir. Onun için buna simdiden hazir olun. Zaten bir sefer denedigimizde ne demek istedigimi anlayacaksinizdir.




Sor:
//sonsuz.cpp
//while döngüsü ile sonsuz bir döngü yaptik

#include <iostream.h>

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

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

}





Burada neden sonsuz bir döngü oldu? Evet iste x ifadesini kosula baglamadik. Sayet while(x<10) demis olsaydik. 1,2,3,4,5,6,7,8,9 a kadar x sayisi siralanacakti.




Sor:
//klavye.cpp
//while döngüsü ile klavyeden girilen sayi

#include <iostream.h>

main()
{
int x, y = 0;

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





Bu programda da klavyeden girilen sayilarin toplami 20'' den büyük olunca program Toplam olarak söylüyor. Sanirim basit While yapisini anladiniz. Simdi birazda karmasik programciklar yapalim.

1. Örnek: Girilen alti not''un ortalamasini aliyor.




Sor:
//ortalama.cpp
// while döngüsü ile girilen notlarin ortalamasini aldik.


#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 << "Sinif ortalamasi = " << ortalama << endl;

return 0;

}





Bu örnegimizde yine toplam, sayac, not, ortalama gibi degiskenleri tanimladik. ( toplam =0 ; ve sayac = 1; ) de degiskenlere ilk degerlerini atadik. While döngüsünün içinde sayac degiskenimizi alti defa islemesini söyledik. Sonra alttaki toplam ve sayac bölümlerinde ise toplam a not'' u ekliyoruz, her seferinde de sayac degerini bir arttiriyoruz ve sayac degeri 6'' ya gelince while döngümüz duruyor. Program sonra toplami alip altiya böler bu sayede ortalamayi alir, sonrada çiktisini gerçeklestirir.

2. Örnek:




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

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

cout << faktoriyel << endl;
return 0;
}





Burda while (sayi>1) seklinde kosulumuzu belirttik. Bir altinda ise faktoriyel *= sayi--; evet burda da daha önce gördügümüz gibi esitleme operatörü olan ( *= ) i kullandik. Yani faktoriyel''e faktoriyel*sayi-- nin degeri atanir. Matematigini düsünürseniz; 7 sayisinin faktöriyeli 7 *= 7-- gibi. yani 7 ye devamli 7-- oda 6 demektir. 6 ile carpimi eklenir, bu 6-- ile devam eder. En basit anlatimi bu Sonrada tüm while döngüsü bittikten sonrada faktoriyel'' in sonucu çikti olarak ekrana gelir. Bu örnekte negatif sayilarin faktöriyelini de 1''e esit tutuyor. Dikkat ediniz. Negatif sayilarin faktöriyeli alinmaz sartini koymadik. Sayet siz koymak isterseniz bir if else blogu yerlestirmelisiniz if(sayi>=0) faktoriyel al yoksa faktoriyel alma gibi.

3. Örnek:




Sor:
// maas.cpp
// while if-else ile bir maas vergi uygulamasi


#include <iostream.h>

int main( )
{
unsigned long maas, net, vergi = 0.0; // maas net vergi bunlari tanimladik

cout<< "Lütfen maasinizi giriniz: "; // maasi giriyoruz
cin>> maas; // maasi programa aliyoruz

while( maas >= 0.0 ) // maasin koslunu yaziyorus döngüye
{
if( maas <= 250000000 ) // maas 250 milyondan az ise
vergi = 0.0;
else // vergi yok
if( maas < 500000000 ) // maas 500 den az ise
vergi = maas * 0.10; // vergi %10
else // 500 den fazla ise
vergi = maas * 0.20; // vergi %20

net = maas - vergi; // net maasimiz vergi düsünce çikar
cout<< "Ödenmesi Gereken vergi " << vergi << endl; // vergi ekranda
cout<< "Net maasiniz: " << net << endl; // geriye kalan maasimiz


cout<< "Lütfen maasinizi giriniz: "; // bir dahaki ayki yeni maasimiz
cin>> maas; // maasi program aliyor

}
return 1;

}





Bu örnekte sanirim fazla açiklama yok. Sizden istedigim, üç kisinin maasini girdikten sonra onlarin alacagi toplam maas ve ödemeleri gereken toplam vergiyi bulmaniz. Bunu yaparsaniz buraya kadar olanlardan bir seyler anlamisizdir.

[red_hacker]

Bu döngü while döngüsünün biraz degistirilmis halidir. Do-while döngüsünde karsilastirma islemi, döngünün sonunda gerçeklesir. Bunun sonucu olarak döngünün içine en az bir defa girilmis olur. Yapisi asagidaki gibidir.



Sor:
do

cümle

while ( kosul );






do'' nun altindaki cümle kismindaki komut satirlari birden fazla olursa diger döngülerde oldugu gibi " { } " içine aliyoruz. Bunu kullanmamiz kodlari okuma da ve ayirma da daha çok isimize yarayacaktir.




Sor:
do
{
cümle
cümle
cümle
...
}
while ( kosul );





Simdi yukarida demek istedigimizi standart kod satiri üzerinde anlatalim. Kodlari yazdigimizda, komut sirasi do''ya geldigi zaman, do'' dan sonraki komutun döngünün basi oldugunu belirtiyor. Digerlerinden farkli ( for, While ) olarak döngüye giris yapiyor, yani hiçbir kontrol yapmadan en az bir defa döngünün içine girmis oluyoruz. While''e geldiginde ise kosulu kontrol ediyor, eger dogru ise döngünün basindaki komuta giderek yeniden komutlari isliyor. Eger kosul kontrolü yanlis ise while''den bir sonra ki komutu veya komutlari isleyip döngüden çikiyor. Simdi bu söylediklerimizi örnek üzerinde gösterelim.




Sor:
//do.cpp
// number echoer
//do-while döngüsünü kullandik

#include <iostream.h>

int main ()
{
unsigned long x;
do {
cout<< "Bir sayi giriniz ( Durdurmak için 0 ) : ";
cin>> x;
cout<< "Girdiginiz sayi: " << x << "\n";
}
while (x != 0);
return 0;
}





Örnegimizde de görüldügü gibi önce do dan sonraki komutlar isleniyor. Sayet 0 girersek while islemeye basliyor. Do-while döngüsü C++ da çok fazla kullanilmaz bunun yerine biz for'' u kullanacagiz çünkü for döngüsü çok daha güçlüdür.

[red_hacker]

For döngüsünün çalismasi, döngünün kontrol degiskenine baslangiç degerinin atanmasi ile baslar. Asagida verecegimiz ilk deger atama cümlesinden kastimizda budur. Yani bu kisimda baslangiç tanimlari yapilir. For döngüsünün baslangiç adimidir. Bu kisimda yapilan bir degisken tanimindaki degiskenin ömrü, for döngüsünün sonunda biter. Sonra döngü kosul kismina gelinir ve bu test edilir. Sayet degeri !0, dogru (1) oldugunda döngü içindeki komutlar uygulanir. Arttirma ise for döngüsü isleminin sonunda meydana gelir. for içindeki tüm deyimler meydana geldikten sonra uygulanir.

Genel yapisi:

for ( ilk deger atamalar, kosul, arttirma)
cümle
Bunu daha da genellersek, digerlerinde de oldugu gibi cümleler birden fazla oldugunda komut blogu arasina alinacaktir.




Sor:
for ( ilk deger atamalar, kosul, arttirma)
{
cümle1
cümle2
cümle3
...
}



Bu söylediklerimizi bir örnek üzerinde izah edelim.




Sor:
//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 kismi anlatacagim, diger kisimlar apaçik gözüküyor zaten. For diyip () imizi açtik. Sonra içine ilk basamagimiz olan degisken tanimlamamizi yaptik. Int n=10; Bu bizim yukarida bahsettigimiz ilk deger atamalar kismi. Daha sonra kosulumuzu yazdik. n>0; bunu test ettik ve !0 yani dogru (1) çikti. Sonrada n-- yi yazdik. Genel tanimda yazdigimiz arttirma kismi. Aslinda buna yenileme komutlari desek daha dogru olur. Biz bu örnekte örnegin azaltma yaptik. Neyse umarim bu for örnegini anlamissinizdir.

C++ da yapacagimiz çogu örnekte for u kullanacagiz. C++ ''nin en güçlü yanlarindan biriside for döngüsüdür. For döngüsünün basinda yani ilk deger atama kisminda birden çok degisken tanimlayip deger atiyorsak bunlari virgül ( , ) ile bir birinden ayirmaliyiz. Ilk deger atamadan kosul bölümüne geçtigimizde ve kosul bölümünden arttirma ya geçerken noktali virgül ( ; ) kullanmaliyiz. Tabi kullandigimiz bu üç kisim seçimlidir istersek bos birakabiliriz. Fakat, noktali virgüller ( ; ) konulmasi zorunludur.

1.Örnegimiz:




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


#include <iostream.h>

int main()

{
int fac, sayi;

cout<<"Sayiyi giriniz: ";
cin>>sayi;
fac=1;

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

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

}





Bu örnegimiz oldukça basit. Bildigimiz matematiksel faktöriyel islemini C++ kodlari olarak yazdik. (\a yi kullandim bip! demesi için ).

2.Örnegimiz:




Sor:
//carpim_for.cpp
// iç içe for döngüsüyle çarpim tablosu


#include <iostream.h>


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




Görüldügü gibi ilk for döngüsünde, birinci bilesen olan x i önce 1 e esitledik sonra birer arttirarak 10'' a kadar götürdük. Sonraki for da da aynisini y için yaptik ve bu iki bileseni çarparak ekrana yazdirdik. Son derece basit bir örnek.

3.Örnegimiz:




Sor:
//asal_for.cpp
// for , if ve while ile asal sayi bulma

#include <iostream.h>

int main()
{
int sayi;
cout << "Bir sayi girinizr: ";
cin >> sayi;

for (int sayac=1; sayac< sayi; sayac++)
{
int asal, test;
test = sayac;
asal = 1;
while (test--> 2)
if ((sayac % test) == 0)
asal = 0;
if (asal == 1)
cout<< sayac << " bir asal sayidir!\n";
}
return 0;
}





Bu örnegimizde ikinci örnegimize benziyor. Içinde for, while ve if de var. While ve if'' in içindeki matematiksel ifadeleri biliyorsak örnek gayet basit gelicektir. Burada birakmak istiyorum. Bir sonraki ders görüsmek üzere.

[red_hacker]

BREAK
Break komutunu, swtich komutundan çikmak için önceki derslerimizde görmüstük. Komutun kendine özgü bir kullanimi daha vardir. Break komutu bir döngünün içinde çalistirilirsa o an o döngü biter. Bir goto gibi islem gördügünü de söyleyebiliriz. Break kullaninca program döngüyü bitirir ve döngünün sonundaki satirdan çalismaya devam eder. Bir örnek verelim.




Sor:
//break.cpp
//break komutunu kullandik.


#include <iostream.h>

main()

{

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






Iste örnegimizde gördügünüz gibi. X 7''ye esit olunca break; döngüyü bitiriyor ve döngüden sonraki satiri çalistirmaya basliyor.


EXIT

Hayati hata durumlarini ele almak için exit() fonksiyonundan yararlanilir. Bu hatalar main() fonksiyonunu return ile normal olarak sonlandirilmadan önce olusabilir. Exit() fonksiyonu, durum degerini bir tam sayi parametre olarak döndürür.

Exit() ile özel bir degerin gönderilmesi bazi islemler yapmasi için kullanilabilir. Örnegin program komut satirinda kullaniliyorsa ve durum degeri bazi hatalari gösteriyorsa, isletim sistemi bunlari mesaj olarak yazabilir. Exit() fonksiyonu programi sonlandirmanin yaninda, tüm bekleyen yazma islemlerini tamamlar ve açik tüm dosyalari kapatir.

Exit() fonksiyonunu kullanirken kullanmamiz gerek kütüphaneler ise process.h ve stdlib.h tir.

[red_hacker]

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

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.




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




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




Sor:
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 yaygin yapilan 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.

[red_hacker]

Diziler, "indisleri olan degiskenler" olarak adlandirilirlar. Diger bir deyisle, birden fazla tek düze veri tipi içeren degiskenlerdir. Diziler birbirine bitisik bellek gözleri kullanilarak olusturulurlar. Bunu biraz daha açarsak: farz edelim ki elimizde üç tane kutu var, birinde yesil kalemler, birinde kirmizi kalemler ve birinde de mavi kalemler olsun. Bu kutucuklari 1,2,3 diye adlandirdigimizi düsünelim. Biz diziler ile numarasini bildigimiz kutucugun içindeki malzemeyi alabilecegiz. Daha dogrusu numarasini vermis oldugumuz kutunun içindeki bilgiyi bilgisayar okuyacaktir.

Not: For döngüsü dizi elemanlarina ulasmak için en çok kullanilan yöntemdir.

Dizilerin indislerden olustugunu söylemistik. Diger yüksek seviyeli dillerle karsilastirildiginda arasindaki fark ilk elemanin indisi daima sifir (0) olmasidir.

for(int i=0; i<boyut; i++)
Burada dikkat etmek istedigimiz "int i=0" kismidir. Görüldügü gibi indisin ilk aldigi degeri sifir (0)`dan baslatiyoruz. Bu kismi unutmayiniz. Genellikle yapilan en büyük hatalardan biridir.

Bir dizi tanimlayicisi -adi-, dizinin ilk elemaninin adresini tanimlayan adrestir. Bunu söyle izah edelim; elimizde bir dizi var ve ilk elemani karakter ise biz "char DiziAdi[boyut]" seklinde tanimlariz. Tam sayi ise "int DiziAdi[boyut]" seklinde olur.

Dikkat edilmesi gereken diger bir konu da: dizi adi hiçbir zaman (=) isaretinin solunda bulunmaz. Bu yukarida söylediklerimi anlamamis olabilirsiniz. Onun için alt kismi okuyup bir daha tekrar etmenizi tavsiye ederim.

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.

<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


Sor:
#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.

[red_hacker]

sizeof() fonksiyonu, nesne için bellekte gerekli olan byte`larin sayisini belirtir. Sizeof() fonksiyonu dizilerde kullanilabilir.




Sor:
#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üs oldugumuz gibi dizinin bellekte kaplayacagi byte`lari hesapladi.

Birde bu konuyla beraber "&" operatörünün bir dizi bile olsa degiskene nasil uygulandigini görebiliriz.




Sor:
#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;
}





Programi derledikten sonra "sizeof(int) is 2 ya da sizeof(int) is 4" diyecektir. Bu degisiklik int in mikroislemcilere bagli olarak 2 veya 4 byte olabilmesinden kaynaklanmaktadir.

[red_hacker]

C++ da sözcükler için farkli bir tip yoktur. Sözcükler ile ilgili islemler diziler yardimi ile kolaylikla yapilabilir. Dikkat edilmesi gereken bir kural vardir. Sözcüklerin (strings) son elemanlari "\0" degerini alir (null terminator). Burdan da anlayacagimiz gibi son karakter bos dizgiyi belirtiyorsa stringtir. Suna da dikkat edilmelidir ki string sabitlerinin sonuna "\0" koymamiza gerek yoktur. Derleyici bunu otomatik olarak yapacaktir.

Char sozcuk[7]="Deneme";
Char sozcuk[7]=''D'', ''e'', ''n'', ''e'', ''m'', ''e'', ''\0''};
Bu dizilerin içerikleri tamamen aynidir. Hazir söz gelmisken suna da deginelim. ''\n'', ''\t'', ''\0'' v.s, bunlar birer karakter olarak okunur. Ben önceleri iki diye okurdum




Sor:
#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? " << 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?" <<endl;
}
else
{
cout << "Zorlamaya devam et!" << endl;
}
system("pause");
return 0;
}





Bu, sanirim bu konudaki en zor örnegimiz. Simdi örnek üzerinde biraz konuyu konusmaya devam edelim. Zaten diger if, else bloklarindan ve cout, cin gibi komutlardan bahsetmeyecegim. string Cevap = ""; bir sabitimizle isleme basladik. if( ( Cevap[0] == ''e'' ) || ( Cevap[0] == ''E'' ) ) burasi sanirim tanidik geldi Evet simdi burda Cevap[1] i çagirmis olsaydik ''v'' veya ''V'' degerlerini alicaktik. Tabi burada index degerinin yani dizideki ilk degerin 0 ile basladigini bir daha gördük. Simdi bu örnekle alakali olarak da Diziler ve Fonksiyonlar konusuna geçelim....

[red_hacker]

Iste buraya biraz dikkat, kafaniz gerçekten karisabilir. Daha dogrusu hangisi hangisiydi diye ugrasir durursunuz

strlen()
Bu fonksiyon bir karakter dizisinin uzunlugunu verir ve "string.h" kitapliginda tanimlidir. Strlen() fonksiyonu, sözcükler (strings) bölümünde bahsettigimiz string ifadeleri okumak için kullanilir. Fakat sondaki "nul terminator" diger sekliyle ''\0'' degerini okumaz. Örnegimizde de oldugu gibi "Deneme" ve ''d'' ''e'' ''n'' ''e'' ''m'' ''e'' sözcükler kisminda ki biz buna 7 karakter demistik, "null" ile birliktedir ama strlen() bunu bize 6 diye okuyacaktir.

int boy = strlen(h);
for (int i = 0; i<=boy; i++)
y[i] = h[i] ;
strcpy()
Bu fonksiyonda sözcük kopyalamaya yarar ve "string.h" kitapligindadir.

#include <iostream.h>
#include <string.h>

#define OTUZ 30

void main(void)
{
char Dosya1[OTUZ]="C:\\belgelerim\\deneme.txt",
Dosya2[OTUZ];


strcpy(Dosya2, Dosya1);
cout<<Dosya2<<endl;

cout<<"\n ikinci dosyayi gir: ";
cin>>Dosya1;

strcpy(Dosya2, Dosya1);
cout<<"\n"<<Dosya2<<"\n";
}
strcat()
strcat() fonksiyonu iki karakter katarini bir birine ekler.

strcmp()
Iki sözcügün (iki karakter katarinin) ayni olup olmadigini kontrol etmek için kullanilir. Bu fonksiyon büyük/küçük harf duyarli degildir.

atoi()
Bazen sayilari karakter dizisi olarak okumamiz gerekebilir. Ancak esas, bu sayilarin sayi degerlerine gereksinmemiz vardir. Atoi fonksiyon, bir karakter dizisini alir ve onu sayiya çevirir.

Örnegin; "123456" dizisini alir 123456 sayisina döndürür.

strstr()
Bunu bir örnekle anlatayim: "C++ dersleri" gibi bir sözcügümüz var, strstr() fonksiyonu ile bu sözcük içinde "d" harfinin varligini sorgulayabiliriz.

[red_hacker]

Isaretçiler (Pointers) ve bundan önce görmüs oldugumuz diziler (Arrays) ilerde yapacagimiz uygulamalarda kullanimina kesin ihtiyaç duyacagimiz basliklardir. Bunlar bize dinamik bellek kullanimini saglarlar. Dinamik bellek kullanimindan bahsedecek olursak, bellegimizin kutucuklardan olustugunu hayal edin. 100 kutucuklu bir bellegimiz var. Bu kutucuklarin her birinin bir adresi vardir ve biz de bu adresler yolu ile kutucuklara erisiriz. Iste isaretçiler bu erisimi sagliyor. Bu konuya çalisirken, anlamanin gayet kolay oldugunu göreceksiniz. Fakat ben sizi uyarayim, en kolay konular en çok hata yapilanlardir. Isaretçilerde yapilan hatalar programin hatta sistemin çökmesine sebep olabilir, ayni zamanda yapilan hatalari kolay kolay bulamayabilirsiniz. Büyük projelerde bu sizi bayagi sikintiya sokacaktir. Onun için isaretçiler konusunda, kullanim teknigi hakkinda size sik sik tavsiyelerde bulunacagim.

Isaretçilerin Tanimlanmasi ve Deger Atanmasi

Bir isaretçi tipi, hangi tipe isaret ettigini belirten ve birer adres degeri içeren verilere sahiptir. Bir isaretçi degisken bildirimi, açik olarak hangi tip veriyi kullanacagini bildirerek baslar. Derleyicimizde * isareti ile isaretçi degiskeni tanimladigimizi anlar.

<tip> *<isaretçi adi>; Seklinde yazilir. Örnegin, int *IsaretciAdi;

Simdi de ayni satirda birden fazla isaretçi tanimlayalim.

Int *is1, *is2, *is3;
Seklinde tanimlayabiliriz. Benim size tavsiye ettigim budur. Fakat farkli bir yol olarak da (Int *) is1, is2, is3; seklinde de yazilabiliriz. Burda dikkat etmemiz gereken olay ise, int tipinde isaretçileri tanimlarken herhangi bir degiskende tanimlarsak (int *) seklinde tek satirda yapmamiz hatalidir.

(Int *) is1, is2, is3, x=4; //hata
int *is1, *is2, *is3, x=4; //dogru
Sanirim ne demek istedigimi anladiniz.

Daha önce görmüs oldugumuz "&" adres operatörünü hatirlayalim, kendisisinden sonra gelen ifadenin adresini gösterir.

Int x;
Int *is1=&x;
x i tanimladik, sonra is1 isaretimize x in adresini atadik. Kisaca is1 in gösterdigi adresteki deger diye biliriz




Sor:
#include <iostream.h>
#include <string.h>

int main(void)
{
char *is1="deneme";
int index;
for(index=(strlen(is1)-1); index>=0; index--)
cout<<is1[index]<<endl;

cout<<"\n"<<is1;

return 0;
}



Programin çiktisi
---------
e
m
e
n
e
d

deneme

---------

[red_hacker]

Isaretçilere daha önce görmüs oldugumuz artirma (++), azalatma (--), çikarma (-), toplama (+) islemlerini uygulayabilirsiniz. Bunlarin yaninda iliskisel operatörleri de ( <=, =, !=, >= ) kullanmaniz mümkündür. Iliskisel operatörlerin sadece ayni tip isaretçiler üzerinde uygulanacagini unutmayiniz.

Bir dizinin boyutu degisken olabilir, daha dorusu bir program içinde degiskenler ve isaretçiler kullanilarak diziler dinamik bellek yerlesimi ile yapilabilir. C++ da dinamik belles islemleri new ve delete komutlari ile gerçeklestirilir.

Genel tanimimiz:
new <tür> [<[uzunluk]>]

new int
new char
new double [10]
new float[n]
new char[strlen(s) + 1]
new komutu ile yer tahsis etme islemi yapmaktayiz. new int ->1 int''lik yer tahsis edilmistir. Simdide tahsis ettigimiz yerin serbest birakilisini ele alalim. Bu sirada da delete komutu devreye giriyor. Daha dogrusu delete operatöürü new operatörüyle tahsis edilmis olan bloklari serbest birakmak için kullanilir.

Genel tanimimiz:
Delete[ ] <isaretçiadi>;
Eger yer ayirma islemi tek parça olarak yapilmissa (köseli parantez kullanilmadan yapilmissa) silme islemi de köseli parantez kullanilmadan yapilmalidir. Bir de suna dikkat edelim

Delete x+1; //hatalidir
Delete (x+1); //dogrudur
kullanilacaktir. Simdi bu söylediklerimizi asagidaki örnek üstünde uygulayalim.




Sor:
//dinamik.cpp
//dinamik bellek kavrami
#include <iostream.h>

struct tarih { //struck u daha görmedigimiz
int ay; //icin su an buraya egilmeyin.
int gun;
int yil;
};

void main()
{
int i, *is1, *is2; // i bir sabit ve *is1, *is2 isaretcilerimiz

is1 = &i;
*is1 = 77;
is2 = new int;
*is2 = 178;
cout << "Degerler "<<i<<" "<<*is1<<" "<<*is2<<"\n";
is1 = new int;
is2 = is1;
*is1 = 95454;
cout << "Degerler "<<i<<" "<<*is1<<" "<<*is2<<"\n";
delete is1;

float *float_is1, *float_is2 = new float;

float_is1 = new float;
*float_is2 = 3.14159;
*float_is1 = 2.4 * (*float_is2);
delete float_is2;
delete float_is1;

tarih *tarih_is;

tarih_is = new tarih;
tarih_is->ay = 10;
tarih_is->gun = 18;
tarih_is->yil = 1938;
cout<<tarih_is->ay<<"/"<<tarih_is->gun<<"/"<<tarih_is->yil<<"\n";
delete tarih_is;

char *c_is;

c_is = new char[37];
delete [] c_is;
c_is = new char[sizeof(tarih) + 133];
delete [] c_is;
}

[red_hacker]

C++ da Isaretçiler ve diziler arasinda çok yakin bir iliski vardir. Bir dizinin ismi, dizideki ilk elemanin adresini içeren sabit bir degiskendi. Bundan diziler bölümünde bahsetmistik. Simdi isaretçiler ile dizileri iliskilendirirsek, dizilerin adlarinin birer isaretçiden olustugunu görmüs olacagiz.

*(a+i)
a[i]
Bu sayede bu iki ifadenin ayni oldugunu söylemis oluruz. Bir de çok boyutlu dizilere uyarlarsak,

*(*(a+i)+j)
a[i][j]
seklini alir.

Int a[100];
Int *is1=&a[100];
Örnegimiz;


Sor:
//isaretçi ve diziler
#include <iostream.h>

void KareAl(int *sayi) {
*sayi *= *sayi;
}
void KareAlDizi(int *is1) {
for (int i=0; i<10; i++)
is1[i] *= is1[i];
}
int main() {
int x = 50;
int intis1[10];
KareAl(&x);
cout<<"x = "<<x<<endl;
KareAlDizi(intis1);
cout<<intis1;

return 0;
}

[red_hacker]

Isaretçiler ve diziler bölümünde görmüs oldugumuz örnektede oldugu gibi. Biz fonksiyonun adresine onun adi ile ulasiriz.

Kareal(x);
gibi. Simdi bir fonksiyonu isaret eden bir isaretçiyi ele alalim.


Int KareAl( );
fonksiyonumuz olsun.


Int (*KareAl)( );
Bu da Fonksiyonu isaret eden bir isaretçimiz oldu.

Biz genellikle isaret edilen fonksiyonlari menülerde ve siralamalarda kullaniriz. Asagida bir siralama örnegi verilmistir.




Sor:
//is_ve_fonk.cpp
//isaretçiler ve fonksiyonlar
#include <stdlib.h>
#include <iostream>
using namespace std;

void YatayYaz(char*);
void DikeyYaz(char*);
void ismiYaz(char*, void (*Yaz)(char*));

int main()
{
char isim[] = "Deneme";
ismiYaz(isim,DikeyYaz);
ismiYaz(isim,YatayYaz);
system("pause");
return 0;
}

void YatayYaz(char *isim)
{
if(!isim)
return;
cout << isim;
}

void DikeyYaz(char *isim)
{
if(!isim)
return;
int i = 0;
while(isim[i] != NULL)
{
cout << isim[i++];
cout << endl;
}
}

void ismiYaz(char *isim, void (*Yaz)(char*))
{
Yaz(isim);
cout << endl;
}

[olmezozc]

ya arkadaşlar bana microsoft visual c veya c++ lazım nerden bulurum bunu.... biraz acele de....