Depolama sınıfı

DEPOLAMA SINIFLARI

2. üniteden 4. üniteye kadar değişken isimleri için tanıtıcılar kullandık. Değişkenlerin özellikleri isim, tip ve değer içermektedir. Bu ünitede, tanıtıcıları ayrıca programcı tarafından tanımlanan fonksiyonların isimleri olarak da kullandık. Aslında bir programdaki her tanıtıcı depolama sınıfı,depolama süreci,faaliyet alanı ve bağlama özelliklerine de sahiptir.

C auto,register,extern ve static depolama sınıfı belirteçleriyle belirlenebilen dört depolama sınıfına sahiptir. Bir tanıtıcının depolama sınıfı, depolama süreci, faaliyet alanı ve bağlama özelliklerinin belirlenmesine yardımcı olur. Bir tanıtıcının depolama süreci o tanıtıcının hafızada tutulduğu zaman aralığıdır. Bazı tanıtıcılar oldukça kısa, bazıları yeniden yaratılıp yok edilerek, bazıları ise programın çalıştığı tüm süre boyunca hafızada tutulur. Bir tanıtıcının faaliyet alanı tanıtıcının program içinde kullanılabileceği yerdir. Bazı tanıtıcılar, tüm program boyunca, diğerleri ise programın bazı kısımlarında kullanılabilirler. Bir tanıtıcının bağlaması, çok kaynaklı bir program ( Bu konuyu 14. ünitede inceleyeceğiz) içinde tanıtıcının yalnızca o andaki kaynak dosyada mı yoksa uygun bildirimlerle herhangi bir kaynak dosyada mı geçerli olacağını belirler. Bu kısım, depolama sınıflarını ve depolama süreçlerini açıklamaktadır. Kısım 5.12, tanıtıcıların faaliyet alanlarını açıklamaktadır. 14. ünite, tanıtıcı bağlama ve birden çok kaynak dosyası ile programlamayı açıklamaktadır.

4 depolama sınıfı belirteci, 2 depolama sürecine ayrılabilir: Otomatik depolama süreci ve statik depolama süreci. auto ve register anahtar kelimeleri, otomatik depolama süreçli değişkenler bildirmek için kullanılırlar. Otomatik depolama süreçli değişkenler, bildirildikleri blok içine girildiğinde yaratılır, blok aktif iken varolur ve bloktan çıkıldığında yok edilirler.

Yalnızca değişkenler otomatik depolama sürecine sahip olabilirler. Bir fonksiyonun yerel değişkenleri ( parametre listesi yada fonksiyon gövdesi içinde bildirilenler) otomatik depolama sürecine sahiptirler. auto anahtar kelimesi, otomatik depolama süreçli değişkenler bildirmek için kullanılır. Örneğin, aşağıdaki bildirim double tipteki x ve y değişkenlerinin otomatik yerel değişkenler olduğunu ve yalnızca bildirimin yer aldığı fonksiyon gövdesi içinde varolduğunu belirtir:

1

auto double x, y;

Yerel değişkenler aksi belirtilmedikçe otomatik depolama sürecine sahip olduklarından, auto anahtar kelimesi nadiren kullanılır. Bu noktadan itibaren otomatik depolama süreçli değişkenlere kısaca otomatik değişkenler diyeceğiz.

Performans İpuçları 5.1
Otomatik depolama hafızayı korumak için kullanılır.Çünkü otomatik değişkenler yalnızca ihtiyaç duyulduklarında varolurlar.Bunlar, bildirildikleri fonksiyon çalıştırıldığında yaratılır, fonksiyonun çalıştırılması sona erdiğinde yok edilirler.

Yazılım Mühendisliği Gözlemleri 5.10
Otomatik depolama, en az yetki prensibinin bir başka örneğidir. Değişkenler neden hafızada depolansın ve neden gerçekte ihtiyaç duyulmamalarına rağmen erişilebilsin? Bir programın makine dili versiyonunda veri, hesaplamalar ve diğer işlemler için genellikle yazmaçlara ( register ) yüklenir.

Performans İpuçları 5.2
register depolama sınıfı belirteci, otomatik değişken bildiriminden önceye yerleştirilerek derleyiciye, değişkeni, bilgisayarın yüksek hızlı donanım yazmaçlarından birine yerleştirmesi önerilebilir.Eğer sayıcı ya da toplam gibi sıklıkla kullanılan değişkenler donanım yazmaçları içine yerleştirilebilirse, değişkenleri hafızadan yazmaçlara sık sık yüklemek ve sonuçları hafızaya yazmak yükü ortadan kaldırılabilir.

Derleyici register bildirimlerini ihmal edebilir. Örneğin derleyicinin kullanımına uygun yeterli sayıda yazmaç olmayabilir. Aşağıdaki bildirim, sayici değişkeninin tamsayı olduğunu ve bilgisayarın yazmaçlarından birine yerleştirileceğini ve ayrıca ilk değer olarak 1 değerine atanacağını belirtmektedir:

1

register int sayici = 1;

register anahtar kelimesi yalnızca otomatik depolama süreçli değişkenlerle kullanılabilir.

Performans İpuçları 5.3
Genellikle register bildirimleri gereksizdir. Bugünkü derleyicilerin bir çoğu sıklıkla kullanılan değişkenleri tanıyıp, programcının register bildirimi yapmasına gerek kalmadan değişkeni yazmaçlardan birinin içine koymaya karar verir.

extern ve static anahtar kelimeleri, statik depolama süreçli değişken ve fonksiyon tanıtıcıları bildirmek için kullanılırlar. Statik depolama süreçli tanıtıcılar, program çalışmaya başladığı andan itibaren var olurlar. Değişkenler için program çalışmaya başladığında bir kereliğine depolama için yer ayrılır ve ilk değerler verilir. Fonksiyonlar için fonksiyon ismi program çalışmaya başladığında varolur ancak değişkenler ve fonksiyon isimleri program çalışmaya başladığı andan itibaren varolsalar da bu, tanıtıcıların program boyunca kullanılacakları anlamına gelmez. Depolama süreci ve faaliyet alanı kısım 5.12'de göreceğimiz gibi ayrı konulardır.

Statik depolama zamanlı iki tip tanıtıcı vardır: dış tanıtıcılar (global değişkenler ve fonksiyon isimleri gibi) ve static depolama zamanı belirteciyle bildirilmiş yerel değişkenler. Global değişkenler ve fonksiyon isimleri, aksi belirtilmedikçe extern depolama sınıfındadırlar. Global değişkenler, değişken bildirimleri herhangi bir fonksiyon tanımının dışında yapılarak oluşturulurlar ve değerlerini programın çalışma zamanı boyunca korurlar. Global değişkenler ve fonksiyonlar, bildirimlerini ve tanımlanmalarını izleyen fonksiyonlar tarafından ya da dosya tanımlamalarında kullanılabilirler. Bu, fonksiyon prototiplerinin kullanılmasının bir sebebidir. printf çağıran bir programa stdio.h eklediğimizde, fonksiyon prototipi programın en başında yer alır ve böylece printf dosyanın geri kalanında bilinir.

Yazılım Mühendisliği Gözlemleri 5.11
Bir değişkeni yerel değil de global olarak bildirmek, bir değişkene erişmemesi gereken bir fonksiyonun, değişkeni yanlışlıkla değiştirmesi gibi istenmeyen yan etkilere sebep olabilir.Genelde bazı belirli ve çok özel durumlar hariç (14.Ünitede anlatıldığı gibi) global değişkenlerin kullanımından kaçınılmalıdır.

İyi Programlama Alıştırmaları 5.10
Yalnızca belli bir fonksiyonda kullanılan değişkenler o fonksiyon içinde yerel olarak bildirilmelidir.

static anahtar kelimesiyle bildirilen yerel değişkenler yalnızca bildirildikleri fonksiyon içinde bilinmektedirler ancak otomatik değişkenlerden farklı olarak, static yerel değişkenler fonksiyondan çıkıldıktan sonrada değerlerini korurlar. Fonksiyonun bir sonraki çağrısında, static yerel değişken, fonksiyondan en son çıkıldığındaki değeri tutmaktadır. Şimdiki ifademiz say yerel değişkenini static olarak bildirmekte ve değişkene ilk değer olarak 1 vermektedir.

1

static int say = 1;

Statik depolama zamanlı tüm nümerik değişkenler, programcı tarafından özel olarak bir başka değere atanmadıkça ilk değer olarak 0'a atanırlar. (Gösterici değişkenleri 7.Ünitede anlatıldığı gibi ilk değer olarak NULL'a atanırlar)

Genel Programlama Hataları 5.13
Bir tanıtıcı için birden çok depolama sınıfı belirteci kullanmak.Bir değişkene yalnızca bir depolama sınıfı belirteci uygulanabilir.

extern ve static anahtar kelimeleri , dış tanıtıcılara uygulandıklarında özel anlamlara gelirler. 14.Ünitede, extern ve static anahtar kelimelerinin dış tanıtıcılarla ve çok kaynak dosyalı programlarla özel olarak nasıl kullanılacağını anlatacağız.

FAALİYET ALANI KURALLARI

Bir tanıtıcının faaliyet alanı, tanıtıcının kod içinde kullanılabileceği program kısmıdır. Örneğin, bir blok içinde yerel değişken bildirirsek, bu değişken yalnızca o blok içinde ya da o bloğun içine yuvalanmış bloklarda kullanılabilir. Bir tanıtıcının 4 faaliyet alanı şu şekilde adlandırılır: fonksiyon faaliyet alanı ,dosya faaliyet alanı, blok faaliyet alanı ve fonksiyon prototipi faaliyet alanı.

Etiketler (bir tanıtıcının sonuna iki nokta üst üste konurak oluşturulur, örneğin basla: ) fonksiyon faaliyet alanına sahip tek tanıtıcıdır. Etiketler, bulundukları fonksiyon içinde her yerde kullanılabilirler ancak fonksiyon gövdesi dışında kullanılamazlar. Etiketler, switch yapılarında (case etiketleri gibi) ve goto ifadelerinde (14.Üniteye bakınız) kullanılırlar. Etiketler, fonksiyonların diğerlerinden gizledikleri uygulama detaylarıdır. Bu saklama ( daha teknik olarak bilgi saklama ), iyi yazılım mühendisliğinin en temel prensiplerinden biridir.

Herhangi bir fonksiyonun dışında bildirilmiş tanıtıcılar, dosya faaliyet alanına sahiptir. Bu tarzda bir tanıtıcı, bildirildiği yerden dosyanın sonuna kadar tüm fonksiyonlar tarafından bilinir. Global değişkenler, fonksiyon tanımları ve fonksiyon dışına yerleştirilmiş fonksiyon prototipleri dosya faaliyet alanına sahiptir.

Bir blok içinde bildirilmiş tanıtıcılar, blok faaliyet alanına sahiptir. Blok faaliyet alanı, bloğu sonlandıran küme parantezine( } ) ulaşıldığında sona erer. Fonksiyonun başında bildirilen yerel değişkenler, fonksiyon parametreleri gibi blok faaliyet alanına sahiptir ve fonksiyon için yerel değişkenler olarak bilinirler. Herhangi bir blok, değişken bildirimleri içerebilir. Bloklar yuvalandığında ve dıştaki bloktaki tanıtıcı içteki bloktaki tanıtıcıyla aynı isme sahip olduğunda, dış bloktaki tanıtıcı iç blok sona erene kadar saklanır. Bu, içteki blok çalıştırılırken içteki bloğun yalnızca kendi yerel tanıtıcısının değerini göreceği ve dışındaki blokta yer alan ve aynı isme sahip olan tanıtıcının değerini kullanmayacağı anlamına gelir. static olarak bildirilmiş yerel değişkenler, program çalışmaya başladığı andan itibaren var olsalar da hala blok faaliyet alanına sahiptirler. Bu sebepten, depolama süreci bir tanıtıcının faaliyet alanını etkilemez.

Fonksiyon prototipi faaliyet alanına sahip tek tanıtıcı, fonksiyon prototipinin parametre listesinde kullanılan tanıtıcılardır. Daha önceden bahsedildiği gibi, fonksiyon prototiplerinin parametre listelerinde isim olması gerekmez, derleyici bu isimleri ihmal eder. Fonksiyon prototipinde kullanılan tanıtıcılar, programın herhangi bir yerinde karışıklık olmadan yeniden kullanılabilir.

Genel Programlama Hataları 5.14
Programcı dış bloktaki tanıtıcının iç blok çalışırken aktif olmasını isterken, yanlışlıkla iç blokta kullandığı tanıtıcı ismiyle dış blokta kullandığı tanıtıcı isminin aynı olması.

İyi Programlama Alıştırmaları 5.11
Dış faaliyet alanlarında, isimleri gizleyen değişken isimlerinden kaçının. Bu, bir programda aynı tanıtıcı ismini bir kez daha kullanmayarak sağlanabilir.

Şekil 5.12 global değişkenler, otomatik yerel değişkenler ve static yerel değişkenler için faaliyet alanı konularını göstermektedir. Global olarak bir x değişkeni bildirilmiş ve bu değişkene ilk değer olarak 1 atanmıştır. Bu global değişken, x adında bir değişkenin bildirildiği herhangi bir bloktan (ya da fonksiyon) gizlenmiştir. main içinde x yerel değişkeni bildirilmiş ve bu değişkene ilk değer olarak 5 atanmıştır. Daha sonra bu değişken yazdırılarak main içinde global değişken olan x'in saklandığı gösterilmiştir. main içinde yeni bir blok tanımlanmış ve bu blok içinde başka bir yerel değişken olan x bildirilmiş ve bu değişkene ilk değer olarak 7 atanmıştır. Bu değer yazdırılarak x'in dış blok olan main'den saklandığı gösterilmiştir. 7 değerine sahip olan x değişkeni, bloktan çıkıldığında otomatik olarak yok edilmiştir ve main dış bloğu içindeki yerel değişken olan x yeniden yazdırılarak artık bu değişkenin daha fazla saklanmadığı gösterilmiştir. Program, argüman almayan ve geriye değer döndürmeyen üç fonksiyon tanımlamıştır. a fonksiyonu, otomatik bir x değişkeni bildirmiş ve bu değişkene 25 ilk değerini atamıştır. a çağrıldığında değer yazdırılmış, arttırılmış ve fonksiyondan çıkılmadan bir kez daha yazdırılmıştır. Fonksiyon her çağrıldığında x otomatik değişkeni yeniden 25 değerine atanmıştır. b fonksiyonu, static bir x değişkenini bildirmekte ve bu değişkene ilk değer olarak 50 atamaktadır. static olarak bildirilen yerel değişkenler, faaliyet alanı dışında olsalar bile değerlerini korurlar. b çağrıldığında x yazdırılmış , arttırılmış ve fonksiyondan çıkılmadan önce bir kez daha yazdırılmıştır. Bu fonksiyonun bir sonraki çağrısında, static yerel değişken x, 51 değerini içerecektir. c fonksiyonu, herhangi bir değişken bildirmemektedir. Bu sebepten, x değişkeninden bahsettiğinde, global x değişkeni kullanılmaktadır. c çağrıldığında global değişken yazdırılmakta, 10 ile çarpılmakta ve fonksiyondan çıkılmadan önce bir kez daha yazdırılmaktadır. Sonuç olarak program, main içindeki yerel değişken x'i, fonksiyon çağrılarının hiçbirinin x' in değerini değiştirmediğini çünkü tüm fonksiyonların başka faaliyet alanlarındaki değişkenlerden söz ettiğini göstermek için yeniden yazdırılmıştır.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

/* Fig. 5.12: fig05_12.c
Bir faaliyet alanı örneği */
#include <stdio.h>
 
void a( void ); /* fonksiyon prototipi*/
void b( void ); /* fonksiyon prototipi */
void c( void ); /* fonksiyon prototipi */
 
int x = 1; /* global değişken */
 
int main( )
{
   int x = 5; /* main'e yerel değişken */
 
   printf ("main'in faaliyet alanı dışındaki yerel x değişkeni %d olur.\n", x );
 
   { /* yeni faaliyet alanına başla */
      int x = 7;
 
      printf( "main'in faaliyet alanı içindeki yerel x değişkeni %d olur.\n", x );
   } /* yeni faaliyet alanını bitir*/
 
   printf( "main'in faaliyet alanı dışındaki yerel x değişkeni %d olur.\n", x );
 
   a( ); /* a automatic yerel x' e sahiptir.*/
   b( ); /* b static yerel x' e sahiptir. */
   c( ); /* c global x kullanır. */
   a( ); /* a automatic yerel x' e tekrar ilk değer atar.*/
   b( ); /* static yerel x önceki değerini korur */
   c( ); /* global x ' de değerinin korur. */
 
   printf( "main içindeki yerel x %d olur.\n", x );
   return 0;
   }
 
  void a( void )
  {
  int x = 25; /* a her çağrıldığında ilk değeri atanır */
 
  printf( "\na'ya girildikten sonra yerel x %d olur.\n", x );
  ++x;
  printf( "a'dan çıkmadan önce yerel x %d olur.\n", x );
  }
 
  void b( void )
  {
 static int x = 50; /* sadece static ilk değer atama */
  /* b'nin ilk çağırılması */
  printf( "\nb'ye girerken static x %d olur.\n", x );
   ++x;
  printf( "b'den çıkarken önce static x %d olur.\n", x );
  }
 
  void c( void )
  {
  printf( "\nc' ye girerken global x %d olur.\n", x );
  x *= 10;
  printf( "c' den çıkarken global x %d olur.\n", x );
 }

main'in faaliyet alanı dışında yerel x değişkeni 5 olur.
main'in faaliyet alanı içindeki yerel x  değişkeni 7 olur.
main'in faaliyet alanı dışında yerel x değişkeni 5 olur.






a'ya girildikten sonra yerel x  25 olur.
a'dan çıkmadan önce yerel x 26 olur.
b'ye girerken static x  50 olur.
b'den çıkarken static x 51 olur.
c' ye girerken global x  1 olur.
c' den çıkarken global x  10 olur.
a'ya girildikten sonra yerel x  25 olur.
a'dan çıkmadan önce yerel x 26 olur.
b'ye girerken static x  51 olur.
b'den çıkarken static x 52 olur.
c' ye girerken global x  10 olur.
c' den çıkarken global x  100 olur.
main içindeki yerel x 5 olur.
Şekil 5.12 Faaliyet Alanı Örneği