DİZİLER

(ARRAYS)

Chapter 9
DİZİLER
 Bir çok programda ortak karakteristiklere sahip verilerin
işlenmesi gerekmektedir.
 Bu tip durumlarda bu verileri bir dizi olarak yaratmak en
uygun çözüm yolu olarak karşımıza çıkmaktadır.
 Dizi kullanıldığında, tüm elemanlar aynı ad altında
toplanmış olurlar.
 Bir dizinin tüm elemanları aynı tipte (data type) ve aynı
kapsam-sınıfında (storage-class) olmalıdırlar.
 Her bir dizi elemanına, dizi adına elemanın dizi
içerisinde bulunduğu sırayı ifade eden indeks eklenerek
ulaşılır.
DİZİLER
 İndeks olarak kullanılan sayılar, negatif olmayan tam
sayılar olmalıdır (nonnegative integer quantaties).
 n elemana sahip x adlı bir dizi aşağıdaki şekilde
olacaktır;

x[0] x[1] x[2] x[n - 2] x[n - 1]

X tek boyutlu n elemanlı bir dizidir.

DİZİLER
 array_name[index] formatında index ya da subscript
olarak adlandırılan değer bir integer değer (0, 1 gibi), bir
integer değişken veya daha kompleks bir integer ifade
olabilir (örn. integer değer döndüren bir fonksiyon
çağrımı).
 Dizide kullanılan indeks sayısı dizinin boyutunu belirler.
 Örneğin x[i] bir boyutlu dizide bir elemanı ifade ederken,
y[i][j] iki boyutlu bir dizide bulunan bir elemanı ifade
etmektedir.
 İki boyutlu bir diziyi bir tablo gibi (ya da matris) gibi
düşünebilirsiniz (i sırayı, j sütunu ifade etmektedir).
DİZİLERİN TANIMLANMASI
 Diziler de aynı diğer değişkenler gibi tanımlanırlar.
 Tek fark, dizi adı mutlaka dizideki eleman sayısını ifade
eden bir büyüklük belirleyicisini de içermelidir (size
specification).
 Tek boyutlu dizilerde bu belirleyici pozitif bir integer
ifadedir. Genellikle de pozitif bir integer değer kullanılır.
 Tek boyutlu bir dizi genel olarak aşağıdaki şekilde
tanımlanır;
storage-class data-type array_name[integer expression]

static int ogrenci_no[28]

DİZİLERİN TANIMLANMASI
 Dizileri tanımlarken dizi büyüklüğünü bir integer değer
yerine sembolik sabitle ifade etmek programımızın daha
kolay değiştirilebilir olmasını sağlayacaktır.
#define SIZE 80
---
char letter[SIZE];
---
DİZİLERE İLKDEĞER ATANMASI
 Dizileri tanımlarken aynı zamanda ilk değer atamak da
mümkündür.

s-class data-type name[expres] = {value1, value2, value n}

int digits[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

static float x[6] = {0, 0.25, 0, -0.50, 0, 0}
char color[3] = {‘R’, ‘E’, ‘D’}
DİZİLERE İLKDEĞER ATANMASI

digits[0] 0 x[0] 0 color[0] ‘R’

digits[1] 1 x[1] 0.25 color[1] ‘E’
digits[2] 2 x[2] 0 color[2] ‘D’
digits[3] 3 x[3] 0.50
digits[4] 4 x[4] 0
digits[5] 5 x[5] 0
digits[6] 6
digits[7] 7
digits[8] 8
digits[9] 9
DİZİLERE İLKDEĞER ATANMASI
İlk değer atanırken sadece birkaç terimi vermek de
yeterlidir. Bu durumda dizinin geri kalan tüm elemanlarına
0 değeri atanır.
int digits[10] = {3, 3, 3}
static float x[6] = {-0.3, 0, 0.25}
char color[3] = {‘R’, ‘E’}
DİZİLERE İLKDEĞER ATANMASI

digits[0] 3 x[0] -0.3 color[0] ‘R’

digits[1] 3 x[1] 0 color[1] ‘E’
digits[2] 3 x[2] 0.25 color[2] ‘\0’
digits[3] 0 x[3] 0
digits[4] 0 x[4] 0
digits[5] 0 x[5] 0
digits[6] 0
digits[7] 0
digits[8] 0
digits[9] 0
DİZİLERE İLKDEĞER ATANMASI
 Eğer dizi tanımlanırken ilk değer atanıyorsa dizi
büyüklüğünü belirtmek de zorunlu değildir. Dizinin
büyüklüğü atanan ilk değer elemanlarının sayısından
otomatik olarak belirlenir.

int digits[] = {1, 2, 3, 4, 5, 6}

static float x[] = {0, 0.25, 0, -0.5}
 Bu durumda digits dizisi 6 elemanlı, x dizisi de 4 elemanlı
bir dizi olarak yaratılmış olacaktır.
DİZİLERE İLKDEĞER ATANMASI
 Eğer dizi tanımlanırken ilk değer atanıyorsa dizi büyüklüğünü
belirtmenin zorunlu olmadığını söyledik.
 Ancak karakter dizilerinde bu duruma özellikle dikkat edilmesi
gerekmektedir;

char color[3] = “RED”

char color[ ] = “RED”
 İlk durum hatalı olacaktır çünkü 3 elemanlı olduğu belirtilen dizi
NULL karakteri içermeyecektir.
 İkinci durum ise otomatik olarak NULL karakter
ekleneceğinden doğru olacaktır.
 char color[4] = “RED” doğru olacaktır ancak karakter dizileri
için genellikle ikinci yöntem tercih edilir.
DİZİLERİN BİLDİRİMİ
 Program içerisinde tek boyutlu bir dizinin bildiriminin
yapılması gerekiyorsa (dizi external-global olarak
tanımlanmış ya da bir fonksiyonun formal argumanı olarak
kullanacaksak) aşağıdaki kurallar uygulanır;
1. Köşeli parantez içi boş bırakılabilir çünkü zaten
tanımlama sırasında dizinin büyüklüğü verilmiştir. Genel
kabul görmüş bir yöntem olarak parantez içi boş bırakılır.
2. Bildirim esnasında ilk değer atanamaz.
DİZİLERİN BİLDİRİMİ
İlk dosya; İkinci dosya;
int c[ ] = {1, 2, 3}; extern int c[ ];
char message[ ] = “Hello!”; extern char message[ ];
extern void funct1(void) extern void funct1(void)
main () {
{ ....
.... }
}
DİZİLER ÜZERİNDE İŞLEMLER
 Tüm dizi elemanlarını içerecek şekilde tek bir
operasyona C dilinde izin verilmemiştir.
 Bu nedenle iki dizi arasında yapılacak eşitleme,
karşılaştırma ya da buna benzer işlemler büyük bir dikkatle
yapılmalıdır.
 Bu gibi işlemler için genellikle bir for döngüsü kullanılır ve
bu döngü içersinde dizi elemanları arasındaki işlem her bir
eleman için ayrı ayrı icra edilir.
FONKSİYONLARA DİZİ AKTARIMI

 Bir dizi bir fonksiyona arguman olarak yollanabilir.

 Bunun için fonksiyon çağrılırken sadece dizinin adını
yazmak yeterli olacaktır.
 Arguman olarak bir dizi alan fonksiyonlarda, formal
argumanları yazarken, dizilere karşılık gelen argumanlar
için daha önce bahsedilen dizi bildirim kuralları uygulanır.
 Kısaca, formal arguman olan dizi için arguman adının
yanında boş köşeli parantez kullanılır ve ilk değer ataması
yapılamaz.
FONKSİYONLARA DİZİ AKTARIMI

main ()
{
int n;
float avg;
float list[100];
float average(int a, float x[ ]);
....
avg = average(n, list);
}

float average(int a, float x[ ]) { ..... }

FONKSİYONLARA DİZİ AKTARIMI
 Fonksiyonlara parametre aktarımı konusundan daha önce
bahsetmiştik.
 Fonksiyonlara aktarılan parametreler call-by-value olarak
aktarılıyordu yani gerçek arguman, formal argumana yapılan
değişikliklerden etkilenmiyordu.
 Formal arguman olarak diziler kullanıldığında ise biraz dikkatli
olmak gerekir. Parametre aktarımı yine call-by-value olarak
yapılır ancak dizi aktarımında aktarılan sadece dizinin adıdır.
 Yani dizi elemanları fonksiyona aktarılmaz. Elemanlara
fonksiyona aktarılan dizi adı üzerinden ulaşılır.
 Bu nedenle fonksiyon içerisinde dizi elemanları üzerinde
yapılan değişiklikler dizinin kapsam içinde olduğu her yerde etkili
olur.
ÇOKBOYUTLU DİZİLER
(MULTIDIMENSIONAL ARRAYS)
 Çok boyutlu diziler de aynı tek boyutlu diziler gibi tanımlanırlar.
 Tek fark, her bir boyut için dizi adına yeni bir köşeli parantez ilave
etmek gerekmektedir.
 Örneğin, iki boyutlu bir dizi tanımlanırken dizi adının yanına iki
adet köşeli parantez ilave etmek gerekecektir;
int multi[ ][ ] gibi....
 Genel olarak;
storage-class data-type
array_name[expression1][expression2].......
[expression n]
 n boyut sayısını göstermekte olup, tek boyutlu dizilerde olduğu gibi
her bir expression bir tamsayı ifade olmalıdır.
ÇOKBOYUTLU DİZİLER
(MULTIDIMENSIONAL ARRAYS)
 İki boyutlu bir diziyi bir tablo olarak düşünebiliriz.
 Dizinin ilk indeksi tablodaki satırlara, ikinci indeksi de tablonun
sütunlarına karşılık gelecektir. Örneğin int x[m][n] 
col 1 col 2 col 3 col n - 1 col n
row 1
x[0][0] x[0][1] x[0][2] x[0][n - 2] x[0][n - 1]

row 2
x[1][0] x[1][1] x[1][2] x[1][n - 2] x[1][n - 1]
..............................................

row m
x[m-1][0] x[m-1][1] x[m-1][2] x[m-1][n - 2] x[m-1][n - 1]
ÇOKBOYUTLU DİZİLERİN TANIMLANMASI
ve İLKDEĞER ATAMASI
int values[3][4] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}
values[0][0] = 1 values[0][1] = 2 values[0][2] = 3 values[0][3] = 4
values[1][0] = 5 values[1][1] = 6 values[1][2] = 7 values[1][3] = 8
values[2][0] = 9 values[2][1] = 10 values[2][2] = 11 values[2][3] = 12
Ya da şu şekilde de tanımlayabiliriz;
int values[3][4] = { {1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12} }

values[0][0] = 1 values[0][1] = 2 values[0][2] = 3 values[0][3] = 4

values[1][0] = 5 values[1][1] = 6 values[1][2] = 7 values[1][3] = 8
values[2][0] = 9 values[2][1] = 10 values[2][2] = 11 values[2][3] = 12
ÇOKBOYUTLU DİZİLERİN TANIMLANMASI
ve İLKDEĞER ATAMASI
int values[3][4] = {1, 2, 3, 4, 5, 6, 7, 8, 9}
values[0][0] = 1 values[0][1] = 2 values[0][2] = 3 values[0][3] = 4
values[1][0] = 5 values[1][1] = 6 values[1][2] = 7 values[1][3] = 8
values[2][0] = 9 values[2][1] = 0 values[2][2] = 0 values[2][3] = 0

Ya da şu şekilde de tanımlayabiliriz;
int values[3][4] = { {1, 2, 3}, {4, 5, 6}, {7, 8, 9} }
values[0][0] = 1 values[0][1] = 2 values[0][2] = 3 values[0][3] = 0
values[1][0] = 4 values[1][1] = 5 values[1][2] = 6 values[1][3] = 0
values[2][0] = 7 values[2][1] = 8 values[2][2] = 9 values[2][3] = 0
 ÇOKBOYUTLU DİZİLERİN TANIMLANMASI
ve İLKDEĞER ATAMASI
Aşağıdaki tanımlamaları yaptığımızı varsayalım;
int values[3][4] = { {1, 2, 3, 4, 5}, {6, 7, 8, 9, 10}, {11, 12, 13, 14, 15} }
int values[3][4] = { {1, 2, 3, 4}, {5, 6, 7, 8, 9, 10}, {11, 12, 13, 14, 15} };
int values[3][4] = {{1, 2, 3, 4}, {1, 2, 3, 4}, {5, 6, 7, 8}, {11, 12, 13, 14}};

Bu durumların her birinde bir derleyici hatası alırız çünkü eleman

sayısı verilen satır veya sütun sayısından fazla olmaktadır!
ÇOKBOYUTLU DİZİLERİN TANIMLANMASI
ve İLKDEĞER ATAMASI
Üç boyutlu bir diziyi birçok tablodan oluşan bir dizi olarak
düşünebiliriz;
int values[2][3][4] = {
{ /* Tablo 1 */
{1, 2, 3, 4}, /* Satır 1 */
{5, 6, 7, 8}, /* Satır 2 */
{9, 10, 11, 12} /* Satır 3 */ },
{ /* Tablo 2 */
{13, 14, 15, 16}, /* Satır 1 */
{17, 18, 19, 20 }, /* Satır 2 */
{21, 22, 23, 24} /* Satır 3 */ }
}
ÇOKBOYUTLU DİZİLERİN TANIMLANMASI
ve İLKDEĞER ATAMASI
Bir önceki slaytta verilen üç boyutlu dizinin elemanları da aşağıdaki
şekilde verilen ilk değerleri almış olacaktır:

values[0][0][0]= 1 values[0][0][1] = 2 values[0][0][2] = 3 values[0][0][3] = 4

values[0][1][0] = 5 values[0][1][1] = 6 values[0][1][2] = 7 values[0][1][3] = 8
values[0][2][0] = 9 values[0][2][1] = 10 values[0][2][2] = 11 values[0][2][3] = 12

values[1][0][0]= 13 values[1][0][1] = 14 values[1][0][2] = 15 values[1][0][3] = 16

values[1][1][0] = 17 values[1][1][1] = 18 values[1][1][2] = 19 values[1][1][3] = 20
values[1][2][0] = 21 values[1][2][1] = 22 values[1][2][2] = 23 values[1][2][3] = 24
FONKSİYONLARA ÇOK BOYUTLU
DİZİ AKTARIMI
 Tek boyutlu dizilerde olduğu gibi çok boyutlu dizilerde de
fonksiyonlara gerçek argumanlar yollanırken sadece
dizinin adını yazmak yeterlidir.
 Tek boyutlu dizilerde olduğu gibi fonksiyonların formal
argumanlarını yazarken çok boyutlu dizinin her bir boyutu
için dizi adı yanına köşeli parantez ilave edilir.
 Formal arguman olarak yazılırken dikkat edilecek en
önemli husus, tek boyutlu dizilerden farklı olarak, çok
boyutlu dizilerde ilk indeks hariç geri kalan her bir boyutun
büyüklüğü mutlaka tanımlanması gerekliliğidir (neden?)!
FONKSİYONLARA DİZİ AKTARIMI

main ()
{
int n;
float avg;
float list[100][10];
float average(int a, float x[ ][10]);
....
avg = average(n, list);
}

float average(int a, float x[ ][10]) { ..... }