C Gömülü Programlama konularımız yayında...
C++ dilinde bilgisayar belleğinin bir kısmına belirli bir isim vererek bu bellek alanını kendimiz için ayırabilir ve bu alana değerler yerleştirebiliriz. Bu değerleri de istediğimiz zaman değiştirebiliriz.
Bu işlemlere değişken bildirimi ve değişkene değer atama işlemleri diyoruz.
Bir değişken bildirimi yaparak, bilgisayarın belleğinde belirli büyüklükte bir alanı kendimize ayırabiliriz. Bu bellek boyutu değişken veri türüne göre değişecektir. Bu işlemi yaptığımızda belleğin belirli bir bölümü bizim için ayrılmış olur.
Değişken bildirimi aşağıda gösterilen 3 farklı yerde yapılabilir:
C++ programlama dilinde, bir değişken ifade içinde kullanılmadan önce mutlaka bildirimi yapılmalı ve bir değer atanmalıdır. Bu bildirim işlemi, ister main() ister başka bir fonksiyon içinde olsun fonksiyonun veya kod bloğunun herhangi bir satırında yapılabilir.
Bir değişken bildirimi aşağıdaki şekilde görüldüğü gibi yapılır:
veri-türü değişken-adı;
Değişken bildiriminin bir işlem satırı ile yapıldığından bahsetmiştik. Bu nedenle noktalı virgül (;) ile sona erer. veri-türü ifadesi bildirimi yapılan değişkeninin veri türünü, değişken-adı ifadesi ise değişkenin adını göstermektedir.
Değişken bildiriminde değişken-adı ifadesi yerine kullanılacak değişken adları, sizin verebileceğiniz herhangi bir ad olabilir. Bu ad harflerden, rakamlardan ve (_) işaretinden oluşan bir karakter dizisi olmalıdır. C++, küçük ve büyük harflere farklı işlem yapar. FD ve fd olarak verilen değişken adları birbirinden tamamen farklı olarak kabul edilir.
Aşağıdaki işlem satırlarından birincisi id adlı int, ikincisi fd adlı float ve üçüncüsü dd adlı double bir değişken bildirimi yapar:
int id;
float fd;
double dd;
Değişken bildirimlerini, main() fonksiyonu da dahil olmak üzere, fonksiyonların başında veya herhangi bir satırında veya bütün fonksiyonların dışında olmak üzere kaynak kod dosyamızın başında veya herhangi bir satırında yapabiliriz.
Aynı türden olan birden fazla değişken bildirimini aynı işlem satırında yapabiliriz. Aşağıdaki işlem satırı id1, id2 ve id3 adlarında üç adet int değişken bildirimi yapar:
int id1, id2, id3;
Eğer değişken bildirimini fonksiyonların yada kod bloklarının içinde yaparsak bu değişkenlere "lokal değişken" adı verilir.
Lokal değişkenlerin en önemli özelliği sadece tanımlanmış olduğu fonksiyonlar içinde geçerli olması ve bu fonksiyon tarafından kullanılabilmesidir. Lokal değişken bildirimi fonksiyonun içinde yapılır ve sadece içinde tanımlandığı fonksiyon çalıştığı sürece geçerlidir. Bir fonksiyon programın herhangi bir yerinden çağrıldığında, çağrılan fonksiyonun içindeki lokal değişkenler oluşturulur ve fonksiyonun son işlem satırına işlem yapıldıktan sonra yok edilirler.
Aynı ada sahip olsalar bile, bir fonksiyondaki lokal bir değişkenin diğer bir fonksiyon içindeki lokal değişken ile herhangi bir ilgisi yoktur.
fonk1() fonk2()
{ {
int id; int id;
işlem satırı; işlem satırı;
. .
. .
. .
işlem satırı; işlem satırı;
} }
Yukarıda gösterilen fonk1() ile fonk2() fonksiyonları içinde yer alan id adlı int değişkenleri birbirlerinden tamamen farklıdır ve birbirleri üzerinde herhangi bir etkisi yoktur. Sadece tanımlandıkları fonksiyon içinde geçerlidirler.
Lokal değişkenlerle ilgili bahsettiklerimizi bir örnek üzerinde incelemeye çalışalım:
#include <iostream>
using namespace std;
void fonk1(void);
void fonk2(void);
int main(void)
{
int id;
id = 21; // Bu değişken sadece main() fonksiyonu içinde geçerlidir.
cout << "main() fonksiyonu içindeki id değişken değeri: " << id << "\n";
fonk1();
fonk2();
return 0;
}
void fonk1(void)
{
int id;
id = 175; // Bu değişken sadece fonk1() fonksiyonu içinde geçerlidir.
cout << "fonk1() fonksiyonu içindeki id değişken değeri: " << id << "\n";
}
void fonk2(void)
{
int id;
id = 2178; // Bu değişken sadece fonk2() fonksiyonu içinde geçerlidir.
cout << "fonk2() fonksiyonu içindeki id değişken değeri: " << id << "\n";
}
Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:
main() fonksiyonu içindeki id değişken değeri: 21 fonk1() fonksiyonu içindeki id değişken değeri: 175 fonk2() fonksiyonu içindeki id değişken değeri: 2178
Program biri direk diğer ikisi ise fonksiyon çağrısı yoluyla olmak üzere 3 farklı değişken değerini ekrana yazar. main(), fonk1() ve fonk2() fonksiyonlarının tamamında id adlı bir değişken yer almaktadır. Ancak, her üç değişkende, aynı ada sahip olmalarına rağmen, birbirinden tamamen farklı olup, içinde bulundukları fonksiyon içinde geçerlidir.
Fonksiyonlarda kod bloğu içinde tanımlanan lokal değişkenler
Bir fonksiyondaki kod bloklarının içinde tanımlanan değişkenler sadece o kod bloğu içinde geçerlidir. Bu değişken sadece tanımlandığı kod bloğu tarafından kullanılabilir, kod bloğu dışından değişkene erişim sağlanamaz.
Bu özelliği bir örnek üzerinde incelemeye çalışalım:
#include <iostream>
using namespace std;
int main(void)
{
int id1=21;
if (id1>0) {
int id2 = id1 * id1;
cout << "id1 değişken değeri: " << id1 << " id2 değişken değeri: " << id2 << "\n";
}
cout << "id1 değişken değeri: " << id1;
// id2 değişkenine buradan erişim sağlanamaz. Program derleme hatası verir.
// cout << " id2 değişken değeri: " << id2;
return 0;
}
Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:
id1 değişken değeri: 21 id2 değişken değeri: 441 id1 değişken değeri: 21
Program, main() fonksiyonu içinde, id1 adlı bir değişken tanımlayarak 21 değerini atar. Bir if koşulu kod bloğu içinde, id2 adlı int bir değişken tanımlayarak id1 değişkeninin karesini bu değişkene atar ve her iki değişken değerini ekrana yazar. if koşulu dışında id1 değişken değerini tekrar ekrana yazar. Ancak, id2 değişkenine buradan erişim sağlayamaz, çünkü id2 değişkenini sadece if koşul bloğu içinde geçerlidir. Erişim sağlamaya çalıştığımızda, derleyici hata verir.
Eğer bir fonksiyon kendisine aktarılan değerlere işlem yapacaksa, aktarılan değerlerin atanması için fonksiyon adından hemen sonra parantez içinde bir veya daha fazla değişken parametre tanımlanır. Bu değişkenlere fonksiyon parametre değişkenleri adı verilir.
Fonksiyon parametre değişkenleri fonksiyon lokal değişkenleri ile aynı özelliklere sahiptir. Tek farkları fonksiyona geçirilen değerlerin bu değişkenlere aktarılmasıdır.
Fonksiyonlara bir parametre geçirdiğinizde de aslınızda lokal bir değişken tanımlamış olursunuz. Bir fonksiyonun parametresi olarak tanımlanmış olan lokal değişkenler, fonksiyon çağrıldığında fonksiyona geçirilen argümanların değerini alırlar. Bu değişkenlerde tıpkı lokal değişkenler gibi fonksiyon çağrıldığında oluşturulur ve fonksiyon sona erdiğinde yok edilirler.
Bu özelliği bir örnek üzerinde incelemeye çalışalım:
#include <iostream>
using namespace std;
void carpim(int id1, int id2);
int main(void)
{
int id1=21, id2=7;
carpim(id1, id2);
return 0;
}
void carpim(int id1, int id2)
{
cout << "Çarpım sonucu: " << id1*id2;
}
Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:
Çarpım sonucu: 147
Program, id1 ve id2 adlı iki adet int değişken tanımlayarak 21 ve 7 değerlerini atar. Sonra, değişkenleri parametre olarak geçirerek, carpim() fonksiyonunu çağırır. Fonksiyon çağrılınca, fonksiyon parametreler yoluyla iki adet id1 ve id2 adlı lokal değişken oluşturarak, kemdisine parametre yoluyla geçirilen değişken değerlerini bu değişkenlere atar. Değişken değerlerini biribiryle çarparak elde ettiği sonucu ekrana yazar.
main() fonksiyonu içinde bildirimi yapılan id1 ve id2 değişkenleri, fonksiyon bildiriminde parametre olarak bildirimi yapılan id1 ve id2 değişkenleri ile tamamen farklıdır.
Eğer bir değişken bildirimini bütün fonksiyonların dışında ve kaynak dosyamızın içinde yaparsak bu değişkenlere global değişken adı verilir. Global değişken bildirimlerinin kaynak dosyamızın başında yapılması kod takibi açısından kolaylık sağlar.
Global değişkenlere main() fonksiyonu da dahil olmak üzere bütün fonksiyonlar erşim sağlayabilir.
Bu değişkenlere, main() fonksiyonu veya diğer fonksiyonların işlem satırından herhangi bir işlem yapabiliriz. Global değişkenler kaynak dosyamızın içinde tanımlandığından, programın çalışması sona erene kadar varlıklarını sürdürürler.
Global değişkenler bir program çalıştığı sürece varlıklarını sürdüreceklerinden sürekli bellekte kaplarlar. Bu nedenle, sadece ihtiyaç olduğunda, lobal değişkenleri kullanmak daha doğru bir tercih olacaktır.
#include <iostream>
using namespace std;
int gid; // Global değişken bildirimi
int deger_ekle(int id);
int main(void)
{
int id;
id = 21;
gid = 35; // Global değişkene erişim
cout << "id değişken değeri: " << id << " gid değişken değeri: " << gid << "\n";
cout << "deger_ekle() fonksiyon sonucu: " << deger_ekle(247);
return 0;
}
int deger_ekle(int id)
{
return id + gid; // Global değişkene erişim
}
Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:
id değişken değeri: 21 gid değişken değeri: 35 deger_ekle() fonksiyon sonucu: 282
Program, gid adlı global int bir değişken ve main() fonksiyonu içinde id adlı lokal bir değişken bildirimi yapar. id değişkenine 21 değerini gid değişkenine ise 35 değerini atar. Her iki değişken derğerini ekrana yazdıktan sonra, 247 değerini parametre olarak geçirerek deger_ekle() fonksiyonunu çağırır. Fonksiyon içinde parametre değeri ile gid değişken değerini toplar ve elde ettiği değeri geri döndürerek ekrana yazar. Global değişkene main() ve deger_al() fonksiyonları içinden erişim sağlanmaktadır.
Bir fonksiyon veya bir kod bloğu içinde bildirimi yapılan lokal değişken adı global değişken adı ile aynı olursa, fonksiyon veya kod bloğu içinde bu değişken adı ile ilgili işlemler doğrudan lokal değişkeni etkiler. Global değişkeni etkilemez.
Şimdi, bu özelliği bir örnek üzerinde incelemeye çalışalım:
#include <iostream>
using namespace std;
int id=7; // Global değişken bildirimi
void deger_goster(void);
int main(void)
{
int id; // Lokal değişken bildirimi
id = 21;
cout << "main fonksiyonu içindeki id değişken değeri: " << id << "\n";
deger_goster();
return 0;
}
void deger_goster(void)
{
int id; // Lokal değişken bildirimi
id = 35;
cout << "deger_goster() fonksiyonu içindeki id değişken değeri: " << id;
}
Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:
main fonksiyonu içindeki id değişken değeri: 21 deger_goster() fonksiyonu içindeki id değişken değeri: 35
Program, biri global, diğer ikisi main() fonksiyonu ve deger_goster() fonksiyonu içinde olmak üzere toplam üç adet id adlı int değişken bildirimi yapar. main() fonksiyonu içinde id değişkenine 21 değerini atayarak, deger_goster() fonksiyonu içinde de 35 değerini atayarak değişken değerlerini ekrana yazar. id lokal değişkenlerine main() ve deger_goster() fonksiyonları içinde yapılan değişiklikler global id değişkenini etkilemez.
Global değişkenlere herhangi bir ilk değer atanmadığında, otomatik olarak 0 (sıfır) değeri atanır. Lokal değişkenlere ise bir ilk değer atanmadığında, kendiliğinden herhangi bir değer atanmaz.
Önce, değer atanmamış bir lokal değişken değerini ekrana yazdırmak istediğimizde nasıl bir sonuç aldığımızı görmek için aşağıdaki örneği inceleyelim:
#include <iostream>
using namespace std;
int main(void)
{
int id;
cout << id; // Derleyici uyarı verir.
return 0;
}
Yukarıdaki örneği derlediğimizde, derleyici uyarı verir. Programı çalıştırdığımızda, ekrana hiçbir anlamı olmayan çok farklı bir sayı yazar. Bu değerin ekrana yazılmasının nedeni henüz değişkene bir değer atanmamış olmasıdır. Şimdi, bildirimi yapılan değişkenlere bir değer atama işlemini incelemeye çalışalım.
Lokal bir değişkene değer vermeden kullandığımızda, belirsiz sonuçlara neden olur.
Bir değişken bildirimi ile yapılan ilk değer atama işlemi aşağıdaki şekilde yapılır:
veri-türü değişken-adı = sabit;
int id = 1354;
Bir değişkene değer atamak için işlem satırında önce değişkenin adı, sonra eşit işareti (=) ve en son olarak ta atanacak değer yazılır.
Bir değişken bildirimi ve bu değişkene değer atama işlemi iki ayrı satırda yapılabileceği gibi tek işlem satırında da yapılabilir. Aşağıda yer alan ilk işlem satırı id1 adlı bir değişken bildirimi yapar ve ikinci işlem satırı id1 değişkenine 537 değerini atar. Üçüncü işlem satırı ise, id2 adlı int bir değişken bildirimi yaparken değişkene 751 değerini atayarak, üstteki iki satırın yapıtğı işlemi tek işlem satırında gerçekleştirir.
int id1; // Değişken bildirim satırı
id1 = 537; // Değişkene değer atama satırı
int id2 = 751; // Değişken bildirimi ve değer atama işlemi aynı satırda yapılır.
Sonuç olarak, bir değişkene ya ilk bildirildiğinde, yada daha sonra bir değer atanabilir.
Değişkenlere ilk değer atama işlemini bir örnek üzerinde incelemeye çalışalım:
#include <iostream>
using namespace std;
int main(void)
{
char cd = 'A';
int id = 21;
cout << "cd değişken değeri: " << cd << "\n";
cout << "id değişken değeri: " << id;
return 0;
}
Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:
cd değişken değeri: A id değişken değeri: 21
Program, oluşturduğu cd adlı char bir değişkene 'A' karakterini, id adlı int bir değişkene ise 21 sayısını harfini ilk değer atama yöntemi ile atar. Sonra değişken değerlerini ekrana yazar.
İlk değer atama işlemlerinde, global değişkenlere atanan değerler mutlaka sabit bir değer olmalıdır. Atanan değer bir değişken olarak tanımlanamaz. Başka bir deyişle, ilk değer atama işlemlerinde, ilk değer atama işlemcisinin (=) sağ tarafında yer alan değer mutlaka bir sabit olmalıdır.
Şimdi, bu özelliği bir örnek üzerinde incelemeye çalışalım:
#include <iostream>
using namespace std;
int gid = 21; // Global değişkene sadece sabit bir değer atanabilir.
int fonk(void);
int main(void)
{
int id1 = 84; // Lokal değişkene sabit değer atama
int id2 = id1/gid; // Lokal değişkene bir işlem sonucunu atama
int id3 = fonk(); // Lokal değişkene fonksiyonun geri döndürdüğü değeri atama
cout << "id1 değişken değeri: " << id1 << "\n";
cout << "id2 değişken değeri: " << id2 << "\n";
cout << "id1 değişken değeri: " << id3;
return 0;
}
int fonk(void)
{
int id = gid/3;
return id;
}
Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:
id1 değişken değeri: 84 id2 değişken değeri: 4 id1 değişken değeri: 7
Program, oluşturduğu gid adlı global bir değişkene ve id adlı lokal değişkene yaptığı ilk değer atamalarında sabit değerler kullanır. id2 değişkenine bir işlem sonucunu, id3 değişkenine ise fonk() fonksiyonu içinde yapılan bir işlem sonucunu atar.
Global değişkenlere bir defaya mahsus olmak üzere sadece programın başında bir ilk değer atama yapabiliriz. Lokal değişkenlere ise içinde tanımlandıkları fonksiyonların her çağrılışında bir ilk değer atama işlemi yapılır.
Bu özelliği bir örnek üzerinde incelemeye çalışalım:
#include <iostream>
using namespace std;
int gid = 21;
int kare_al(int id);
int main(void)
{
int id=5;
cout << "id değişkeninin karesi: " << kare_al(id) << "\n";
id=7;
cout << "id değişkeninin karesi: " << kare_al(id) << "\n";
cout << "gid değişken değeri: " << gid;
return 0;
}
int kare_al(int id1)
{
int id2 = id1;
return id2 * id2;
}
Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:
id değişkeninin karesi: 25 id değişkeninin karesi: 49 gid değişken değeri: 21
Program, gid adlı global int bir değişken oluştururken 21 değerini ilk değer olarak atar. main() fonksiyonu içinde, id adlı int bir değişken oluştururken 5 değerini ilk değer olarak atar. kare_al() fonksiyonunu id değişken değerini önce 5 sonra 7 değeri ile parametre olarak geçirerek, iki defa çağırır. Her defasında, fonksiyon içindeki id2 lokal int değişkenine parametre olarak geçirdiği değişken değerini ilk değer atama yöntemi ile atar. Bir fonksiyonun her çağrılışında, lokal değişken değerleri yeniden bir ilk değer alır.
Program yazarken başka bir işlem satırında değer atama yapmak yerine ilk değer atama yöntemini kullanmanın en büyük avantajı daha kısa ve daha hızlı bir kodlama yapabilmektir.
Global bir değişkene bir ilk değer atamazsak, değişken sıfır (0) değerini alır. Lokal bir değişkene bir ilk değer atamazsak, değişken anlamsız bir değer alır. Şimdi, bu özelliği bir örnek üzerinde incelemeye çalışalım:
#include <iostream>
using namespace std;
int gid;
int kare_al(int id);
int main(void)
{
int id;
cout << "gid global değişken değeri: " << gid << "\n";
cout << "id lokal değişken değeri: " << id; // Derleyici uyarı verir.
return 0;
}
Program, oluşturduğu gid adlı global int bir değişkene ve id adlı lokal int bir değişkene bir ilk değer vermediği için, global değişken için ekrana sıfır (0), lokal değişken için anlamsız bir değer yazar.
Bir işlem satırında birden fazla değişkene ilk değer atama yapılabilir:
int id1 = 7, id2 = 21, id3;
char cd1 = 'A', cd2 = 'F';
float fd1 = 45.324, fd2 = 852.321
Şimdi, bu özelliği bir örnek üzerinde incelemeye çalışalım:
#include <iostream>
using namespace std;
int main(void)
{
int id1 = 7, id2 = 21;
char cd1 = 'F', cd2 = 'K';
double dd1 = 652.435, dd2 = 234.741;
cout << "int değişken değerleri: " << id1 << " " << id2 <<"\n";
cout << "char değişken değerleri: " << cd1 << " " << cd2 << "\n";
cout << "double değişken değerleri: " << dd1 << " " << dd2;
return 0;
}
Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:
int değişken değerleri: 7 21 char değişken değerleri: F K double değişken değerleri: 652.435 234.741
Program, değişken bildiriminin yapıldığı her iki satırda ilk değer atama yöntemi ile ikişer farklı değişkene değerler atar ve ekrana yazar.