Dizileri kullanan örnekler

DİZİLERİN BİLDİRİLMELERİ

Diziler hafızada bir yer kaplarlar. Programcı, her elemanın tipini ve dizide kaç eleman kullanacağını belirterek bilgisayarın en uygun hafızayı ayırmasını sağlatır. Mesela, bilgisayara 12 elemana sahip bir tamsayı dizisini

1

int c[12];

ile bildiririz. Aynı anda birden fazla dizi bildirimi yapabiliriz. 100 elemana sahip bir b tamsayı dizisi ile 27 elemana sahip bir x tamsayı dizisini aynı anda bildirmek istersek

1

int b[ 100 ] , x [ 27 ] ;

yazarız.
Diziler başka veri tipleri içermek üzere de bildirilebilirler. Örneğin, char tipte bir dizi karakter stringlerini depolamakta kullanılabilir. Karakter stringleri ile dizilerin benzerlikleri 8. ünitede anlatılacaktır. Göstericiler ve diziler arasındaki ilişki ise 7.ünitede gösterilecektir.

DİZİLERİ KULLANAN ÖRNEKLER

Şekil 6.3' teki program, for döngü yapısını yapısı kullanarak 10 elemana sahip bir dizinin tüm elemanlarını 0'a atamaktadır ve diziyi çizelge biçiminde yazdırmaktadır.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

/*Şekil 6.3:fig06_03.c
bir diziye ilk değer vermek*/
# include <stdio.h>
 
 int main ( )
 {
     int n[10] , i ;
 
     for (i=0;i<=9;i++) /*diziye değer ata*/
         n[i]=0;
 
     printf("%s%13s\n","Eleman","Değer");
     for(i=0;i<=9;i++) /*diziyi yazdır*/
     printf("%7d%13d\n",i,n[i]);
 
 return 0;
 }

Eleman      Değer
0                  0
1                  0
2                  0
3                  0
4                  0
5                  0
6                  0
7                  0
8                  0
9                  0
Şekil 6.3 Bir dizinin elemanlarına sıfır değerlerini atamak.

Şekil 6.3'te, ilk printf ifadesi ile (12.satır) for yapısı arasındaki yakın ilgiden dolayı boşluk bırakmadığımıza dikkat ediniz. Bu durumda printf ifadesi, for yapısıyla yazdırılan sütunların başlıklarını yazdırmaktadır. Programcılar, for yapısıyla ilgili olan printf ifadesi arasındaki boşluğu genelde çıkarırlar.

Bir dizinin elemanları dizi bildirimi yapılırken, bildirimden sonra , eşittir işareti ve küme parantezleri içinde virgülle ayrılmış atama değerleriyle ( initializers ) ilk değerlere atanabilir. Şekil 6.4, bir tamsayı dizisine 10 değerle ilk değer atamakta ( 7.satır ) ve diziyi çizelge biçiminde yazdırmaktadır.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

/*Şekil 6.4:fig06_04.c
Diziye bildirim sırasına ilk değerler verme*/
#include <stdio.h>
 
int main( )
{
    int n[10]={32, 27, 64, 18, 95, 14, 90, 70, 60, 37};
    int i;
 
    printf ("%s %13s\n","Eleman","Değer");
 
    for (i = 0; i <= 9 ;i++1)
         printf ("%6d%14d\n",i,n[i]);
 
return 0;
}

Eleman      Değer
0                  32
1                  27
2                  64
3                  18
4                  95
5                  14
6                  90
7                  70
8                  60
9                  37

Şekil 6.4 Dizinin elemanlarına bildirim sırasında ilk değer atamak

Eğer dizideki elemanların sayısından daha az sayıda atama değeri varsa, kalan elemanların hepsi 0 değerine atanır. Örneğin, Şekil 6.3'deki n dizisinin tüm elemanları

1

int n[10] = { 0 };

ifadesiyle 0 değerine atanabilirdi. Bu ifade tarzı ilk elemanı sıfıra atayacak, geriye kalan 9 elemanda, eleman sayısından daha az atama değeri olduğu için sıfıra atanacaktı. Dizilerin otomatik olarak 0 ilk değerine atanmadıklarını hatırlamak önemlidir. Programcı, kalan elemanların otomatik olarak 0'a atanmasını sağlamak için en azından ilk değeri 0'a atamalıdır. Dizi elemanlarına ilk değer olarak 0 vermek için kullanılan bu yöntem, static diziler için derleme zamanında ve otomatik diziler için çalışma zamanında uygulanır.

1

int n[5]={ 32, 27, 64,18, 95, 14};

Şeklinde bir dizi bildirimi ise yazım hatası oluşturacaktır çünkü 5 dizi elemanı ve 6 atama değeri vardır.

Genel Programlama Hataları 6.2
Elemanlarına ilk değer verilmesi gerekilen bir dizinin elemanlarına ilk değer vermeyi unutmak.

Genel Programlama Hataları 6.3
Diziye ilk değer atanacakken dizi elemanından daha çok sayıda atama değeri kullanmak bir yazım hatasıdır.

Eğer atama değerleri ile yapılan bir bildirimde dizinin boyutu belirtilmezse, dizinin eleman sayısı atama listesindeki eleman sayısı olacaktır. Örneğin,

1

int n[ ] = { 1, 2, 3, 4, 5 };

5 elemanlı bir dizi oluşturur.

Şekil 6.5'teki program, 10 elemana sahip s dizisine ilk değer olarak 2,4,6,......20 değerlerini vermektedir. Bu değerler döngü sayıcısını 2 ile çarpıp, çarpıma 2 eklenerek oluşturulmaktadır.

#define önişlemci komutu bu programda tanıtılmıştır. 5. satırdaki

1

#define BOYUT 10

10 değerine sahip, BOYUT isminde bir sembolik bir sabit yaratır. Sembolik sabitler, C önişlemcisi tarafından derleme esnasında yerdeğiştirme metniyle (replacement text) değiştirilecek olan tanıtıcılardır. Program önişlemeye sokulduğunda, BOYUT sembolik sabitiyle karşılaşılan her yerde BOYUT, değiştirme metni olan 10 ile değiştirilecektir. Şekil 6.5'te ilk for döngüsü ( 11.satır ), #define komutundaki BOYUT sabiti 10'dan 1000'e değiştirilerek 1000 elemanlı bir diziyi doldurabilirdi. Eğer BOYUT sembolik sabiti kullanılmasaydı, 1000 elemanlı bir diziyi idare etmek için programda üç yerde değişiklik yapmak zorunda kalacaktık. Programlar büyüdükçe bu teknik, açık programlar yazmak için daha kullanışlı hale gelecektir.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

/*Şekil 6.5:fig06_05.c
s dizisinin elemanlarına
2'den 20'ye kadar olan çift tamsayıları atamak*/
# include <stdio.h>
#define BOYUT 10
 
int main ( )
{
    int s[BOYUT], j ;
 
    for (j=0 ; j <= BOYUT - 1; j++) /*Değerleri hesapla*/ 
        s[j] = 2 + 2 * j ;
 
    printf (" %s %13s \n","Eleman","Değer");
 
    for (j = 0; j <= BOYUT - 1 ; j++) /*Değerleri yazdır*/
        printf ("%7d %13d\n", j, s[j] );
 
return 0;
}
 
 

0                 2
1                 4
2                 6
3                 8
4              10
5              12
6              14
7              16
8              18
9              20
Şekil 6.5 Bir dizinin elemanlarına yerleştirilecek değerleri oluşturmak

Genel Programlama Hataları 6.4
#define ve # include önişlemci komutlarını noktalı virgül ile sonlandırmak. Önişlemci komutlarının, C ifadeleri olmadığını hatırlayınız.

Eğer az önceki #define önişlemci komutu noktalı virgül ile sonlandırılsaydı, BOYUT sembolik sabitiyle karşılaşılan her yerde önişlemci tarafından BOYUT yerine 10; metni yerleştirilecekti. Bu, derleme esnasında yazım hatalarına ya da çalışma esnasında mantık hatalarına neden olur. Önişlemcinin yalnızca bir metin yöneticisi olduğunu hatırlayınız.

Genel Programlama Hataları 6.5
Sembolik bir sabite, çalıştırılabilir bir ifade içinde değer atamak. Sembolik sabit bir değişken değildir. Derleyici tarafından, çalışma zamanında değerleri tutan değişkenler gibi sembolik sabitlere de hafızada yer ayrılmaz.

Yazılım Mühendisliği Gözlemleri 6.1
Her dizinin boyutunu sembolik sabitlerle belirtmek programı daha ölçülendirilebilir yapar.

İyi Programlama Alıştırmaları 6.1
Sembolik sabitler için yalnızca büyük harfler kullanın. Bu, sembolik sabitlerin program içinde göze çarpmasını sağlayarak, programcıya bunların değişken olmadıklarını hatırlatacaktır.

Şekil 6.6, 12 elemanlı a tamsayı dizisinin içindeki değerleri toplamaktadır. for döngüsünün gövdesi (13.satır) toplamayı yapmaktadır.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

/*Şekil 6.6:fig06_06.c
Dizi elemanlarının toplamlarını hesaplamak*/
#include <stdio.h>
#define BOYUT 12
 
int main( )
{
    int a[ BOYUT ]={1, 3, 5, 4, 7, 2, 99,
    16, 45, 67, 89, 45};
    int i, toplam=0;
 
    for (i = 0;i <= BOYUT - 1; i++)
        toplam += a[i];
 
   printf ("Dizideki elemanların toplamı %d dir.\n",toplam);
 return 0;
}
 
 

Şekil 6.6 Dizi elemanlarının toplamlarını hesaplamak

Bir sonraki örneğimiz ise dizileri bir araştırmada toplanacak verilerin özetini yapmak için kullanmaktadır. Aşağıdaki problemi inceleyiniz;
40 öğrenciye kafeteryadaki yiyeceklerin kalitesine 1'den 10'a kadar bir not vermeleri (1 çok kötü ve 10 mükemmel anlamındadır) söylenmiştir. 40 yanıtı bir diziye yerleştirin ve oyların özetini yapın.
Bu örnek tipik bir dizi uygulamasıdır.(bakınız şekil 6.7) Her tipte cevabın (1'den 10'a kadar ) sayısını özetlemek istiyoruz. cevaplar dizisi ( 10.satır ) öğrencilerin cevaplarından oluşan 40 elemanlı bir dizidir. 11 elemana sahip frekans dizisiyle ( 9.satır ) her cevaptan kaç adet olduğunu sayacağız. frekans[0]'ı önemsemeyeceğiz çünkü 1 yanıtı için frekans[0] yerine frekans[1]'i arttırmak daha mantıklıdır. Bu sayede her yanıtı frekans dizisindeki belirteç gibi doğrudan kullanabileceğiz.

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

/* Şekil 6.7: fig06_07.c
Öğrenci Oylama Programı */
#include <stdio.h>
#define CEVAP_BOYUTU 40
#define FREKANS_BOYUTU 11
 
int main( )
{
    int ogrenciCevabi, oylama, frekans[ FREKANS_BOYUTU ] = { 0 };
    int cevaplar[ CEVAP_BOYUTU ] =
    { 1, 2, 6, 4, 8, 5, 9, 7, 8, 10,
    1, 6, 3, 8, 6, 10, 3, 8, 2, 7,
    6, 5, 7, 6, 8, 6, 7, 5, 6, 6,
    5, 6, 7, 5, 6, 4, 8, 6, 8, 10 };
 
for(ogrenciCevabi=0;ogrenciCevabi<=CEVAP_BOYUTU-1;ogrenciCevabi++)
        ++frekans[ cevaplar [ogrenciCevabi ] ];
 
    printf( "%s%17s\n", "Oylama", "Frekans" );
 
    for ( oylama = 1; oylama<= FREKANS_BOYUTU - 1; oylama++ )
        printf( "%6d%17d\n", oylama, frekans[ oylama] );
 
return 0;
}

Oylama     Frekans
1                   2
2                   2
3                   2
4                   2
5                   5
6                 11
7                   5
8                   7
9                   1
10                 3

Şekil 6.7 Basit bir oylama analiz programı

İyi Programlama Alıştırmaları 6.2
Programın açıklığı için çaba gösterin. Kimi zaman, hafızanın ya da işlemci zamanının etkili kullanılması daha açık programlar yazmak için feda edilebilir.

Performans İpuçları 6.1
Kimi zaman performans hususları açıklık hususlarından daha önemlidir.

for döngüsü (16.Satır), cevaplar dizisinden cevapları alarak frekans dizisi içindeki 10 sayıcıdan uygun olanını ( frekans[1]'den frekans [10]'a kadar) arttırır. Döngüdeki kilit ifade 17.satırdadır ;

1

++ frekans [ cevaplar [ ogrenciCevabi ] ] ;

Bu ifade, cevaplar[ ogrencicevabi ] değerine göre uygun frekans sayıcısını arttırır. Örneğin, ogrenciCevabi sayıcı değişkeni 0 olduğunda cevaplar[ ogrencicevabi ] 1'dir. Bu yüzden, ++frekans [ cevaplar [ ogrenciCevabi ] ] ; gerçekte ilk dizi elemanını arttıran

1

++frekans [ 1 ] ;

olarak gösterilebilir.

ogrenciCevabi 1 olduğunda, cevaplar [ ogrenciCevabi ] 2'dir. Bu yüzden, ++ frekans [ cevaplar [ ogrenciCevabi ] ] ; ikinci dizi elemanını arttıran

1

++frekans[2];

biçiminde gösterilebilir.

ogrenciCevabi 2 olduğunda, cevaplar [ ogrenciCevabi ] 6'dır. Bu yüzden, ++ frekans [ cevaplar [ ogrenciCevabi ] ] ; altıncı dizi elemanını arttıran

1

++frekans[6];

biçiminde gösterilebilir. Araştırmadaki yanıtların sayısı ne olursa olsun, sonuçları özetlemek için yalnızca 11 elemanlı bir diziye ( ilk elemanı ihmal edilerek ) ihtiyaç duyulmaktadır. Eğer veri 13 gibi geçersiz değerler içeriyorsa, program frekans [ 13 ]'e 1 eklemeye çalışacaktır.Bu, dizinin sınırları dışında olacaktır. C, bilgisayarın var olmayan bir elemanı kullanmasını engelleyecek herhangi bir dizi sınırı kontrolüne sahip değildir. Bu sebepten, çalışmakta olan bir program uyarı vermeden dizinin dışına çıkabilir. Programcı, bütün dizi kullanımlarının dizi sınırları içinde kalacağından emin olmalıdır.

Genel Programlama Hataları 6.6
Dizi sınırları dışındaki bir elemanı kullanmak

İyi Programlama Alıştırmaları 6.3
Dizi boyunca döngü kullanırken dizi belirteci asla 0'ın altına inmemeli ve her zaman dizideki toplam eleman sayısından az olmalıdır (büyüklük-1). Döngü devam şartının bu aralığın dışındaki elemanlara ulaşılmasını engellediğinden emin olun.

İyi Programlama Alıştırmaları 6.4
for yapısında en yüksek dizi belirtecini kullanarak , "bir eksik" hatalarını ortadan kaldırmak

İyi Programlama Alıştırmaları 6.5
Programlar, hatalı bilginin programın hesaplarını etkilememesi için tüm giriş değerlerinin doğruluğunu onaylamalıdır.

Performans İpuçları 6.2
Dizi sınırlarının dışındaki elemanları kullanmanın yaratacağı hatalar (genelde ciddi hatalardır) sistemden sisteme farklılık gösterir.

Bir sonraki örneğimiz diziden sayıları okumakta ve bilgiyi çizgi grafik biçiminde göstermektedir; sayı yazdırıldıktan sonra, sayının yanında o kadar sayıda yıldız karakteri * yazdırılmaktadır. Yuvalı for yapısı çizgileri çizmektedir. Çizgiyi sonlandırmak için kullanılan printf ( "\n" ) kullanımına dikkat ediniz.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

/* Şekil 6.8: fig06_08.c
Çizgi grafik yazdırma programı */
#include <stdio.h>
#define BOYUT 10
 
int main( )
{
    int n[ BOYUT ] = { 19, 3, 15, 7, 11, 9, 13, 5, 17, 1 };
    int i, j;
 
    printf( "%s%13s%17s\n", "Eleman", "Değer", "Grafik" );
 
    for ( i = 0; i <= SIZE - 1; i++ ) {
        printf( "%7d%13d ", i, n[ i ]) ;
 
    for ( j = 1; j <= n[ i ]; j++ ) /* bir satır yaz */
        printf( "%c", '*' );
 
    printf( "\n" );
}
 
return 0;
}

Eleman           Değer              Grafik
0                        19                  *******************
1                          3                  ***
2                        15                  ***************
3                          7                  *******
4                        11                  ***********
5                          9                  *********
6                        13                  *************
7                          5                  *****
8                        17                  *****************
9                          1                  *

Şekil 6.8 Çizgi grafik çizen program

5.ünitede, zar atma problemini yazmak için daha şık bir yöntem göstereceğimizi söylemiştik. Problem, 6 yüzlü bir zarı 6000 kez atacak ve rasgele sayı üreticisinin gerçekten de rasgele sayılar üretip üretmediğini test edecekti. Bu programın dizilerle yapılmış hali şekil 6.9'da gösterilmiştir.

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

/* Şekil 6.9: fig06_09.c
6000 kez zar atma programı */
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define BOYUT 7
 
int main( )
{
    int yuz,zarAt, frekans[ BOYUT ] = { 0 };
 
    srand( time( NULL ) );
 
    for ( zarAt = 1; zarAt <= 6000; zarAt ++ ) {
        yuz = rand() % 6 + 1;
        ++frekans[ yuz ]; /* Şekil 5.8 20.satırdaki switch'in 
yerine geçer */
    }
 
    printf( "%s%17s\n", "Yüz", "Frekans" );
 
    for ( yuz = 1; yuz<= BOYUT- 1; yuz++ )
        printf( "%3d%17d\n", yuz, frekans [ yuz ] );
 
return 0;
}

Yüz        Frekans
1               1037
2                 987
3              1013
4              1028
5                952
6                983

Şekil 6.9 switch yerine dizileri kullanan zar atma programı

Bu noktaya kadar sadece tamsayı dizilerini tartıştık. Ancak diziler her tipte verileri tutabilir. Şimdi karakter dizilerinde dize [Not: string terimi bilişim sözlüğünde dize olarak açıklanmıştır, ancak önemli olan bu terimin karşılığını kavramaktır.Bu kitapta hem string hem de dize kelimelerini kullanmayı uygun buluyoruz] depolamayı anlatacağız. Şu ana dek sahip olduğumuz tek string işleme yeteneği printf ile bir string yazdırmaktı. "merhaba" gibi bir string aslında, C'de bağımsız karakterlerden oluşmuş static bir dizidir.

Karakter dizileri kendilerine has bir çok özelliğe sahiptir. Bir karakter dizisi, bir string kullanılarak ilk değerlere atanabilir. Örneğin,

1

char string1[ ]="birinci";

biçimindeki bir bildirim, string1 dizisine "birinci" stringi içindeki bağımsız karakterleri atamaktadır. Az önceki bildirimde string1 dizisinin boyutu, derleyiciye bağımlı bir biçimde stringin uzunluğuyla belirlenir.

"birinci" stringinin 7 karakter ile stringi sonlandıran ve null karakter adı verilen özel bir karakter içerdiğini bilmek önemlidir. Bu sebepten, string1 dizisi aslında 8 eleman içermektedir. null karakterin, karakter sabiti olarak gösterimi '\0' biçimindedir. C'de tüm stringler bu karakter ile sonlanır. Bir stringi temsil eden diziler her zaman, stringin içindeki karakter sayısı ve sonlandırıcı null karakteri tutabilecek kadar geniş bildirilmelidir.

Karakter dizilerine, atama listesindeki bağımsız karakter sabitleriyle de ilk değerler atanabilir. Az önceki bildirim

1

char string1 [ ] = { 'b' , 'i' , 'r' ,'i' ,'n' , 'c' ,'i '};

ile denktir.

Bir string aslında karakterlerden oluşan bir dizi olduğundan, string içindeki bağımsız karakterlere dizi belirteci gösterimiyle erişebiliriz. Örneğin, string1[0] 'b' karakteri ve string1[3] 'i' karakteridir.

Bir karakter dizisine scanf ve %s dönüşüm belirtecini kullanarak klavyeden okuyacağımız bir stringi alabiliriz. Örneğin,

1

char string2[20];

bildirimi 19 karakter ve sonlandırıcı null karakteri tutabilecek bir karakter dizisi yaratır.

1

scanf("%s",string2);

ifadesi, klavyeden bir string okur ve okuduğu stringi string2 içine yazar. Dizi isminin scanf fonksiyonuna diğer değişkenler için kullanılan & ile geçirilmediğine dikkat ediniz. & , bir değişkenin hafızadaki konumunu scanf fonksiyonuna bildirir ve böylece o konuma bir değer depolanabilir. Kısım 6.5'te dizilerin fonksiyonlara geçirilişini anlatacağız. Bir dizi isminin, dizinin başlangıç adresi olduğunu ve bu sebepten & kullanmanın gereksiz olduğunu göreceğiz.

Programcı, stringin yazılacağı dizinin, kullanıcının klavyeden yazacağı herhangi bir stringi tutabilmesini garanti altına almalıdır. scanf fonksiyonu, ilk boşluk karakteri girilene dek klavyeden karakter okumaya devam eder; dizinin büyüklüğüne dikkat etmez. Bu sebepten, scanf dizinin sonundan öteye de yazabilir.

Genel Programlama Hataları 6.7
scanf ile klavyeden yazılan stringi tutabilecek kadar geniş olmayan bir karakter dizisi kullanmak, veri kaybına ya da çalışma zamanlı diğer hatalara sebep olabilir.

Bir stringi temsil eden karakter dizisi, printf ve %s dönüşüm belirteciyle yazdırılabilir. string2 dizisi

1

printf ("%s\n",string2);

ile yazdırılabilir.

printf'in scanf gibi karakter dizisinin büyüklüğünü önemsemediğine dikkat ediniz.Stringin karakterleri, sonlandırıcı null karakterle karşılaşılıncaya dek yazdırılır.

Şekil 6.10, bir karakter dizisine string ile ilk değer verilmesini , karakter dizisinin bir string olarak yazdırılmasını ve stringin bağımsız karakterlerine erişilmesini göstermektedir.

Şekil 6.10, for yapısını (16.satır) string1 dizisi boyunca ilerlemek ve %c dönüşüm belirteciyle karakterleri birer boşluk bırakarak yazdırmak için kullanmaktadır. for yapısındaki koşul (string1 != '\0' ), string içinde sonlandırıcı null karakterle karşılaşılmadığı sürece doğrudur.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

/* Şekil 6.10: fig06_10.c
Karakter dizilerini string gibi ele almak */
#include <stdio.h>
 
int main( )
{
    char string1[ 20 ], string2[] = "string literal";
    int i;
 
    printf("Bir string girin: ");
    scanf( "%s", string1 );
    printf( "string1: %s\nstring2: %s\n"
    "karakterler arasında boşlukla string1:\n",
    string1, string2 );
 
    for ( i = 0; string1[ i ] != '\0'; i++ )
        printf( "%c ", string1[ i ] );
 
    printf( "\n" );
return 0;
}

Bir string girin: Herkese merhaba
string1: Merhaba
string2: string literal
karakterler arasında boşlukla string1:
M e r h a b a

Şekil 6.10 Karakter dizilerini string gibi ele almak.

5.ünite, static depolama sınıfı belirtecini anlatmıştı . static bir yerel değişken, program süresince var olur ancak yalnızca fonksiyon gövdesi içinde görülebilir. Yerel dizi bildirimlerinde static kullanarak, dizinin fonksiyon her çağrıldığında yeniden yaratılmasını ve fonksiyondan her çıkıldığında dizinin yok edilmesini engelleyebiliriz. Bu, büyük diziler içeren fonksiyonların sıklıkla çağrıldığı programların çalışma zamanını kısaltır.

Performans İpuçları 6.3
Faaliyet alanına sıklıkla girip çıkan ve otomatik diziler içeren fonksiyonlarda,diziyi static yaparak fonksiyonun her çağrısında dizinin yeniden yaratılmasını engelleyin.

static olarak bildirilen diziler, derleme zamanında yalnızca bir kere otomatik olarak ilk değerlere atanır. Eğer static bir dizi programcı tarafından özellikle ilk değerlere atanmamışsa, dizinin elemanları derleyici tarafından 0'a atanacaktır.

Şekil 6.11, statikDiziIlk fonksiyonunu (20.satır) ve fonksiyon içinde static olarak bildirilmiş bir yerel dizi ile otomatikDiziIlk fonksiyonu (37.satır) ve fonksiyon içinde bildirilmiş otomatik bir yerel dizinin kullanımlarını göstermektedir. statikDiziIlk fonksiyonu iki kez çağrılmıştır (11 ve 14.satırlar). Fonksiyon içindeki static yerel dizi ise derleyici tarafından 0'a atanmıştır. Fonksiyon diziyi yazdırmakta, her elemana 5 eklemekte ve diziyi bir kez daha yazdırmaktadır. Fonksiyon ikinci kez çağrıldığında static dizi, ilk fonksiyon çağrısında depolanan değerleri içermektedir. otomatikDiziIlk fonksiyonu da 2 kez çağrılmıştır (12 ve 15.satırlar). Fonksiyon içindeki otomatik yerel dizinin elemanları 1,2 ve 3 değerlerine atanmıştır. Fonksiyon diziyi yazdırmakta, her elemana 5 eklemekte ve diziyi yeniden yazdırmaktadır. Fonksiyon ikinci kez çağrıldığında dizi elemanları 1,2 ve 3'e yeniden atanmışlardır çünkü dizi otomatik depolama sürecine sahiptir.

Genel Programlama Hataları 6.8
static olarak bildirilmiş bir dizinin elemanlarının, içinde bildirildiği fonksiyonun her çağrılışında 0'a atandığını düşünmek.

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

/* Şekil 6.11: fig06_11.c
Statik dizilere 0 ilk değeri atandı */
#include <stdio.h>
 
void statikDiziIlk ( void );
void otomatikDiziIlk( void );
 
int main( )
{
    printf( "Her fonksiyona ilk çağrı:\n" );
    statikDiziIlk ( );
    otomatikDiziIlk ( );
    printf( "\nHer fonksiyona ikinci çağrı:\n" );
    statikDiziIlk ( );
    otomatikDiziIlk ( );
return 0;
}
 
/* a statik yerel diziyi kanıtlayan fonksiyon */
void statikDiziIlk ( void )
{
    static int a[ 3 ];
    int i;
 
    printf( "\nstatikDiziIlk'e girerken değerler:\n" );
 
    for ( i = 0; i <= 2; i++ )
        printf( "dizi1[%d] = %d ", i, a[ i ] );
 
    printf( "\nstatikDiziIlk'den çıkarken değerler:\n" );
 
    for ( i = 0; i <= 2; i++ )
        printf( "dizi1[%d] = %d ", i, a[ i ] += 5 );
}
 
/* otomatik yerel diziyi kanıtlayacak fonksiyon */
void otomatikDiziIlk ( void )
{
    int a[ 3 ] = { 1, 2, 3 }, i;
 
    printf( "\n\notomatikDiziIlk'e girerken değerler:\n" );
 
    for ( i = 0; i <= 2; i++ )
        printf("dizi1 [ %d ] = %d ", i, a[ i ] );
 
    printf( "\notomatikDiziIlk'den çıkarken değerler:\n" );
 
    for ( i = 0; i <= 2; i++ )
        printf( "dizi1[ %d ] = %d ", i, a[ i ] += 5 );
}

Her fonksiyona ilk çağrı:
statikDiziIlk'e girerken değerler:
dizi1[0] = 0 dizi1[1] = 0 dizi1[2] = 0
statikDiziIlk'den çıkarken değerler:
dizi1[0] = 5 dizi1[1] = 5 dizi1[2] = 5

otomatikDiziIlk'e girerken değerler:
dizi1[0] = 1 dizi1[1] = 2 dizi1[2] = 3
otomatikDiziIlk'den çıkarken değerler:
dizi1[0] = 6 dizi1[1] = 7 dizi1[2] = 8

Her fonksiyona ikinci çağrı:

statikDiziIlk'e girerken değerler:
dizi1[0] = 5 dizi1[1] = 5 dizi1[2] = 5
statikDiziIlk'den çıkarken değerler:
dizi1[0] = 10 dizi1[1] = 10 dizi1[2] = 10

otomatikDiziIlk'e girerken değerler:
dizi1[0] = 1 dizi1[1] = 2 dizi1[2] = 3
otomatikDiziIlk'den çıkarken değerler:
dizi1[0] = 6 dizi1[1] = 7 dizi1[2] = 8

Şekil 6.11 Statik dizilere programcı tarafından ilk değerleri atanmazsa, otomatik olarak 0 atanır.