c++ derslerine giriş ve örnekler

Başlamadan Önce
C++ öğrenmek C bilmeyi gerektirdiği için bazı bölümler C bilmeyenler için karışık gelebilir (döngü yapıları* blok yapıları...) Bu gibi durumlarda açıklayıcı bilgiler konacaktır ancak daha iyi oturması bakımından C kaynaklarına bir kaç gün ayırmanızı tavsiye ederim.
İzleyeceğim yöntemden bahsedeyim. konuları başlıklar halinde incelemek yerine direkt örnek kodlarla başlayacağım. bu kodlar içinde nelerin olduğunu anlamaya çalışacağı(m/z) ve yeri geldikçe de C++ ın özelliklerinin neler olduğunu yine kodların içinde göstereceğim.
Kullanacağım derleyici ise windows altında Blooshed firmasının Dev-C++ derleyicisi (Bu derleyici link olarak gcc ye bağlanır) ) Linux altında ise gcc/g++ .

İşte başlıyoruz !
C++ ile C arasındaki temel yazım kuralları
C++* C deki yazım kurallarını aynen destekler. yani C de yazdığınız programları C++ ta derleyip çalıştırabilirsiniz ama bu C++ ın gücünü kullanmanızdan mahrum kalmanıza neden olur. aşağıdaki koda bakın.

// Bu yapı standart bir c programıdır

#include < stdio.h >
#include < stdlib.h >


int main()
{
// system fonksiyonu aldığı parametreyi işletim sistemine gönderir..
system("pause");
return 0;
}

Şimdi bu kodu C++ kodu haline çevirelim. oluşacak kod :

// Bu yapı standart bir c++ programında bulunacak terimlerdir.
// Yapıyı çok iyi bilmeniz pratikliğiniz için gereklidir.

#include <iostream >
#include <stdlib.h >

using namespace std;

int main()
{
// system fonksiyonu aldığı parametreyi işletim sistemine gönderir..
system("pause");
return 0;
}

Gördüğünüz gibi fark header (başlık) dosyalarının eklenmesinde farkediliyor.
stdio.h dosyasının c++ taki karşılığı iostream dir. başlık kısmında her iki dosyayıda
kullanabilirsiniz. Ben şimdi bir şey denemek istiyorum. madem iostream ve stdio.h dosyaları
aynı şey demek* o halde yukarıdaki system fonksiyonu her iki başlık içinde tanımlı demektir.
şimdi her iki başlığıda include bölümünde tanıtalım ve system fonksiyonunu işletelim.
bakalım ne olacak? derleyici hata verecek mi acaba?
#include < iostream>
#include < stdio.h>
#include < stdlib.h>

using namespace std;

int main()
{
// system fonksiyonu aldığı parametreyi işletim sistemine gönderir..
system("pause");
return 0;
}






şimdi Execute butonuna basıyorum ve sonucu görüyorum..

işte hiçbir hata ile karşılaşmadım. mantıksız bir durum mu bu acaba? derleyicinin hata
vermesi gerekiyordu ama hiç bir hata vermedi. benim yorumum derleyicinin c++ terimleri
algılamasından dolayı iostream i işletmesi gerektiği. iostream ifadesi iostream.h dosyasını
ifade eder. başlık bölümünde .h kısmını yazmayabilirsiniz. bu c++ tarzı bir kullanımdır.
şimdi de stdio.h dosyasının .h olmadan yazıp deneyin ve sonra da iostream.h yazarak derleyin.
sonucu gözlerinizle görün.



Kısaca Blok yapıları

C ve C++ ta blok yapıları tamamıyla aynıdır. bir blok "{" parantezi ile başlar ve "}" parantezi
ile son bulur. (Pascal-delphi bilenler için { = begin* }=end; demektir. )
(Basic te blok yapısı : if ... end if* for ... next)

Örnek delphi blok yapısı:
For i := 0 to 20 do
begin
write('i değişkeninin şu andaki değeri : '*i);
writeln(' dir.');
end;

Basic kodu blok yapısı örneği:
For i = 0 to 20 step 1
print "i değişkeninin şu andaki değeri : " *i
Next

Aynı kodun C++ karşılığı :
for( i=0; i<=20; i++)
{
cout << "i değişkeninin şu andaki değeri : "<< i << " dir";
}

NOT : C++ taki blok yapısı aynen C ailesinde de geçerlidir (Java* PHP...)

Şimdi ilk C++ programımızı yazdıktan sonra C++ ın asıl gücünü işlemeye başlayabiliriz.
Hani en çok konuşulan şu Object Oriented Design (Nesneye yönelik dizayn) ne demek anlamaya çalışalım.
Şimdi şöyle düşünelim. Biraz geniş çapta bir program yazıyoruz.
Programda farklı ama kendi içerisinde fazla kod isteyecek bölümler var.
Örneğin bir yazı kutusu olacak (Delphideki editbox ya da Vbasic teki Textbox. Bunlar bu dillerde hazır var ama farzedinki elimizde yok).
Metin kutusu işlemini fonksiyon halinde yapmaya kalkalım (İlla nesne mi yapacaz yani birazda fonksiyonları kullanalım).
Şimdi ilk olarak bu metin kutusunun ekranda yeri(sol üst ve sol yan köşelerinin koordinatları) olması gerekiyor.
bu kutunun genişliğinin bilinmesi gerekiyor. yine bu kutunun yüksekliğinin bilinmesi gerekiyor.
Hatta bu metin kutusu gireceğimiz karakterleri şifreli "*" gösterebilsin (şimdilik bu kadarı yeter).
bu işlemi yapacak basit bir fonksiyon yazmak ne kadar sürer? hadi diyelim 100 satır ile halledilebilir.
örneğin function MetinKutusu (Sol_X*Sol_Y*genislik*yukseklik:int;sifrechar:char ) şeklinde bir fonksiyon olabilir.
Peki ya bu özellikler daha fazla olsaydı? 100 den fazla özelliği bulunsaydı nolurdu?
Bu fonksiyon yapısı yerine nesne yapısını kullanıyor olsaydık oluşacak durum şuna benzeyecekti:
Nesnenin benzeyeceği kalıp adı (sınıf:class) : metinKutusu;
Yöntemleri (metotları) :

sol kenarın X ve Y koordinatları bulunsun
genisliği ve yüksekliği bulunsun
şifreli giriş yapılabilsin

şeklinde bir özet rapordan sonra bu nesneye ait 3 alt fonksiyon ile bu işi çok daha anlaşılır
halde yazabiliriz. ilk alt fonksiyonun adı Koordinat(X*Y:int)* ikincisinin adı Buyukluk(genislik*yukseklik:int)
ve üçüncünün adı da SifreliYap(sifrechar: char) olsun. O halde nesnemizin fonksiyonları

MetinKutusu.Koordinat(int X*Y)
{
Sol_X = X;
Sol_Y = Y;
}

MetinKutusu.Buyukluk(int genislik*yukseklik)
{
KutuGenisligi = genislik;
KutuYuksekligi = yukseklik;
}

MetinKutusu.SifreliYap(char sifrechar)
{
SifreOlarakGosterilecekKarakter = sifrechar;
}
şeklinde gösterebiliriz. Böylece kod çok daha anlaşılır olacaktır. Peki eğer fonksiyon olarak
kullansaydık ne olurdu? şöyle olurdu. bir kez fonksiyon halinde olsaydı bu metin kutusundan
sadece bir tane kullanabilecektik. (O da Ne demek?) fonksiyonu bir kaç kez kullanarak birden
fazla metin kutusu çizdirip kullandırabilirdik ama bu kutuların bir birinden bağımsız olması
için eklenmesi gerekecek kod miktarını bir düşünün? yani birden fazla metin kutusu olacak
ve bu kutulara ayrı ayrı bilgiler gireceğim ve bu bilgiler ve değişkenleri bir birleri ile asla
karışmayacak. tek çözümünüz büyük diziler tanımlayıp içlerine dalmak.
Peki bunun yerine C++ ın sunduğu şu yönteme ne dersiniz?
MetinKutusu adlı sınıfın fonksiyonlarını yazdıktan sonra ana programda tanım bloğuna sadece
şunu yazın:

MetinKutusu Text1* Text2* Text3;

Bu satır ile 3 adet birbirinden bağımsız metin kutuları oluşturabilirsiniz. Burada Text1* Text2 ve Text3 adındaki yeni nesneler MetinKutusu sınıfı ile aynı özellikleri gösterecektir. Çalışma anında bunların herhangi birini yok edebilir ya da yeniden oluşturabilirsiniz. Tüm bunları nasıl yapacağımızı zamanı gelince göstereceğim. Şimdi daha da ileriye gidip

MetinKutusu Text[]; yöntemiyle MetinKutusu nu dinamik bir dizi olarak kullanabilirsiniz (Dinamik Dizi: Programın çalıştığı sırada oluşturulabilen ve eleman sayısının değişken olabildiği dizi. böylece gereksiz yere hafızayı kullanmış olmazsınız)
Böylece Text[] dizisini istediğiniz kadar eleman sayısı ile (ÖR:Text[100]) tanımlayıp kullanabilirsiniz.

Text[0].Koordinat(5*10);
Text[1].Koordinat(5*20);
Text[2].Koordinat(5*30);
...

Yok ben illa fonksiyon halinde yazacam ve bu kadar karışıklığınn üstesinden kendi başıma çıkacam diyorsanız
şunu da düşünün. Ya bu oluşturulacak metin kutularının birbirini etkilemeden çalışabilmesi gibi programın
akışınıda değiştirmeden çalışması gerekirse? yani bu kutuların hepsinin aynı anda çalışması gerekirse ?
Yada kutulardan birkaçının (varsayalım dizinizin tam ortasına denk gelen 20 kutunun) yok edilip hafızadan
kaldırılarak yeni işlemler için hafızadan yer açması gerekirse ?
bence Nesneye dayalı tasarımı kesinlikle öğrenin

İlk c++ programımızı da başarıyla derledikten sonra şimdi de ilk nesnemizin yazmaya ne dersiniz?
Nesne yazmak için öncelikle bir sınıf (class) yazmamız gerekmektedir. nedir bu class?
Yukarıdaki kodu biraz daha inceleyelim. MetinKutusu adlı nesne aslında bir kalıptır. Text1*Text2 ve Text3 değişken ismi oluşturduğumuz yeni yapılar ise birer nesnedir. yani program içerisinde
MetinKutusu Text1;
komutu ile MetinKutusu tipinde bir Text1 nesnesi yaratmasını istiyoruz. biraz felsefik bir açıklama : sanırım platonun fikriydi. idealar dünyası : yeryüzündeki herşeyin bir kalıbı vardır. Sofinin dünyasını okuyanlar hemen hatırlayacaklardır. Hani çörek yapmak isteyen bir kişi önce hamuru ona çörek biçimini verecek bir kalıbın içine sokar. daha sonra fırında pişirir ve sonuçta görür ki çıkan bütün çörekler birbirinin aynıdır ve kalıbın özelliğini almıştır. İşte burda da aynı durum söz konusudur. Sınıf olarak kalıbı tanımlıyoruz ve programın içindeki MetinKutusu Text1; komutu ile bu kalıpta bi Text1 nesnesi yaratıyoruz. İstediğimiz kadar nesne yaratabiliriz bu nesnelerin hepsi bir birinden bağımsız hareket edebileceklerdir. Şimdi örnek bir nesne nasıl hazırlanır görelim.
Öncelikle Nesnede istenen özellikleri sınıf halinde tanımlayacağı. Sınıfımız adı YiginSinifi.
Bu sınıfın şöyle yöntemleri olsun. Ekle ve Cikar. Birde bunlara ek olarak Init (initialize) adında bir düzenleme yöntemi de olsun. Ekle yöntemi Yigina bir karakter ekleyecek ve Cikar yöntemi ise yigindan bir karakteri geri çıkaracaktır. sınıf yapısı :

#define Boyut 10

class YiginSinifi {
char yigin[Boyut];
int Pozisyon;
public
**** init ();
**** ekle(char ch);
char cikar();
};


İşte YiginSinifi için gerekli tanımlamaları yaptık. yukarıdaki tanımlada sırasıyla şu işlemler yapılıyor. yigin adindan bir char dizisi tanımlanıyor. aynı şekilde dizinin hangi elemanında konumlu olduğunun takip edilmesi amacıyla da Pozisyon adında bir integer değişken tanımlanıyor. Dikkat ederseniz bu pozisyon ve yigin değişkenleri public (genel) bildiriminden önce tanımlandı. bunun anlamı şudur. Public deyiminden sonraki tüm tanımlı yöntemler (bu arada Yöntem nesnenin fonksiyonlarına verilen addır. ufak bir farkı var. yeri gelince onu da anlatacağım) ve değişkenler dışarıdan erişime açıktır. Bu deyimden önceki tüm yöntemler ve değişkenler ise sadece nesneye özeldir ve dışarıdan değiştirilmesi mümkün değildir(Bu çoğu zaman işinize çok yarayacak bir özellik). Gerekli sınıf tanımlaması yapıldıktan sonra şimdi de bu sınıfın yöntemlerini yazalım. **** YiginSinifi::init()
{
Pozisyon = 0;
}
Yukarıdaki yöntem çalıştırıldığında Pozisyonu başlangıç olarak 0 'a konumlandıracaktır.

**** YiginSinifi::ekle(char ch)
{

if (Pozisyon = Boyut)
{
cout<<"Yığın doldu";
return;
}
Yigin[Pozisyon]= ch;
Pozisyon++;
}
Bu yöntem ile yığına yeni bir karakter ekleyebileceğiz.
char YiginSinifi::cikar()
{

if (Pozisyon = 0)
{
cout<<"Yığın boş";
return;
}
Pozisyon--;
Return Yigin[Pozisyon]; }
ve bu yöntemle de yığındaki bir karakteri geri çıkarıyoruz.

Şimdi bu kodları main bloğunuda ekyerek derleyelim ve nasıl çalıştığını görelim.

#include < iostream>
#include < stdlib.h>

using namespace std;

#define Boyut 10

class YiginSinifi {
char Yigin[Boyut];
int Pozisyon;
public :
**** init ();
**** ekle(char ch);
char cikar();
};
**** YiginSinifi::init()
{
Pozisyon = 0;
}
// Yukarıdaki yöntem çalıştırıldığında Pozisyonu başlangıç olarak 0 'a konumlandıracaktır.

**** YiginSinifi::ekle(char ch)
{

if (Pozisyon == Boyut)
{
cout<<"Yigin doldu ";
return;
}
Yigin[Pozisyon]= ch;
Pozisyon++;
}
// Bu yöntem ile yığına yeni bir karakter ekleyebileceğiz.
char YiginSinifi::cikar()
{

if (Pozisyon == 0)
{
cout<<"Yigin boş ";
return 0;
}
Pozisyon--;
return Yigin[Pozisyon];
}

int main()
{ YiginSinifi Nesne1;
int x*x2;
Nesne1.init();
Nesne1.ekle('a');
Nesne1.ekle('b');
Nesne1.ekle('c');
Nesne1.ekle('d');
Nesne1.ekle('e');
cout << "Nesneye 5 adet karakter eklendi.. \n";
cout << "simdide nesneye ekledigimiz tüm karakterleri cikartalim.. \n";
cout << Nesne1.cikar()<< "\n";
cout << Nesne1.cikar()<< "\n";
cout << Nesne1.cikar()<< "\n";
cout << Nesne1.cikar()<< "\n";
cout << Nesne1.cikar()<< "\n";
cin >> x;
return 0;
}


ve bu kodun çıktısı şu şekildedir..
Gördüğünüz gibi çıktı tamamıyla ilk giren son çıkar mantığına dayanıyor (FILO).

Şimdide Free zamanı !

Yukarıdaki kod üzerinde hiçbir değişklik yapmadan linux altında nasıl derleyip çalıştırabileceğimizi görelim.

Şekilde de gördüğünüz gibi tek yapmanız gereken g++ deneme.cpp -o sonuc komutuyla programı derlemek. Buradaki deneme.cpp dosyası derlenecek olan kaynak dosyayı ifade eder. "-o" parametresi ise derlenmiş dosyanın adını değiştirmek istediğimizi anlatır (burda oluşacak çalıştırılabilir dosyanın adının "sonuc" olmasını istedim. bu parametreyi belirtmezseniz standart olarak dosyanız "a.out" olarak derlenecektir.) Bu derlenmiş çalıştırılabilir dosyayı işletmek için dosya adının önüne "./" eklememiz yeterlidir. "./sonuc" yazıp enter lediğimizde dosya çalıştırılacaktır.


Gelecek ders te sınıfları işlemeye devam edeceğiz. bu konuda eklemek istediklerinizi lütfen belirtin. Çünkü geniş ve çok önemli bir konu.