7.1 Scope ve Duration mantigi

Degiskenler program içinde scope ve duration özelliklerine sahiptirler. Scope, bir degiskenin tanimli oldugu bölge iken, duration degiskenin hafizada tutulma süresidir. Bir degikenin scope’u ve duration’inina birden, o degiskenin storage class’i yani ‘depolama sinifi’ adi verilir.

7.2 Fixed (Sabit) ve Automatic (Otomatik) Duration

Fixed duration’a sahip degiskenlerin hafizada tutulacaklari yer önceden ayrilmistir; yani sabittir. Automatic duration’a sahip degiskenlerin tutulacaklari hafiza alanlari ise programin çalismasi sirasind ayrilir. Fixed duration’a sahip degiskenin alani programin baslangicinda ayrilir ve bütün program boyunca degismez. Automatic duration’a sahip bir degikenin hafiza alani ise, o degiskenin tanimlandigi bölgeye girildiginde ayrilir ve bu kod parçasina her girildiginde bu alanin yeri degisir.

Sabit degisken tanimlamak için kullanilan keyword ‘static’ tir. Bu keyword kullanilarak tanimlanan degiskenler sabittir. Otomatik degisken tanimlamak için ise auto keyword’ü seçilmistir. Fakat tanimlanan bütün degiskenler otomatik olarak degerlendirildiklerinden bu keyword kullanilmaz.

7.2.1 Degiskenlere ilk deger verme

Sabit degiskenler program içerisinde sadece bir kez ilk deger alirken, otomatik degiskenlerin degerleri tanimlandiklari kod parçasina her giriste yenilir. Örnegin;

 void increment()
  {
  int j=1;
  static int k=1;
  j++;
  k++;
  printf(“j: %d\t k: %d\n”, j, k);
  }
  main()
  {
  increment();
  increment();
  increment();
  }

Bu program çalistirildiginda k sadece 1 kez ilk deger alir ve ondan sonra k üzerinde yapilna bütün islemler mevcut degeri üzerinden gerçeklesir. Bu programin ekran çiktisi;

 j: 2 k: 2
  j: 2 k: 3
  j: 2 k: 4

increment() fonksiyonu her çagirildiginda j 1 degerini alir ve j++ il degeri 2 olur. Fakat k 1 kez 1 degerini aldiktan sonra, increment() her çagirildiginda bu deger 1 artirilir.

Sabit ve otomatik duration’a sahip degiskenler arasindaki bir diger önemli fark da, otomatik degiskenlere ilk deger verilmediginde ayrilan adresteki degerleri almalarina karsin, sabit degiskenlerin ilk degeri her zaman 0’dir. Az önceki örnekte j’ye ve k’ye ilk deger atama islemini kaldirirsak olusacak ekran görüntüsü;

 j: 243653 k: 1
  j: 243653 k: 2
  j: 243653 k: 3

gibi birsey olacaktir.

7.3 Scope

Bir degiskenin scope’u, o degiskenin tanimli oldugu araliga, yani o degiskene erisebilecegimiz araliga denir. C’de dört ayri scope (bölge) vardir:

Program scope: Programin bütününü olusturan farkli kod parçalari tarafindan degiskene erisilebilir. Bu tip degiskenlere ‘global degisken’ adi verilir.
File scope: Tanimlanan degiskenin sadece tanimlandigi kod dosyasinda aktif oldugunu ifade eder.
Function scope: Degiskenin tanimlandigi fonksiyon içinde geçerli oldugunu belirtir.
Block scope: Degiskenin tanimlandigi yerden, tanimlanmis oldugu blogun sonuna kadar geçerli oldugunu belirtir. Bloklar { }ile belirtilir.

Bu 4 bölge hiyerarsik olarak gösterilirse;

Genelde degiskenlerin scope’larini belirleyen tanimlandiklari yerlerdir. Örnegin;

 int i; // Program scope
  static int j; // File scope
  func(k) // Program scope
  int k; // Block scope
  {
  int m; // Block scope
  start: // Function scope
  ……

Degiskenlerin farkli bölgelerde tanimli olmasi özelligini kullanarak, tanim bölgeleri (Scopelari) birbirinden fakrli olmak kosuluyla ayni isimde birden fazla degisken kullanmak mümkündür. Örnegin;

 func1()
  {
  int j;
  ……
  }
  func2()
  {
  int j;
  ……
  }

Ayni isimde ve tanim bölgeleri kesisen degiskenler kullanmak da mümkündür. Bu gibi durumlarda tanim araligi daha küçük olan degisken öncelik kazanir. Örnegin;

 int j=10;
  main()
  {
  int j;
  for (j=0;j<5;j++)
  printf(“j: %d\n”, j);
  }

Bu kod parçasinda global tanimlanan j degiskeni, 10 degerini korurken, main() içinde block scope’una sahip olan j’nin degeri kullanilir.

7.3.1 Block Sope

Block scope’una sahip bir degiskene block disindan müdahale edilemez. Bu da program yazm islemini kolaylastirir. Degiskenlerin tanim bölgelerini daraltarak daha anlasilabilir ve düzenlenebilir kod yazmak mümkündür. Bu sayede kullanilan degiskenin degerinin degismesine yol açacak yan etkilerden de kurtulmus olunur. Block scope kullanmak degisken isimlerinin çakismasi derdini de ortadan kaldirir.

while, for, if gibi kontrol ifadelerinde de kod bloklari kullanildigindan, bu bloklar içinde de degisken tanimlamak mümkündür. Bu daha çok kontrol - debugging amaçli kod yazma isleminde faydali olur. Çok karmasik kod parçalarinda bu yöntem ile degiskenlerin çakismasi da engellenir. Örnegin;

 foo()
  {
  int ar[20];
  int j;
  // debugging kodu
  {
  int j; //bir üste bloktaki j ile çakismaz
  for (j=0;j<=10;j++)
  printf(“%d\t”, ar[j]);
  }

7.3.2 Function scope

Function scope’a sahip olan tek eleman goto komutu ile birlikte kullanilan label’lardir. Label’lar fonksiyonun basindan sonuna kadar tanimlidirlar.

7.3.3 File ve Program Scope

Bir degiskenin file (dosya) scope’una sahip olmasi, onun o dosyada yeralan bütün fonksiyonlar tarafindan kullanilabilecegi anlamina gelir. Bir degiskene file scope’u kazandirmak için, herhangi bir fonksiyonun disinda static keyword’ü ile tanimlanmasi gerekir. Örnegin;

Program scope’a sahip degiskenler, yani global degiskenler, programi olusturan bütün fonksiyonlar ve kod tarafindan erisilebilir degiskenlerdir. Global degisken tanimlamak için, herhangi bir fonksiyonun içinde olmayacak sekilde ve static keyword’ünü kullanmadan degiskeni tanimlamak yeterlidir. Örnegin;
static int filesv; // File scope
int progsv; // Program scope

 foo()
  {
  …