Değişkenler

► Detaylı anlatım

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.

• Değişken bildirimi
• Lokal değişkenler
• Fonksiyon parametre değişkenleri
• Global değişkenler
• Değişkenlere ilk değer atama

Değişken bildirimi

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;

Lokal değişkenler

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

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

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

id1 değişken değeri: 21 id2 değişken değeri: 441
id1 değişken değeri: 21

Fonksiyon parametre değişkenleri

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

Çarpım sonucu: 147

Global değişkenler

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
}

id değişken değeri: 21 gid değişken değeri: 35
deger_ekle() fonksiyon sonucu: 282

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

main fonksiyonu içindeki id değişken değeri: 21
deger_goster() fonksiyonu içindeki id değişken değeri: 35

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.

Değişkenlere ilk değer atama

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

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

cd değişken değeri: A
id değişken değeri: 21

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

id1 değişken değeri: 84
id2 değişken değeri: 4
id1 değişken değeri: 7

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

id değişkeninin karesi: 25
id değişkeninin karesi: 49
gid değişken değeri: 21

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

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

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