Geri: C++ NEDİR VE TEMEL DERSLER

[Admin]

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[i])
{
cout << getenv[i++]<<endl;

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











__________________

[Admin]

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.

[Admin]

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











__________________

[Admin]

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<<"]="<<&a[c]<<endl;
} Programı derledikten sonra "sizeof(int) is 2 ya da sizeof(int) is 4"
diyecektir. Bu değişiklik int in mikroişlemcilere bağlı olarak 2 veya 4
byte olabilmesinden kaynaklanmaktadır.











__________________

[Admin]

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











__________________

[Admin]

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.







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[i] = h[i] ; 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.

[Admin]

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

[Admin]

İş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.
http://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;
}











__________________

[Admin]

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!



İş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[i] Bu sayede bu iki ifadenin aynı olduğunu söylemiş oluruz. Bir de çok boyutlu dizilere uyarlarsak,
*(*(a+i)+j)
a[i][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[i] *= is1[i];
}
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... Çay yapıp geliyorum

[Admin]

İş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.
http://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;
}


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





[i]
Kısaca C++'ya giriş yaptık.Bundan sonrası çok çalışıp yorularak küçük programlar yapıp kendimizi geliştirmemiz gerekiyor.