C++ Nedir ve Temel Dersler!

By MaTRiX · 30 Eyl 2006

Örnekler 2

7) #include <iostream.h>
#include <stdlib.h>
#include <ctype.h>
int main()
{
int idariPersonel=0* yazilimciKadrolu=0* yazilimciProje=0;
double netMaasToplam=0* cesitliKesintiToplam=0* saglikKesintiToplam=0;
//programın en sonunda hesaplayacağı toplamlar.

while(1)
{
cout<<"Personel türü:"<<endl;
cout<<"A-İdari"<<endl;
cout<<"B-Yazılımcı (Kadrolu)"<<endl;
cout<<"C-Yazılımcı (Proje)"<<endl;
cout<<"X-Programdan Çıkış"<<endl;
char tur;
cin>>tur;
tur=toupper(tur);
if(tur=='X') {break;}
switch (tur)
{
case 'A' : {
int saat=0* saatUcreti=0;
const int NORMAL=22*8;
double brut=0* net=0* kesinti=0;
cout<<"Toplam çalışma süresini (saat) giriniz: ";
cin>>saat;
cout<<"Saat ücretini giriniz: ";
cin>>saatUcreti;
brut=(double)(NORMAL + 1.5*(saat-NORMAL))*saatUcreti;
//bu satır hem normal hemde fazlamesai de çalışır
net=brut*0.8; kesinti=brut*0.2;
//artık bordor yazılabilir.
cout<<"Bordor bilgileri:"<<endl;
cout<<"Toplam çalışma sürtesi:"<<saat<<"saat."<<endl;
cout<<"Brüt ücret: \t"<<brut<<"TL."<<endl;
cout<<"Kesintiler: \t"<<kesinti<<"TL."<<endl;
cout<<"Net ücret: \t"<<net<<"TL."<<endl;
//genel hesaplara ilişkin yenilemeler
netMaasToplam+=net; cesitliKesintiToplam+=kesinti;
idariPersonel++;
//switchden çıkıyorus.
break;
}
case'B':{
int saat=0* saatUcreti=0;
const int NORMAL=22*10;
double brut=0* net=0* kesinti=0* saglik=0;
cout<<"Toplam çalışma süresi (saat) giriniz: ";
cin>>saat;
cout<<"Saat ücretini giriniz: ";
cin>>saatUcreti;
brut=(double)(NORMAL+1.5*(saat-NORMAL))*saatUcreti;
//bu satır hem nromal hem de fazla mesai de çalışır.
net=brut*0.65;
kesinti=brut*0.2;
saglik=brut*0.15;
//artik bordro yazılabilir
cout<<"Bordro bilgileri: "<<endl;
cout<<"Toplam çalışma süresi:"<<saat<<"saat."<<endl;
cout<<"Brüt ücret: \t"<<brut<<"TL."<<endl;
cout<<"Kesşntiler: \t"<<kesinti<<"TL."<<endl;
cout<<"Sağlık kesintileri: \t"<<saglik<<"TL."<<endl;
cout<<"Net ücret: \t"<<net<<"TL."<<endl;
//genel hesaplara ilişkin yenilemeler.
netMaasToplam+=net;
cesitliKesintiToplam+=kesinti;
saglikKesintiToplam+=saglik;
yazilimciKadrolu++;
//switch den çıkıyoruz.
break;
}
case'C': {
int modul;
double temel=0* modulBasi=0;
double net=0;
cout<<"Temel ücreti girin: ";
cin>>temel;
cout<<"Teslim edilen modül sayısını girin: ";
cin>>modul;
cout<<"Modül başı ücreti girin: ";
cin>>modulBasi;
net=(double) temel+modul*modulBasi;
//artık bordro yazılabilir.
cout<<"Bordor bilgileri:"<<endl;
cout<<"Bitirilen Modül sayısı: "<<modul<<endl;
cout<<"Net ücret: \t"<<net<<"TL."<<endl;
//genel hesaplara ilişkin yenilemeler
netMaasToplam+=net; yazilimciProje++;
//switch den çıkıyorus
break;
}
default: {
cout<<"Geçersiz personel türü. Yeniden Deneyin."<<endl;
}
}//switch

cout<<"Başka bir personelin maaşını hesaplamak istiyormusunuz?(E/H)";
char secenek;
cin>>secenek;
secenek=toupper(secenek);

if(secenek=='H') {break;} //bu while den çıkartır.
else if (secenek=='E'){} //birşey yapma
else {cout<<"Geçersiz seçenek. Ana menüye dönüyor..."<<endl;

//acaba ekranı nasıl temizlerdik?
//Böylece daha güzel görünümlü olan bir programımız olurdu

}//while

cout<<"Oturum İçin Genel Bilgiler:"<<endl;
cout<<"--------------------------------------"<<endl;
cout<<"Toplam İdari Personel: \t"<<idariPersonel<<endl;
cout<<"Toplam Yazılımcı (Kadrolu): \t"<<yazilimciKadrolu<<endl;
cout<<"Toplam Yazılımcı (Proje): \t"<<yazilimciProje<<endl;
cout<<"--------------------------------------"<<endl;
cout<<"Toplam Net ödeme: \t\t"<<netMaasToplam<<"TL."<<endl;
cout<<"Toplam Cesitli Kesintiler: \t"<<cesitliKesintiToplam<<"TL."<<endl;
cout<<"Toplam Sağlık Sigortası Kesintisi: \t"<<saglikKesintiToplam<<"TL."<<endl;
cout<<"--------------------------------------"<<endl;

system("PAUSE");
return 0;
} Bu örnek Bora GÜNGÖREN`e ait olan C++ İLE NESNE TABANLI PROGRAMLAMA kitabından alınmıştır.

By MaTRiX · 30 Eyl 2006

Fonksiyonlar

1. Fonksiyonlar

Bundan sonraki bölümlerdeki kullanacagimiz derleyici Borland Turbo C++ 4.5 tir. Fazla zorlanmayacaginizi umut ediyorum. Kolay anladiginiz yerlere lütfen dikkat ediniz. Hata yapma olasiliginiz daha da çok artmaktadir. Yapacaginiz hatalar programin çökmesine* belki de sistemin zarar görmesine sebep olabilir. Lütfen vermis oldugum uyarilara ve tavsiyelere uymaya çalisin. Sizin de tavsiyeniz olursa bana bildiriniz

. Haydi kolay gelsin...
1. Fonksiyonlara Giris:

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

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

By MaTRiX · 30 Eyl 2006

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

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

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

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

By MaTRiX · 30 Eyl 2006

İnline Fonksiyonlar

3. İnline Fonksiyonlar

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

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

return x * x * x;

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

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

double kenar;

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

By MaTRiX · 30 Eyl 2006

Fonksiyon Yüklemesi ve Prototipleri

4. Fonksiyon Yüklemesi ve Prototipleri

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

By MaTRiX · 30 Eyl 2006

Fonksiyonları Referans ile Çağırma

5. Fonksiyonları Referans ile Çağırma

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

#include <iostream.h>

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

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

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

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

By MaTRiX · 30 Eyl 2006

Void Tipi ve Main() Fonksiyonu

6. Void Tipi ve Main() Fonksiyonu

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

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

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

//kodlar

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

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

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

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

By MaTRiX · 30 Eyl 2006

Dizilere Giriş

1. Dizilere Giriş

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

By MaTRiX · 30 Eyl 2006

Dizilerin Tanımlanması ve Değer Atama

2. Dizilerin Tanimlanmasi ve Deger Atama

Int a[10]; Seklinde bir diziyi tanimlayabiliriz. Bunu daha genel bir kaliba dökersek.
<tip> <dizi adi> [<boyut>]; halini alir. Birde boyutlarinin arttirilmis halini verelim.
<tip> <dizi adi> [<boyut1>][<boyut2>][<boyut3>]....[<boyutn>]; n boyutlu dizi

.
<tip>: Yukarida söylemis oldugumuz "int DiziAdi[boyut]" olayidir.
<dizi adi>: Kurallara uygun herhangi bir isim olabilir. Genellikle dizilerinizin amacina uygun isimler kullaniniz.
[<boyut>]: Dizinin kaç eleman içerdigini gösterir. 5 elemanli ise [5] seklinde yazariz.
Basta " int a[10]; " almistik. Simdi bunu degisik bir formda yazalim
const int boyut=10;
Int a[boyut]; Önce boyut adinda bir sabiti tanimladik ve deger atadik sonrada bunu dizi içine çagirdik.
Dizilere Deger atama:

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

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

main() {

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

static int DuraganDizi[boyut];

for(int i=0; i<boyut;i++)
cout<<GlobalDizi;
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.

By MaTRiX · 30 Eyl 2006

Dizi Boylarının Dinamik Hesaplanması

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

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

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

void main() {
int a[10];
cout<<"sizeof(int) is"<<sizeof(int)<<endl;
for(int c=0; c<10; c++)
cout<<"&a["<<c<<

By MaTRiX · 30 Eyl 2006

Diziler ve Sözcükler (strings)

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

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

#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* sanırım bu konudaki en zor örneğimiz. Şimdi örnek üzerinde biraz konuyu konuşmaya devam edelim. Zaten diğer if* else bloklarından ve cout* cin gibi komutlardan bahsetmeyeceğim. string Cevap = ""; bir sabitimizle işleme başladık. if( ( Cevap[0] == 'e' ) || ( Cevap[0] == 'E' ) ) burası sanırım tanıdık geldi

Evet şimdi burda Cevap[1] i çağırmış olsaydık 'v' veya 'V' değerlerini alıcaktık. Tabi burada index değerinin yani dizideki ilk değerin 0 ile başladığını bir daha gördük. Şimdi bu örnekle alakalı olarak da Diziler ve Fonksiyonlar konusuna geçelim....

By MaTRiX · 30 Eyl 2006

Diziler ve Fonksiyonlar

5. Diziler ve Fonksiyonlar

Öncelikle dizilerin fonksiyonlara gönderilmesi ile başlayalım. Dizilerde değişken önüne adres operatörünün gelmesine gerek yoktur. Nedeni ise dizi isminin zaten bir adres olmasıdır.
İnt dizi[10]; bir dizimiz olsun biz bunu diziye bir değer olarak göndereceksek*
Fonksiyon(dizi* 10); olarak yaparız. Bir diziyi parametre olarak alacaksak bir fonksiyon* o da void fonksiyon( int dizi[]* int 10) şeklinde olur.

By MaTRiX · 30 Eyl 2006

Karakter Katarları Fonksiyonları ve Karakter Dizileri

6. Karakter Katarları Fonksiyonları ve Karakter Dizileri

İşte buraya biraz dikkat* kafanız gerçekten karışabilir. Daha doğrusu hangisi hangisiydi diye uğraşır durursunuz

strlen()

Bu fonksiyon bir karakter dizisinin uzunluğunu verir ve "string.h" kitaplığında tanımlıdır. Strlen() fonksiyonu* sözcükler (strings) bölümünde bahsettiğimiz string ifadeleri okumak için kullanılır. Fakat sondaki "nul terminator" diğer şekliyle '\0' değerini okumaz. Örneğimizde de olduğu gibi "Deneme" ve 'd' 'e' 'n' 'e' 'm' 'e' sözcükler kısmında ki biz buna 7 karakter demiştik* "null" ile birliktedir ama strlen() bunu bize 6 diye okuyacaktır.
int boy = strlen(h);
for (int i = 0; i<=boy; i++)
y = h ; strcpy()

Bu fonksiyonda sözcük kopyalamaya yarar ve "string.h" kitaplığındadır.
#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 katarını bir birine ekler.
strcmp()

İki sözcüğün (iki karakter katarının) aynı olup olmadığını kontrol etmek için kullanılır. Bu fonksiyon büyük/küçük harf duyarlı değildir.
atoi()

Bazen sayıları karakter dizisi olarak okumamız gerekebilir. Ancak esas* bu sayıların sayı değerlerine gereksinmemiz vardır. Atoi fonksiyon* bir karakter dizisini alır ve onu sayıya çevirir.
Örneğin; "123456" dizisini alır 123456 sayısına döndürür.
strstr()

Bunu bir örnekle anlatayım: "C++ dersleri" gibi bir sözcüğümüz var* strstr() fonksiyonu ile bu sözcük içinde "d" harfinin varlığını sorgulayabiliriz.

By MaTRiX · 30 Eyl 2006

İşaretçilere Giriş

1. İşaretçilere Giriş

İşaretçiler (Pointers) ve bundan önce görmüş olduğumuz diziler (Arrays) ilerde yapacağımız uygulamalarda kullanımına kesin ihtiyaç duyacağımız başlıklardır. Bunlar bize dinamik bellek kullanımını sağlarlar. Dinamik bellek kullanımından bahsedecek olursak* belleğimizin kutucuklardan oluştuğunu hayal edin. 100 kutucuklu bir belleğimiz var. Bu kutucukların her birinin bir adresi vardır ve biz de bu adresler yolu ile kutucuklara erişiriz. İşte işaretçiler bu erişimi sağlıyor. Bu konuya çalışırken* anlamanın gayet kolay olduğunu göreceksiniz. Fakat ben sizi uyarayım* en kolay konular en çok hata yapılanlardır. İşaretçilerde yapılan hatalar programın hatta sistemin çökmesine sebep olabilir* aynı zamanda yapılan hataları kolay kolay bulamayabilirsiniz. Büyük projelerde bu sizi bayağı sıkıntıya sokacaktır. Onun için işaretçiler konusunda* kullanım tekniği hakkında size sık sık tavsiyelerde bulunacağım.
İşaretçilerin Tanımlanması ve Değer Atanması
Bir işaretçi tipi* hangi tipe işaret ettiğini belirten ve birer adres değeri içeren verilere sahiptir. Bir işaretçi değişken bildirimi* açık olarak hangi tip veriyi kullanacağını bildirerek başlar. Derleyicimizde * işareti ile işaretçi değişkeni tanımladığımızı anlar.
<tip> *<işaretçi adı>; Şeklinde yazılır. Örneğin* int *İsaretciAdi;
Şimdi de aynı satırda birden fazla işaretçi tanımlayalım.
İnt *is1* *is2* *is3; Şeklinde tanımlayabiliriz. Benim size tavsiye ettiğim budur. Fakat farklı bir yol olarak da (İnt *) is1* is2* is3; şeklinde de yazılabiliriz. Burda dikkat etmemiz gereken olay ise* int tipinde işaretçileri tanımlarken herhangi bir değişkende tanımlarsak (int *) şeklinde tek satırda yapmamız hatalıdır.
(İnt *) is1* is2* is3* x=4; //hata
int *is1* *is2* *is3* x=4; //doğru Sanırım ne demek istediğimi anladınız

.
Daha önce görmüş olduğumuz "&" adres operatörünü hatırlayalım* kendisisinden sonra gelen ifadenin adresini gösterir.
İnt x;
İnt *is1=&x; x i tanımladık* sonra is1 işaretimize x in adresini atadık. Kısaca is1 in gösterdiği adresteki değer diye biliriz

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

Programın çıktısı
---------
e
m
e
n
e
d

deneme

---------
Burada bir işaretçi değişkenine değer atamayı kullandık* aynı zamanda dizilerde gördüğümüz strlen() fonksiyonun örneğini de yapmış olduk.

By MaTRiX · 30 Eyl 2006

İşaretçi İşlemleri ve Dinamik Bellek

2. İşaretçi İşlemleri ve Dinamik Bellek

İşaretçilere daha önce görmüş olduğumuz artırma (++)* azalatma (--)* çıkarma (-)* toplama (+) işlemlerini uygulayabilirsiniz. Bunların yanında ilişkisel operatörleri de ( <=* =* !=* >= ) kullanmanız mümkündür. İlişkisel operatörlerin sadece aynı tip işaretçiler üzerinde uygulanacağını unutmayınız.
Bir dizinin boyutu değişken olabilir* daha dorusu bir program içinde değişkenler ve işaretçiler kullanılarak diziler dinamik bellek yerleşimi ile yapılabilir. C++ da dinamik belleş işlemleri new ve delete komutları ile gerçekleştirilir.
Genel tanımımız: 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 işlemi yapmaktayız. new int ->1 int'lik yer tahsis edilmiştir. Şimdide tahsis ettiğimiz yerin serbest bırakılışını ele alalım. Bu sırada da delete komutu devreye giriyor. Daha doğrusu delete operatöürü new operatörüyle tahsis edilmiş olan blokları serbest bırakmak için kullanılır.
Genel tanımımız: Delete[ ] <işaretçiadı>; Eğer yer ayırma işlemi tek parça olarak yapılmışsa (köşeli parantez kullanılmadan yapılmışsa) silme işlemi de köşeli parantez kullanılmadan yapılmalıdır. Bir de şuna dikkat edelim
Delete x+1; //hatalıdır
Delete (x+1); //doğrudur kullanılacaktır. Şimdi bu söylediklerimizi aşağıdaki örnek üstünde uygulayalım.
//dinamik.cpp
//dinamik bellek kavramı
#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 << "Değerler "<<i<<" "<<*is1<<" "<<*is2<<"\n";
is1 = new int;
is2 = is1;
*is1 = 95454;
cout << "Değerler "<<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;
}

By MaTRiX · 30 Eyl 2006

Void İşarerçiler

3. Void İşarerçiler

C++ da tip tanımlamaları fazla güçlü olmadığından bu sorunu işaretçileri void * tipi ile tanımlayarak hallediyoruz. Void tipinde bir işaretçi değişken tipi ile* adresin bulunduğu* ancak henüz tipinin belirlenmediği anlaşılmalıdır. Void i kullanırken dikkat etmemiz gereken kurallardan biri karşımıza bazı kısıtlamalar getirmesidir. Bunlardan söz edecek olursak; void işaretçilerde adres aritmetiği işlemlerini derleyici hata olarak gösterecektir.
void *is1;
İnt *is2;
///
İs1=is2;
İs1++; Burada dikkat etmemiz gereken is1 yani void ile tanımladığımız işaretçi üzerinde aritmetik işlem yapılmayacağıdır!

By MaTRiX · 30 Eyl 2006

İşaretçiler ve Diziler

4. İşaretçiler ve Diziler

C++ da İşaretçiler ve diziler arasında çok yakın bir ilişki vardır. Bir dizinin ismi* dizideki ilk elemanın adresini içeren sabit bir değişkendi. Bundan diziler bölümünde bahsetmiştik. Şimdi işaretçiler ile dizileri ilişkilendirirsek* dizilerin adlarının birer işaretçiden oluştuğunu görmüş olacağız.
*(a+i)
a Bu sayede bu iki ifadenin aynı olduğunu söylemiş oluruz. Bir de çok boyutlu dizilere uyarlarsak*
*(*(a+i)+j)
a[j] şeklini alır.
İnt a[100];
İnt *is1=&a[100]; Örneğimiz; //işaretçi ve diziler
#include <iostream.h>

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

return 0;
} Örneğimizi adım adım takip edersek: void KareAl(int *sayi) burda sayi adında bir işaretçiyi kullanarak bir fonsiyon tanımlanıyor. Fonksiyonumuzun adı kare alma. İkinci fonksiyonda ise is1 isimli bir işaretçi ile parametresini giriyoruz* fakat işlem diziler üstünde sürüyor. Demiştik ya* dizilerin adları da birer işaretçiden oluşur. Sonraki main() fonksiyonumuzda da* x sabit değişkenimizi ve int tipindeki intis1[ ] dizimizi tanımlıyoruz. Referans yolu ile fonksiyonumuzu sabit değeri gönderiyoruz. Bir diğer işlemle de işaretçi parametresine sahip fonksiyonumuza bir dizi gönderiyoruz. Sanırım gayet basit oldu

. Bu sayede fonksiyonları da konuya ilişkilendirmiş olduk. Yoruldum... ayrıyetten açım

By MaTRiX · 30 Eyl 2006

İşaretçiler ve Fonksiyonlar

5. İşaretçiler ve Fonksiyonlar

İşaretçiler ve diziler bölümünde görmüş olduğumuz örnektede olduğu gibi. Biz fonksiyonun adresine onun adı ile ulaşırız.
Kareal(x); gibi. Şimdi bir fonksiyonu işaret eden bir işaretçiyi ele alalım. İnt KareAl( ); fonksiyonumuz olsun. İnt (*KareAl)( ); Bu da Fonksiyonu işaret eden bir işaretçimiz oldu. Biz genellikle işaret edilen fonksiyonları menülerde ve sıralamalarda kullanırız. Aşağıda bir sıralama örneği verilmiştir.
//is_ve_fonk.cpp
//işaretç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 != NULL)
{
cout << isim[i++];
cout << endl;
}
}

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

By MaTRiX · 30 Eyl 2006

Fonksiyonlara işaretçi Parametresi

6. Fonksiyonlara işaretçi Parametresi

İşaretçiler ve diziler bölümünde yapmış olduğumuz örnekte*
void KareAl(int *sayi); şeklinde bir fonksiyon tanımladık. Burada *sayi adında bir işaretçiyi parametre olarak fonksiyona göndermiş olduk. Zaten kullanım şeklini de örnekte olduğu gibi
KareAl(&x); x in adresini fonksiyona yazmamız yeterli oldu. Bu sayede ek bir işaretçi tanımlamamıza gerek kalmadı.
Farklı bir örnek daha verecek olursak:
#include <stdlib.h>
#include <iostream>
using namespace std;

void artan(int is1);
void artan2(int *is1);

void artan(int is1)
{
is1 += 5;
}
void artan2(int *is1)
{
*is1 += 5;
}
int main()
{
int i = 0;
artan(i);
cout << "i simdi: " << i << endl;
artan2(&i);
cout << "i simdi: " << i << endl;
system("pause");
return 0;
} Görülmüş olduğu gibi artan2 adındaki fonkyionumuza int tipindeki *is1 işaretçisini parametre olarak verdik ve main() artan2(&i); şeklinde çağrımızı yaptık.
!!!En zor kısmı atlattık sanırım. Lütfen geri dönüp örnekleri yeniden gözden geçirirseniz sizin için yararlı olacaktır. Bir program yazana kadar sizi bırakmayacağım

!!!

Kısaca C++'ya giriş yaptık.

Bundan sonrası çok çalışıp yorularak küçük programlar yapıp kendimizi geliştirmemiz gerekiyor.
-MaTRiX-hayırlı olsun...

By MaTRiX · 30 Eyl 2006

konu sabitlenirse iyi olur....

C++ Nedir ve Temel Dersler!

Üye

Üye

Üye

Üye

Üye

Üye

Üye

Üye

Üye

Üye

Üye

Üye

Üye

Üye

Üye

Üye

Üye

Üye

Üye

Üye