8 . BÖLÜM : NESNELERİN FAALİYET ALANLARI VE ÖMÜRLERİ

Daha önce C dilinde nesnelerin 3 ayrı özelliğini görmüştük. Bunlar nesnelerin isimleri, değerleri ve türleriydi. Nesnelerin C dili açısından çok önem taşıyan iki özellikleri daha söz konusudur. Bunlar tanınabilirlik alanları (scope) ve ömürleridir (storage duration). Bu dersimizde bu iki kavramı detaylı olarak inceleyeceğiz.

Tanınabilirlik Alanı (scope / visibility)
Tanınabilirlik alanı bir nesnenin ömrünü sürdürdüğü ve tanınabildiği program aralığıdır. Burada program aralığı demekle kaynak kodu kastediyoruz. Dolayısıyla tanınabilirlik alanı doğrudan kaynak kod ile ilgili bir kavramdır, dolayısıyla derleme zamanına ilişkindir. C dilinde derleyici, bildirimleri yapılan değişkenlere kaynak kodun ancak belirli bölümlerinde ulaşılabilir. Yani bir değişkeni tanımlıyor olmamız o değişkene kodun istediğimiz bir yerinde ulaşabilmemizi sağlamaz. Tanınabilirlik alanlarını 2 ayrı grupta toplayabiliriz :

Blok tanınabilirlik alanı. (Block scope): Bir değişkenin tanımlandıktan sonra, derleyici tarafından, yalnızca belirli bir blok içinde tanınabilmesidir.

Dosya tanınabilirlik alanı (File scope) : Bir değişkenin tanımlandıktan sonra tüm kaynak dosya içinde, yani tanımlanan tüm fonksiyonların hepsinin içerisinde tanınabilmesidir.

Değişkenleri de tanınabilirlik alanlarına göre ikiye ayırabiliriz :

Yerel değişkenler (local variables)
Global değişkenler (global variables)

C dili için çok önemli olan bu değişken tiplerini şimdi detaylı olarak inceleyeceğiz :

Yerel Değişkenler (local variables)
Blokların içlerinde tanımlanan değişkenlere yerel değişkenler denir. Hatırlanacağı gibi C dilinde blokların içlerinde tanımlanan değişkenlerin tanımlama işlemleri blok içinde ilk işlem olarak yapılmalıydı. (C++ dilinde böyle bir zorunluluk yoktur) Yerel değişkenler blok içlerinde tanımlanan değişkenlerdir, iç içe blokların söz konusu olması durumunda hangi blok içerisinde tanımlanırlarsa tanımlansınlar bunları yerel değişken olarak adlandıracağız. Yani yerel değişken olmaları için en dış blok içinde tanımlanmaları gerekmiyor.

Yerel değişkenlerin tanınabilirlik alanı blok tanınabilirlik alanıdır. Yani yerel değişkenlere yalnızca tanımlandıkları blok içinde ulaşılabilir. Tanımlandıkları bloğun daha dışında bir blok içinde bu değişkenlere ulaşamayız. Örnek :

main ()
{
float x;
...
...
{
int y;
...
x değişkeninin tanınabilirlik alanı

...
y değişkeninin tanınabilirlik alanı

{
int z;
z değişkeninin tanınabilirlik alanı

...
...
}
}
}

Yukarıdaki örnekte tanımlanan değişkenlerden hepsi yerel değişkenlerdir. Çünkü x y z değişkenleri blokların içlerinde tanımlanmışlardır. Bu değişkenlere yalnızca tanımlanmış oldukları blok içinde ulaşabiliriz. Tanımlandıkları blok dışında bunlara ulaşmaya çalışmak derleme aşamasında error ile neticelenecektir.

Dikkat etmemiz gereken bir nokta da şudur : Yukarıdaki örnekte bu değişkenlerin hepsi yerel değişkenler oldukları için blok tanınabilirlik alanı kuralına uyarlar, ancak bu tanınabilirlik alanlarının tamamen aynı olmasını gerektirmez. Yukarıdaki şekilden de görüldüğü gibi x değişkeni en geniş tanınabilirlik alanına sahipken y değişkeni daha küçük ve z değişkeni de en küçük tanınabilirlik alanına sahiptir.

Yukarıdaki örneği genişletelim :

main ()
{
float x = 2.5;

printf(“x = %f\n”, x); /* LEGAL BU ALANDA x’E ULAŞILABİLİR */
printf(“y = %d\n”, y); /* ERROR BU ALANDA y’YE ULAŞILAMAZ. */
printf(“z = %ld\n”, z); /* ERROR BU ALANDA z’YE ULAŞILAMAZ. */
{
int y = 1;

printf(“x = %f\n”, x); /* LEGAL BU ALANDA x’E ULAŞILABİLİR */
printf(“y = %d\n”, y); /* LEGAL BU ALANDA y’E ULAŞILABİLİR */
printf(“z = %ld\n”, z); /* ERROR BU ALANDA z’YE ULAŞILAMAZ. */
...
...

{
long z = 5;

printf(“x = %f\n”, x); /* LEGAL BU ALANDA x’E ULAŞILABİLİR */
printf(“y = %d\n”, y); /* LEGAL BU ALANDA x’E ULAŞILABİLİR */
printf(“z = %ld\n”, z); /* LEGAL BU ALANDA x’E ULAŞILABİLİR */
}
}
}

C dilinde aynı isimli birden fazla değişken tanımlanabilmektedir. Genel kural şudur: iki değişkenin scopları (tanınabilirlik alanları aynı ise) aynı isimi taşıyamazlar, aynı isim altında tanımlanmaları derleme zamanında hata oluşturur. İki değişkenin scoplarının aynı olup olmadıkları nasıl tespit edilecek? Standartlar bu durumu şöyle açıklamaktadır : İki değişkenin scopları aynı kapanan küme parantezinde sonlanıyorsa, bu değişkenlerin scopları aynı demektir.

{
float a;
int b;
double a; /* error */
{
int c;
...
}
}

Yukarıdaki program parçasının derlenmesi derleme aşamasında error ile neticelenir. Çünkü her iki a değişkeninin de tanınabilirlik alanı (scopları) aynıdır. (scopları aynı küme paranteziyle sonlanmaktadır.)

Bu durum error oluşturmasaydı, yukarıdaki örnekte derleyici hangi a değişkeninin yazdırılmak istendiğini nasıl anlayacaktı. Zira bu durum error ile engellenmeseydi printf fonksiyonunun çağırıldığı yerde her iki a değişkeni de tanınabilir olacaktı.

C dilinde farklı tanınabilirlik alanlarına sahip birden fazla aynı isimli değişken tanımlanabilir. Çünkü derleyiciler için artık bu değişkenlerin aynı isimli olması önemli değildir. Bunlar bellekte farklı yerlerde tutulurlar.

{
int x = 100;

printf(“%d\n”, x);
{
int x = 200;

printf(“%d\n”, x);
{
int x = 300;

printf(“%d\n”, x);
}
}
}

Yukarıdaki program parçasında bir hata bulunmamaktadır. Çünkü her üç x değişkeninin de tanınabilirlik alanları birbirlerinden farklıdır. Peki yukarıdaki örnekte içerideki bloklarda x ismini kullandığımızda derleyici hangi x değişkenini kast ettiğimizi nasıl anlayacak? Belirli bir kaynak kod noktasında, aynı isimli birden fazla değişkenin faaliyet alanı (scope) içindeysek, değişken ismini kullandığımızda derleyici hangi değişkene ulaşacaktır? Aynı isimli değişkenlere ulaşma konusundaki kural şudur : C dilinde daha dar faaliyet alanına sahip değişken diğer aynı isimli değişkenleri maskeler.

Konunun daha iyi anlaşılması için bir kaç örnek daha verelim :

{
int a;
char ch;
long b;
double a, f; /* hata aynı tanınabilirlik alanında ve aynı blok seviyesinde aynı isimli iki değişken tanımlanmış */
}


{
int var1;
char var2;
{
int var1;
char var2;
}
}

Yukarıdaki kodda herhangi bir hata bulunmamaktadır. var1 ve var2 değişkenlerinin ismi ikinci kez içteki blokta tanımlama işleminde kullanılmıştır ama artık bu tanınabilirlik alanında farklılık yaratan ayrı bir bloktur, dolayısıyla bir hata söz konusu değildir.




void sample1(void)
{
int k;
...
}

void sample2(void)
{
int k;
...
}

void sample3(void)
{
int k;
...
}

Yukarıdaki kodda da bir hata söz konusu değildir. Zira her üç fonksiyonunda da k isimli bir değişken tanımlanmış olsa da bunların tanınabilirlik alanları tamamen birbirinden farklıdır.
Global Değişkenler (global variables)

C dilinde tüm blokların dışında da değişkenlerin tanımlanabileceğini söylemiştik. İşte bütün blokların dışında tanımlanan değişkenler global değişkenler olarak isimlendirilirler.

Bütün blokların dışı kavramını daha iyi anlamak için bir örnek verelim :

#include <stdio.h>

/* bu bölge tüm blokların dışı burada global bir değişken tanımlanabilir. */

int sample1()
{
...
}
/* bu bölge tüm blokların dışı burada global bir değişken tanımlanabilir. */

int sample2()
{
...
}
/* bu bölge tüm blokların dışı burada global bir değişken tanımlanabilir. */

int sample 3()
{
...
}
/* bu bölge tüm blokların dışı burada global bir değişken tanımlanabilir. */

main()
{
...
}
/* bu bölge tüm blokların dışı burada global bir değişken tanımlanabilir. */

Yorum satırlarının bulunduğu yerler global değişkenlerin tanımlanabileceği yerleri göstermektedir. Bu bölgeler hiçbir fonksiyon içinde değidir. Global değişkenler dosya tanınabilirlik alanı kuralına uyarlar. Yani global değişkenler programın her yerinde ve bütün fonksiyonların içinde tanınabilirler. Burada bir noktayı gözden kaçırmamak gerekir, bir değişken yerel de olsa global de olsa tanımlaması yapılmadan önce bu değişkene ulaşılamaz. Derleme işleminin bir yönü vardır ve bu yön kaynak kod içerisinde yukarıdan aşağıya doğrudur. Bunu şu şekilde de ifade edebiliriz : Global değişkenler tanımlandıkları noktadan sonra kaynak kod içerisinde her yerde tanınabilirler.

#include <stdio.h>

int y; /* y bir global değişken tanımlandıktan sonra her yerde tanınabilir */

void sample(void)
{
y = 10; /*başka bir fonksiyondan da y global değişkenine ulaşılabilir */
}

void main()
{
y = 20;

printf(“y = %d\n”, y); /* y = 20 */
sample();
printf(“y = %d\n”, y); /* y = 10 */
}

Yukarıdaki örnekte y değişkeni tüm blokların dışında tanımlandığı için (ya da hiçbir fonksiyonun içinde tanımlanmadığı için) global değişkendir. y değişkeninin tanınabilirlik alanı dosya tanınabilirlik alanıdır. yani y değişkeni tanımlandıktan sonra tüm fonksiyonların içinde tanınabilir. Yukarıdaki programın çalışması main fonksiyonundan başlayacaktır. y global değişkenine önce 20 değeri atanmakta ve daha sonra bu değer printf fonksiyonuyla ekrana yazdırılmaktadır. Daha sonra sample fonksiyonu çağırılmıştır. sample fonksiyonu çağırılınca kodun akışı sample fonksiyonuna geçer. sample fonksiyonu içinde de y global değişkeni tanınabilir. sample fonksiyonunda global y değişkenine 10 değeri atanmakta ve daha sonra bu değer yine printf fonksiyonuyla ekrana yazdırılmaktadır.

Peki bir global değişkenle aynı isimli yerel bir değişken olabilir mi? Kesinlikle olabilir! İki değişkenin tanınabilirlik alanları aynı olmadığı için bu durum bir hataya neden olmaz. Aynı isimli hem global hem de yerel bir değişkene ulaşılabilecek bir noktada, ulaşılan yerel değişken olacaktır, çünkü daha önce de söylediğimiz gibi aynı tanınabilirlik alanında birden fazla aynı isimli değişken olması durumunda o alan içinde en dar tanınabilirlik alanına sahip olanına erişilebilir. Aşağıdaki kodu çok dikkatli inceleyelim :

int g= 20; /* g global bir değişken */

void sample(void)
{
g = 100; /* global g değişkenine atama yapılıyor. */
printf(“global g = %d\n”, g); /* global g yazdırılıyor. */
}

int main()
{
int g; /* g yerel değişken */

g = 200; /* yerel olan g değişkenine atama yapılıyor */
printf(“yerel g = %d\n”, g); /* yerel g yazdırılıyor. */
sample();
printf(“yerel g = %d\n”, g); /* yerel g yazdırılıyor. */
return 0;
}

Fonksiyonların kendileri de bütün blokların başlarında tanımlandıklarına göre global nesnelerdir. Gerçekten de fonksiyonlar kaynak kodun heryerinden çağırılabilirler. Aynı tanınabilirlik alanına ilişkin aynı isimli birden fazla değişken olamayacaağına göre , aynı isme sahip birden fazla fonksiyon da olamaz. (C++ dilinde aynı isimli fakat farklı parametrik yapıya sahip fonksiyonlar tanımlamak mümkündür.)

Programcıların çoğu global değişkenleri mümkün olduğu kadar az kullanmak ister. Çünkü global değişkenleri kullanan fonksiyonlar başka projelerde kullanılamazlar. Kullanıldıkları projelerde de aynı global değişkenlerin tanımlanmış olması gerekecektir. Dolayısıyla global değişkenlere dayanılarak yazılan fonksiyonların yeniden kullanılabilirliği azalmaktadır.
Parametre Değişkenleri (formal parameters)

Parametre değişkenleri, fonksiyon parametreleri olarak kullanılan değişkenlerdir. Parametre değişkenleri de blok tanınabilirlik alanı kuralına uyarlar. Yani parametresi oldukları fonksiyonun her yerinde tanınabilirler. Fonksiyon parametre değişkeninin scope'u fonksiyonun ana bloğunun kapanmasıyla sonlanacaktır. Yani fonksiyon parametre değişkeninin tanınabilirlik alanı fonksiyonun ana bloğudur.

function(int a, double b)
{

/ *a ve b bu fonksiyonun heryerinde tanınır. */

}

Başka bir örnek :

sample (int a, int b)
{
int a; /* hata aynı tanınırlık alanı içinde ve aynı seviyede aynı isimli değişken */
...
{
int b; /* hata değil tanınabilirlik alanları farklı */
...
}
}

Bu örnekte fonksiyonun ana bloğunun başında tanımlanmış olan a, “aynı tanınabilirlik alanında aynı blok seviyesinde aynı isimli birden fazla değişken olamaz “ kuralına göre geçersizdir. Biri parametre değişkeni biri yerel değişken olmasına karşın, her iki a değişkeni aynı tanınabilirlik alanına sahiptir.

Nesnelerin Ömürleri (storage duration / lifespan)

Ömür, nesnelerin faaliyet gösterdiği zaman aralığını anlatmak için kullanılan bir kavramdır. Bir kaynak kod içinde tanımlanmış nesnelerin hepsi program çalışmaya başladığında aynı zamanda yaratılmazlar. Ömürleri bakımından nesneleri iki gruba ayırabiliriz :

1. Statik ömürlü nesneler (static objects)
2. Dinamik ömürlü nesneler (dynamic / automatic objects)
Statik Ömürlü Nesneler (static duration – static storage class)

Statik ömürlü nesneler, programın çalışmaya başlamasıyla yaratılırlar, programın çalışması bitene kadar varlıklarını sürdürürler, yani bellekte yer kaplarlar. Statik nesneler genellikle amaç kod (.obj) içerisine yazılırlar.
C dilinde statik ömürlü 3 nesne grubu vardır :

global değişkenler
stringler(iki tırnak içerisndeki ifadeler)
statik yerel değişkenler

stringler ve statik yerel değişkenleri daha sonra inceleyeceğiz.

statik ömürlü nesneler olan global değişkenlerin ömürleri konusunda şunları söyleyebiliriz : Global değişkenler programın çalışması süresince yaşayan, yani programın çalışması süresince bellekte yer işgal eden değişkenlerdir.
Dinamik Ömürlü Nesneler

Dinamik ömürlü nesneler programın çalışmasının belli bir zamanında yaratılan ve belli süre faaliyet gösterdikten sonra yok olan (ömürlerini tamamlayan) nesnelerdir. Bu tür nesnelerin ömürleri programın toplam çalışma süresinden kısadır.

C dilinde dinamik ömürlü üç nense grubu vardır :

yerel değişkenler
parametre değişkenleri
dinamik bellek fonksiyonları ile tahsisat yapılarak yaratılmış nesneler

dinamik bellek fonskiyonları ile yaratılmış nesneleri daha sonra inceleyeceğiz.

Yerel değişkenler ve parametre değişkenleri dinamik ömürlü nesnelerdir. Tanımlandıkları bloğun çalışması başladığında yaratılırlar, bloğun çalışması bitince yok olurlar (ömürleri sona erer.) Tanınabilirlik alanları kendi bloklarının uzunluğu kadar olan yerel değişkenlerin ömürleri, program akışışının bu bloğa gelmesiyle başlar ve bloğun çalışma süresi bitince de sona erer . Örnek :

{
double x; /* programın akışı bu noktaya geldiğinde bellekte x için bir yer ayrılıyor. ve blok içinde a yaşamaya devam ediyor.*/
...
} /* programın akışı bloğun sonuna geldiğinde a değişkeninin de
ömrü sona eriyor */


Fonksiyonların parametre değişkenleri de benzer biçimde fonksiyon çağırıldığında yaratılırlar, fonksiyon icrası boyunca yaşarlar, fonksiyonun icrası bitince yok olurlar.

Statik değişkenlerle dinamik değişkenler arasında ilk değer verme(initialization) açısından da fark bulunmaktadır. Statik olan global değişkenlere de yerel değişkenlerde olduğu gibi ilk değer verilebilir.

İlk değer verilmemiş ya da bir atama yapılmamış bir yerel değişkenin içinde rasgele bir değer bulunur. Bu değer o an bellekte o değişken için ayrılmış yerde bulunan rasgele bir sayıdır.(garbage value). Oysa ilk değer verilmemiş, ya da bir atama yapılmamış global değişkenler içinde her zaman 0 değeri vardır. Yani bu değişkenler 0 değeriyle başlatılırlar.

Aşağıdaki kısa programı derleyerek çalıştırınız :

#include <stdio.h>

int globx;

int main()
{
int localy;

printf("globx = %d\n", globx);
printf("localy = %d\n", localy);

return 0;
}

Yerel değişkenler ile global değişkenler arasındaki başka bir fark da, global değişkenlere ancak sabit ifadeleriyle ilk değer verilebilmesidir. Global değişkenlere ilk değer verme işleminde kullanılan ifadede (initializer), değişkenler ya da fonksiyon çağırma ifadeleri kullanılamazlar, ifade yalnızca sabitlerden oluşmak zorundadır. (C++ dilinde böyle bir zorunluluk bulunmamaktadır.)
Ancak yerel değişkenlere ilk değer verilme işleminde böyle bir kıstlama bulunmamaktadır. Örnek :

#include <stdio.h>

int x = 5; /* legal */
int y = x + 5; /* error! ilk değer verme işleminde sabit ifadesi kullanılmamış */
int z = funk(); /* error! ilk değer verme işleminde funksiyon çağırma ifadesi var */

int main()
{
int a = b;
int k = b - 2; /* legal, k yerel değişken olduğu için ilk değer verme ifadesi değişken içerebilir */
int l = funk() /* legal, k yerel değişken olduğu için ilk değer verme ifadesinde fonksiyon çağırma i fadesi bulunabilir. */
...
}

int funk()
{
...
}
Argumanların Parametre Değişkenlerine Kopyalanması

C dilinde bir fonksiyonun parametre değişkenlerinin tanımlandıkları fonksiyon içinde her yerde tanınabildiklerini söylemiştik. Peki bir fonksiyonun parametre değişkenleri ne işe yararlar?
Bir fonksiyonun parametre değişkenleri, o fonksiyonun çağırılma ifadesiyle kendisine gönderilen argumanları tutacak olan yerel değişkenlerdir. Örnek :

fonk(int a)
{
.....
}

main()
{
int x;
....
fonk (x);
}

Yukarıdaki örnekte fonk fonksiyonu x argumanı ile çağırıldığında, programın akışı fonk fonksiyonunun kodunun bulunduğu yere sıçrar, fonk fonksiyonundaki a isimli parametre değişkeni için bellekte bir yer ayrılır ve a parametre değişkenine x değişkeninin değeri atanır. Yani

a = x;

işleminin otomatik olarak yapıldığını söyleyebiliriz.

Başka bir örnek verelim :

#include <stdio.h>

main()
{
int x = 100, y = 200, z;

z = add(x, y);
printf("%d\n", z);
return 0;
}

int add(int a, int b)
{
return a + b;
}

add fonksiyonu çağırıldığında programın akışı bu fonksiyona geçmeden önce, x ve y değişkenlerinin içinde bulunan değerler add fonksiyonunun parametre değişkenleri olan a ve b'ye kopyalanırlar.
__________________