Diziler aynı veri çeşidinden olan değişkenlerin aynı isim altında tanımlanması olarak ifade edilebilir. Diziler kullanılarak, aynı isimle birden fazla değişkene erişilebilir ve işlem yapılabilir.
Diziler tek ya da çok boyutlu olarak tanımlanabilir ve dizi boyutu ihtiyaca göre ayarlanabilir.
Diziler belirli bir veri türünden tanımlanabileceğinden, dizilerde sadece aynı veri türünden değişken değerleri yer alabilir.
Tek boyutlu diziler
C++’da, aynı veri tipinden olan değişkenleri tek bir isim altında toplayarak tek boyutlu diziler oluşturabiliriz. Programlarda, aynı veri türünden ve farklı isimlere sahip çok fazla sayıda değişken tanımlamak yerine, dizi bildirimi yapmak suretiyle sadece tek isim kullanarak aynı sayıda değişken tanımlamak daha pratik bir sistem ve kolaylık sağlar. Dizi tanımlandığında, dizinin her bir elemanına dizi adı ile birlikte 0’dan başlayarak kullanılan indeks değeri ile erişim sağlanır.
Tek boyutlu dizi bildirimi
Tek boyutlu dizilerin bildirimi için kullanılan genel yapı aşağıda gösterilmektedir:
1
2
veri-çeşidi dizi-adı [boyut];
Bir dizi bildirimi 3 temel elemandan oluşur. Yukarıdaki satırda yer alan veri-çeşidi ifadesi dizinin içerdiği değişkenlerin veri çeşidini dizi-adı ifadesi dizinin adını, boyut ifadesi ise dizideki değişken sayısını yani dizi boyutunu göstermektedir. Aşağıdaki işlem satırı idizi adlı ve 10 elemanlı int bir dizi tanımlar:
1
2
3
int idizi[10];
Tek boyutlu dizilere atama işlemcisi ile değer atama
Bir dizinin bildirimini yaptıktan sonra, atama işlemcisini kullanarak bu diziye değerler atanabilir. Dizi içinde yer alan bir elemana değer atamak veya eleman değerine erişmek için, dizi adı ile birlikte 0’dan başlayan indeks değeri kullanılır.
C++’da bir dizinin ilk elemanına 0 değeri ile erişim sağlanır.
1
2
3
4
5
6
int idizi[10]; // 10 elemanlı idizi adlı bir dizi oluşturur.
idizi[0] = 21; // Dizinin ilk elemanına 21 değerini atar.
idizi[3] = 36; // Dizinin dördüncü elemanına 36 değerini atar.
idizi[7] = 174; // Dizinin sekizinci elemanına 174 değerini atar.
Yukarıdaki ilk işlem satırında idizi adlı ve 10 elemanlı int bir dizi oluşturulur. Böylece, bilgisayar belleğinde 10 int değişkeni için yer ayrılmış olur. İkinci işlem satırı, dizinin ilk elemanına 21 sayısını, üçüncü işlem satırı dizinin dördüncü elemanına 36 sayısını ve dördüncü işlem satırı dizinin sekizinci elemanına 174 sayısını atar. Burada, dizi[0] ifadesinin dizinin ilk elemanını gösterdiğine dikkat ediniz. Aşağıdaki şekil üzerinde atanan değerler gösterilmekte, diğer eleman değerleri ise boş gözükmektedir. Aslında, dizinin atanmamış değerleri, tıpkı değişkenlerde olduğu gibi, rastgele bir değer içerir. Aşağıdaki şekilde, bellekte ayrılmış ve değer atanmamış değerler renksiz, değer atanmış bellek bölümleri ise renkli olarak gösterilmektedir:
| dizi[0] | dizi[1] | dizi[2] | dizi[3] | dizi[4] | dizi[5] | dizi[6] | dizi[7] | dizi[8] | dizi[9] |
|---|---|---|---|---|---|---|---|---|---|
| 21 | 36 | 174 |
Şimdi, bu özelliği bir örnek üzerinde incelemeye çalışalım:
Örnek
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#include <iostream>
using namespace std;
int main(void)
{
int dizi[5];
dizi[0] = 27; // Dizinin ilk elemanına değer atama
dizi[1] = 348; // Dizinin 2.elemanına değer atama
dizi[2] = 51; // Dizinin 3.elemanına değer atama
dizi[3] = 1254; // Dizinin 4.elemanına değer atama
dizi[4] = 127; // Dizinin 5.elemanına değer atama
cout << dizi[0] << " ";
cout << dizi[1] << " ";
cout << dizi[2] << " ";
cout << dizi[3] << " ";
cout << dizi[4];
return 0;
}
Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:
1
2
3
27 348 51 1254 127
Program önce beş elemanlı int bir dizi bildirimi yapar. Sonra, int dizinin elemanlarına sıra ile birer değer atar. Daha sonra bu değerleri ekrana yazar.
Bir diziye atanan değerler düzenli değilse, her bir atama işlemi için ayrı bir işlem satırı kullanılır. Eğer, diziye atanan değerler düzenli ise, dizi elemanlarına değer atamak için döngüler kullanılır. Şimdi, bu özelliği örnekler üzerinde incelemeye çalışalım:
Örnek
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include <iostream>
using namespace std;
int main(void)
{
int idizi[10];
int id;
// Dizinin elemanlarına 1-10 arasındaki değerleri sıra ile atama
for (id=0; id<10; id++) {
idizi[id] = id+1;
}
// Dizi değerlerini ekrana yazma
for (id=0; id<10; id++) {
cout << idizi[id] << " ";
}
return 0;
}
Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:
1
2
3
1 2 3 4 5 6 7 8 9 10
Program önce 10 elemanlık int bir dizi bildirimi yapar. Bir for döngüsü ile dizi elemanlarına 1-10 arasındaki değerleri atar. İkinci for döngüsü ile dizi değerlerini ekrana yazar. İlk for döngüsü sonunda dizinin aldığı değerler aşağıda gösterildiği şekildedir:
| dizi[0] | dizi[1] | dizi[2] | dizi[3] | dizi[4] | dizi[5] | dizi[6] | dizi[7] | dizi[8] | dizi[9] |
|---|---|---|---|---|---|---|---|---|---|
| 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 |
Örnek
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <iostream>
using namespace std;
int main(void)
{
int dizi[10];
int id;
for (id=0; id<10; id++) {
if (id==0) dizi[id] = 2;
else dizi[id] = dizi[id-1] * 2;
}
for (id=0; id<10; id++) {
cout << dizi[id] << " ";
}
return 0;
}
Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:
1
2
3
2 4 8 16 32 64 128 256 512 1024
Program önce 10 elemanlık int bir dizi bildirimi yapar. İlk for döngüsü ile ilk dizi elemanına 2 değerini atar. Sonraki her tekrarda bir önceki eleman değerinin iki katını alarak dizi elemanına atar. İkinci for döngüsü ile dizi değerlerini ekrana yazar. İlk for döngüsü sonunda dizinin aldığı değerler aşağıda gösterildiği şekildedir:
| dizi[0] | dizi[1] | dizi[2] | dizi[3] | dizi[4] | dizi[5] | dizi[6] | dizi[7] | dizi[8] | dizi[9] |
|---|---|---|---|---|---|---|---|---|---|
| 2 | 4 | 8 | 16 | 32 | 64 | 128 | 256 | 512 | 1024 |
Şimdi, aşağıda vereceğimiz örnekle char dizi tanımlamaları ve bu dizilere değer atanmasını incelemeye çalışalım:
Örnek
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
#include <iostream>
using namespace std;
int main(void)
{
char cdizi1[7];
char cdizi2[8];
int id;
cdizi1[0] = cdizi2[0] = 'D';
cdizi1[1] = cdizi2[1] = 'i';
cdizi1[2] = cdizi2[2] = 'z';
cdizi1[3] = cdizi2[3] = 'i';
cdizi1[4] = cdizi2[4] = 'l';
cdizi1[5] = cdizi2[5] = 'e';
cdizi1[6] = cdizi2[6] = 'r';
cdizi2[7] = '\0'; // İkinci diziye dizi sonu karakteri ekler
for (id=0; id<7; id++) cout << cdizi1[id];
cout << "\n";
cout << cdizi2;
return 0;
}
Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:
1
2
3
4
Diziler
Diziler
Program, yedi elemanlı cdizi1 adlı ve sekiz elemanlı cdizi2 adlı iki adet karakter dizisi bildirimi yapar. Her iki karakter dizisinin ilk yedi elemanına “Diziler” kelimesinin harflerini sıra ile atar. cdizi1 karakter dizisinin elemanlarını bir for döngüsü ile karakter bazında erişim sağlayarak tek tek ekrana yazar. Bu durumda, cdizi1 karakter dizisi sonunda karakter dizisi sonu karakterine (‘\0) ihtiyaç duyulmaz. Ancak, cdizi2 karakter dizisini tek seferde ekrana yazdığından, bu işlemi yapmadan önce, dizinin sekizinci ve son elemanına karakter dizisi sonu karakteri (‘\0) ekler. Son olarak, cdizi2 dizisini ekrana yazar.
char dizilere tek seferde işlem yapılacağı zaman dizi sonunda ‘\0’ karakteri tanımlanmalıdır.
Tek boyutlu dizilerin bellekte yerleşimi
Tek boyutlu dizilerin bütün elemanları, ilk elemanı en düşük adrese gelecek şekilde, bellekte birbirlerine birleşik olarak yerleştirilir. Bir örnek üzerinde incelemeye çalışalım:
Örnek
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include <iostream>
using namespace std;
int main(void)
{
int idizi[10];
int id;
for (id=0; id<10; id++) idizi[id] = id * id;
for (id=0; id<10; id++) cout << idizi[id] << " ";
return 0;
}
Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:
1
2
3
0 1 4 9 16 25 36 49 64 81
Program, 10 elemanlı int bir dizi bildirimi yapar. Bir for döngüsü kullanarak 0 ile 9 arasındaki sayıların karelerini sırası ile dizi elemanlarına atar. Sonra, bir for döngüsü kullanarak dizi elemanlarının değerlerini ekrana yazar. Programda tanımlanan dizinin bellekteki görünümü aşağıdaki şekildedir:
| dizi[0] | dizi[1] | dizi[2] | dizi[3] | dizi[4] | dizi[5] | dizi[6] | dizi[7] | dizi[8] | dizi[9] |
|---|---|---|---|---|---|---|---|---|---|
| 0 | 1 | 4 | 9 | 16 | 25 | 36 | 49 | 64 | 81 |
Bir dizi elemanının değerini tıpkı diğer değişken veya sabit değerler gibi programımızın herhangi bir bölümünde kullanabiliriz. Bir örnek üzerinde incelemeye çalışalım:
Örnek
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#include <iostream>
using namespace std;
int main(void)
{
int idizi[5];
int id1, id2;
for (id1=0, id2=3; id1<5; id1++, id2+=3) {
idizi[id1] = id2;
cout << idizi[id1] << " ";
}
cout << "\n";
for (id1=0; id1<5; id1++) {
cout << idizi[id1] * idizi[id1] << " ";
}
return 0;
}
Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:
1
2
3
4
3 6 9 12 15
9 36 81 144 225
Program, beş elemanlık int bir dizi ve iki adet int değişken bildirimi yapar. Sonra, bir for döngüsü ile, dizinin elemanlarına 3’ten 15’e kadar olan sayıları 3’er arayla sırasıyla atar ve ekrana yazar. Daha sonra, bir for döngüsü ile dizideki değerlerin karesini ekrana yazar.
Tek boyutlu dizilere klavyeden bir değer atama
cin fonksiyonunu kullanarak dizi elemanlarına klavyeden girilen değerleri de atayabiliriz. Bu yöntemle, dışarıdan girilen değerler dizi elemanlarına atanarak kullanılabilir. Şimdi, bu özelliği örnekler üzerinde incelemeye çalışalım:
Örnek
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#include <iostream>
using namespace std;
int main(void)
{
int idizi[5];
int id;
cout << "Bir sayı giriniz: ";
cin >> idizi[0];
for (id=1; id<5; id++) {
idizi[id] = idizi[0] + id;
}
for (id=0; id<5; id++) {
cout << idizi[id] << " ";
}
return 0;
}
Program, int bir değişken ve 5 elemanlı int bir dizi bildirimi yapar. Bir sayı girilmesini bekler. Girilen sayıyı dizinin ilk elemanına atar ve ilk for döngüsü ile bu değere her defasında bir ekleyerek dizinin diğer elemanlarına sıra ile atar. Daha sonra, ikinci for döngüsü ile dizi eleman değerlerini ekrana yazar.
Örnek
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
#include <iostream>
using namespace std;
int main(void)
{
int idizi[10];
int id1, id2;
for (id1=0; id1<10; id1++) {
idizi[id1] = id1;
cout << idizi[id1] << " ";
}
cout << "\n";
cout << "Bir sayı giriniz: ";
cin >> id2;
for (id1=0; id1<10; id1++) {
idizi[id1] += id2;
cout << idizi[id1] << " ";
}
return 0;
}
Program, oluşturduğu 10 elemanlı bir diziye 0-9 arasındaki sayıları sıra ile atar ve ekrana yazar. Sonra, klavyeden girilen int değeri her dizi elemanına ekleyerek, dizi eleman değerlerini tekrar ekrana yazar.
Dizilerde boyut sınırlaması
C++’da, dizi elemanlarının sayısını sınırlayıcı bir kural yoktur. Yani, daha önce boyutunu tanımlanan bir dizinin eleman sayısından daha fazla eleman diziye atanabilir. Böyle bir durumda karşılaştığında, derleyici yazılan programı herhangi bir hata vermeden derler ve .EXE uzantılı bir dosya oluşturur. Ancak, derlenen dosya çalıştırıldığında, beklenmeyen sonuçlarla karşılaşılabilir. Dizilere tanımlanan boyuttan daha fazla eleman atamanın olumsuz sonuçlarını engellemek için, dizi boyutlarını tanımlarken, sınırlar ihtiyaca göre belirlenmelidir.
Örneğin, 10 elemanlı ve idizi adlı int bir dizi tanımlandığında, programın herhangi bir yerinde kullanılan idizi[20] ifadesi derleyici tarafından kabul edilir. Ancak, dizi eleman sayısı üzerinde yapılan atama mevcut bildirimin sınırlarını aşan bu tür tanımlamalar, önceden tahmin edilemeyen sonuçlara neden olabilir. Bu tür hataların tespit edilmesi ve düzeltilmesi, derleyici hatalarına göre daha zordur ve zaman alır. Aşağıdaki program derlendiğinde, derleyici herhangi bir hata vermez. Ancak, program çalıştırıldığında, ekrana istediğiniz sonuçlar dışında bir takım anlamsız şekiller çıkar:
Örnek
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include <iostream>
using namespace std;
int main(void)
{
int idizi[10];
// Dizinin en son elemanı idizi[9] olmasına rağmen, dizi boyutu üzerinde (17) atama
idizi[17] = 124;
cout << idizi[17];
return 0;
}
Dizileri diğer dizilere kopyalama
C++’da, bir dizinin bütün elemanları diğer bir diziye direkt olarak bir defada atanamaz. Bir dizide bulunan elemanların tamamını diğer bir diziye aynen atamak için, dizi elemanlarını birer birer kopya etmek gerekir. Bu özelliği bir örnek üzerinde incelemeye çalışalım:
Örnek
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
#include <iostream>
using namespace std;
int main(void)
{
int idizi1[10], idizi2[10];
int id;
// idizi1 dizinine değer atama
for (id=0; id<10; id++) idizi1[id] = id;
// idizi1 içindeki tüm değerleri idizi2 dizisine kopyalar.
for (id=0; id<10; id++) idizi2[id] = idizi1[id];
// idizi1 dizi eleman değerlerini ekrana yazma
cout << "idizi1 : ";
for (id=0; id<10; id++) cout << idizi1[id] << " ";
cout << "\n";
// idizi2 dizi eleman değerlerini ekrana yazma
cout << "idizi2 : ";
for (id=0; id<10; id++) cout << idizi2[id] << " ";
return 0;
}
Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:
1
2
3
4
idizi1 : 0 1 2 3 4 5 6 7 8 9
idizi2 : 0 1 2 3 4 5 6 7 8 9
Program önce 10’ar elemanlık 2 adet int dizi tanımlar. Bir for döngüsü ile, 0’dan 9’a kadar olan sayıları idizi1 dizisine atar. İkinci bir for döngüsü kullanarak, idizi1 dizisinin bütün elemanlarını idizi2 dizisine kopya eder. idizi1 ve idizi2 dizilerinin eleman değerlerini for döngüsü kullanarak ekrana yazar.
Tek boyutlu dizilere ilk değer atama
Tıpkı diğer değişkenler de olduğu gibi, dizi elemanlarına da dizinin tanımlandığı işlem satırında bir ilk değer verebiliriz. Bu işlemi yerine getirmek için aşağıdaki genel yapı kullanılır:
veri-türü dizi-adı [boyut] = { sabit-değerler };
Yukarıdaki satırda yer alan sabit değerlerin veri türü dizi veri türü ile aynı olmalıdır.
Tek boyutlu int dizilere ilk değer atama
Sabit değerler listesinde yer alan sabitler sırası ile dizi elemanlarına atanır. Örneğin, aşağıdaki işlem satırı tek boyutlu ve 5 elemanlı idizi dizisine sırası ile 1, 2, 3, 4 ve 5 sayılarını atar:
1
2
3
4
5
int idizi[5] = { 1, 2, 3, 4, 5 };
Yukarıdaki satırda yapılan diziye ilk değer atama işlemi, aşağıdaki işlem satırlarının yaptığı işin aynısını yapar:
1
2
3
4
5
6
int idizi[5], id;
for (id=0; id<5; id++) idizi[id] = id+1;
Şimdi, dizilere ilk değer atama yöntemini bir örnek üzerinde incelemeye çalışalım:
Örnek
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <iostream>
using namespace std;
int main(void)
{
int idizi[5] = { 1, 2, 3, 4, 5 };
int id;
for (id=0; id<5; id++) cout << idizi[id] << " ";
return 0;
}
Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:
1
2
3
1 2 3 4 5
Program önce oluşturduğu tek boyutlu beş elemanlı ve idizi adlı int bir diziye, 1’den 5’e kadar olan sayıları ilk değer atama metodu ile atar ve bir for döngüsü ile dizi elemanlarını ekrana yazar.
Tek boyutlu char dizilere ilk değer atama
Karakter dizilerine ilk değer atama işlemi ise iki farklı şekilde yapılabilir.
Karakter dizisinin her elemanına ayrı ayrı değer atanacaksa, diziye atanacak karakter sayısının bir fazlası kadar dizi boyutu tanımlamak ve en son elemana ‘\0’ karakteri atamak gerekir.
Eğer bir karakter dizisine toplu değer ataması yapılacaksa, karakter dizisi (“ “) işaretleri arasında tanımlanmalıdır. Bu durumda dizi boyutu karakter dizisinde yer alan karakter sayısından bir fazla tanımlanır ve karakter dizisinin sonuna derleyici tarafından otomatik olarak ‘\0’ karakteri eklenir.
1
2
3
4
5
char cdizi[8] = { 'D', 'i', 'z', 'i', 'l', 'e', 'r', '\0' }; // Her bir dizi elemanına ayrı ayrı değer atama
char cdizi[8] = "Diziler"; // Diziye toplu değer atama
Yukarıdaki her iki işlem satırı da aynı sayıda karakteri dizilere atar. Ancak, ikinci işlem satırındaki dizinin son elemanı derleyici tarafından eklenecek olan 0 değeri için ayrılmıştır. İlk değer atama işlemi için bir karakter dizisi kullanılırsa, { } işaretleri işlem satırında yer almaz.
Karakter dizilerine ilk değer atama yöntemini kullanırken, atanan değerler ile tanımlanan dizi boyutu birbirine uygun olmalıdır. Aksi takdirde, derleyici programını derlerken hata verir.
Şimdi, karakter dizilerine ilk değer atama işlemini örnekler üzerinde incelemeye çalışalım:
Örnek
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <iostream>
using namespace std;
int main(void)
{
char cdizi1[9] = { 'K', 'a', 'r', 'a', 'k', 't', 'e', 'r', '\0' };
char cdizi2[9] = "dizileri" ;
cout << cdizi1 << " " << cdizi2;
return 0;
}
Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:
1
2
3
Karakter dizileri
Program önce cdizi1 ve cdizi2 adlı tek boyutlu ve 9 elemanlı 2 adet char dizi oluşturur. cdizi1 dizisine “Karakter” kelimesini, cdizi2 dizisine “dizileri” kelimesini ilk değer atama metodu ile atar. Sonra her iki dizinin içeriğini ekrana yazar.
Örnek
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include <iostream>
#include <cstring>
using namespace std;
int main(void)
{
char cdizi[20] = "Karakter";
strcat (cdizi, " dizileri");
cout << cdizi;
return 0;
}
Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:
1
2
3
Karakter dizileri
Program önce 20 elemanlı bir char dizi oluşturur. İlk değer atama yöntemini kullanarak bu diziye “Karakter” kelimesini atar. Sonra, “ dizileri” kelimesini dizinin sonuna ekleyerek, dizi içeriğini ekrana yazar.
Şimdi, bir karakter dizisine değer atamanın dört farklı yöntemini bir örnek üzerinde incelemeye çalışalım:
Örnek
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
#include <iostream>
#include <cstring>
using namespace std;
int main(void)
{
char cdizi1[11] = "Bilgisayar";
char cdizi2[11] = { 'B', 'i', 'l', 'g', 'i', 's', 'a', 'y', 'a', 'r', '\0' };
char cdizi3[11];
char cdizi4[11];
cdizi3[0] = 'B';
cdizi3[1] = 'i';
cdizi3[2] = 'l';
cdizi3[3] = 'g';
cdizi3[4] = 'i';
cdizi3[5] = 's';
cdizi3[6] = 'a';
cdizi3[7] = 'y';
cdizi3[8] = 'a';
cdizi3[9] = 'r';
cdizi3[10] = '\0';
strcpy(cdizi4, "Bilgisayar");
cout << cdizi1 << "\n";
cout << cdizi2 << "\n";
cout << cdizi3 << "\n";
cout << cdizi4;
return 0;
}
Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:
1
2
3
4
5
6
Bilgisayar
Bilgisayar
Bilgisayar
Bilgisayar
Program 11 byte boyutunda 4 adet karakter dizisi tanımlar. “Bilgisayar” ifadesini ilk karakter dizisine kelime olarak ilk değer atama yöntemi ile, ikinci karakter dizisine karakter bazında tek tek ilk değer atama yöntemi ile, üçüncü karakter dizisine karakterleri tek tek atayarak ve dördüncü karakter dizisine strcpy() fonksiyonunu kullanarak atar. Sonra, karakter dizilerini ekrana yazar.
Şimdi değişik örneklerle diziler hakkında öğrendiklerimizi pekiştirmeye çalışalım:
Örnek
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <iostream>
using namespace std;
int main(void)
{
int idizi[20];
int id1, id2;
id2 = 0;
for (id1=0; id1<20; id1++) {
idizi[id1] = id1;
id2 += idizi[id1];
}
cout << "Dizi eleman değerlerinin toplamı: " << id2;
return 0;
}
Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:
1
2
3
Dizi eleman değerlerinin toplamı: 190
Program, bir for döngüsü yoluyla, 0’dan 19’a kadar olan sayıları oluşturduğu 20 elemanlık bir diziye atarken, atadığı değerleri bir değişken içinde toplar ve değişken değerini ekrana yazar.
Örnek
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <iostream>
using namespace std;
int main(void)
{
int idizi[100];
int id1, id2=0, id3=0;
for (id1=0; id1<100; id1++) {
idizi[id1] = id1;
if (id1%2) id3 += idizi[id1];
else id2 += idizi[id1];
}
cout << "Dizideki çift sayıların toplamı: " << id2 << "\n";
cout << "Dizideki tek sayıların toplamı: " << id3;
return 0;
}
Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:
1
2
3
4
Dizideki çift sayıların toplamı: 2450
Dizideki tek sayıların toplamı : 2500
Program önce 0’dan 99’a kadar olan sayıları oluşturduğu 100 elemanlık bir diziye atar. Daha sonra dizi elemanlarından çift olanların toplamını id2 değişkenine, tek olanların toplamını ise id3 değişkenine atar ve her iki değişkenin değerini ekrana yazar.
Örnek
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <iostream>
using namespace std;
int main(void)
{
int idizi1[10], idizi2[10], idizi3[10];
int id;
for (id=0; id<10; id++) {
idizi1[id] = id + 1;
idizi2[id] = (id + 1) * (id + 1);
idizi3[id] = idizi1[id] + idizi2[id];
cout << idizi1[id] << " " << idizi2[id] << " " << idizi3[id] << "\n";
}
return 0;
}
Yukarıdaki örnekte, program aşağıdaki satırları ekrana yazar:
1
2
3
4
5
6
7
8
9
10
11
12
1 1 2
2 4 6
3 9 12
4 16 20
5 25 30
6 36 42
7 49 56
8 64 72
9 81 90
10 100 110
Program önce 10’ar boyutlu olan idizi1, idizi2 ve idizi3 adlı 3 adet int dizi oluşturur. idizi1 dizisine 1-10 sayılarını, idizi2 dizisine 1-10 sayılarının karesini ve idizi3 dizine ise ilk iki dizi elemanlarının karşılıklı gelen değerlerini toplayarak atar. Sonra, her üç dizinin elemanlarını, aynı sırada yer alan elemanları aynı satırda olacak şekilde, ekrana yazar.
Karakter dizileri
C++’da karakter dizisi olarak tanımlanan bir veri türü yoktur.
Karakter dizisi veri desteğini sağlamak için tek boyutlu char diziler kullanılır.
Karakter dizisi NULL(0) değer (‘\0’) ile sona eren bir char dizidir.
Bir karakter dizisi tanımlandığında, derleyici otomatik olarak dizi sonuna 0 değeri ekleyerek dizi sonunu belirler.
char dizilere değer atarken ve ekrana yazdırırken karakterlere tek tek işlem yapılacağı zaman dizinin en sonunda dizi sonu tanımlayan ‘\0’ karakteri için yer ayırmaya gerek yoktur. Ancak, diziye tek seferde işlem yapılacağı zaman dizi sonunda ‘\0’ karakteri mutlaka tanımlanmalıdır.
Bu nedenle, bir karakter dizisi içerecek bir karakter dizisi tanımlarken, dizi boyutunu karakter dizisinden bir byte yani bir karakter fazla olacak şekilde daha uzun tanımlamak gerekir. Derleyici 0 değerini diziye eklemek için ayrılan bir byte’lık boş alanı kullanacaktır.
C++’da, klavyeden girilen karakter dizileri, cin fonksiyonu veya cstdio başlık dosyasında yer alan standart bir kütüphane fonksiyonu olan ve aşağıda genel yapısı verilen fgets() fonksiyonu ile okutulur.
1
2
3
char* fgets(char *str, int count, FILE *stream);
Verilen dosya akışından en fazla count parametre değerinin 1 eksiği kadar karakter okur ve okuduğu karakterleri str parametresi ile gösterilen karakter dizisine atar. ENTER tuşuna basıldığında, belirtilen sayıda karakter okumadan işlem sona erer. Klavyeden girilen karakterleri okumak için stream parametresinde stdin değeri kullanılır. Okunan karakterler str ile gösterilen karakter dizisine atandıktan sonra, str sonuna otomatik olarak, dizi sonu belirlemek üzere, NULL bir karakter (‘\0’) eklenir. Başarı durumunda, fonksiyon str parametresinin içeriğini geri döndürür. Dosya sonu ile karşılaşılırsa ve hiçbir karakter okunmazsa, str içeriği değişmeden kalır ve NULL bir işaretçi geri döndürülür. Eğer bir hata oluşursa, NULL bir işaretçi geri döndürür.
Klavyeden veri okuma işleminde, girilebilecek maksimum karakter sayısından (count-1) daha az karakter girilirse, giriş işlemini sona erdiren yeni satır karakteri (10), ‘\0’ karakterinden önce diziye eklenir.
* cin fonksiyonu ile karakter dizisi okuturken ilk boşluk karakterinden itibaren hiçbir karakter okunmaz.
* fgets() fonksiyonu ile karakter dizisi okuturken okunacak karakter sayısı tanımlanır.
Şimdi, klavyeden girilen karakter dizilerini okumak için, cin ve fgets() fonksiyonlarının kullanılmasını bir örnek üzerinde incelemeye çalışalım:
Örnek
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <iostream>
#include <cstdio>
using namespace std;
int main(void)
{
char cdizi[40];
cout << "Bir karakter dizisi giriniz:" << "\n";
fgets(cdizi, 40, stdin); // En fazla 39 adet karakter okur.
cout << cdizi;
cout << "Bir karakter dizisi giriniz:" << "\n";
cin >> cdizi; // Boşluk karakterinden itibaren girilen karakterleri dikkate almaz.
cout << cdizi;
return 0;
}
Yukarıdaki örnekte, program 40 elemanlı bir karakter dizi bildirimi yaptıktan sonra bir karakter dizisi girilmesini ister. Girilen karakter dizisini fgets() fonksiyonu ile okuyarak cdizi adlı diziye atar ve dizi içeriğini ekrana yazar. Tekrar bir karakter dizisi girilmesini ister. Girilen karakter dizisini cin fonksiyonu ile okuyarak cdizi adlı diziye atar ve dizi içeriğini ekrana yazar. cin ile okuma işleminde boşluk karakteri girilirse, boşluk karakterinden itibaren girilen hiçbir karakteri diziye dahil etmez.
Şimdi klavyeden girilen karakter dizisinin atandığı bir karakter dizisini ekrana yazdırmanın iki farklı yöntemini bir örnek üzerinde incelemeye çalışalım:
Örnek
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <iostream>
#include <cstdio>
using namespace std;
int main(void)
{
char cdizi[40];
int id;
cout << "Bir karakter dizisi giriniz:" << "\n";
fgets(cdizi, 40, stdin); // En fazla 39 adet karakter okur.
cout << cdizi; // 1. yöntem
for (id=0; cdizi[id]; id++) cout << cdizi[id]; // 2. yöntem
return 0;
}
Yukarıdaki örnekte, program klavyeden girilen karakter dizisini cdizi adlı diziye atadıktan sonra, önce cout fonksiyonu ile dizinin tamamını tek seferde ve bir for döngüsüyle her defasında bir karakter olmak ekrana yazar. for döngüsü içindeki cdizi[id] koşulu dizideki karakter dizisi sonunda bulunan ‘\0’ değerine ulaştığı zaman döngü sona erer (cdizi[id]==0).
strcpy(), strcat(), strcmp() ve strlen() fonksiyonları
Şimdi, C++’da karakter dizileri ile ilgili işlemlerde en yaygın şekilde kullanılan aşağıdaki 4 standart kütüphane fonksiyonunu sıra ile incelemeye çalışalım. Bu fonksiyonların tamamı cstring başlık dosyasını kullanmaktadır. strcpy() fonksiyonunun genel yapısı aşağıda gösterilmektedir:
1
2
3
char* strcpy(char *dest, const char *src);
strcpy() fonksiyonu src parametresi ile gösterilen ve boş bir karakter (‘\0’) ile sonlandırılmış karakter dizisini, dest parametresi ile gösterilen ve boş bir karakter (‘\0’) ile sonlandırılmış karakter dizisinin yerine kopyalar. dest parametre değerini geri döndürür.
Şimdi, strcpy() fonksiyonunun kullanılmasını örnekler üzerinde incelemeye çalışalım:
Örnek
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <stdio.h>
#include <string.h>
int main(void)
{
char cdizi[50];
strcpy(cdizi, "Karakter dizisi kopyalama işlemi");
cout << cdizi;
return 0;
}
Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:
1
2
3
Karakter dizisi kopyalama işlemi
Program 50 elemanlı cdizi adlı bir karakter dizisi tanımlar. Sonra, “Karakter dizisi kopyalama işlemi” cümlesini strcpy() fonksiyonu ile cdizi dizisine kopya eder ve dizi içeriğini bir defada ekrana yazar.
Örnek
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <iostream>
#include <cstring>
using namespace std;
int main(void)
{
char cdizi1[20], cdizi2[20];
strcpy(cdizi1, "Harfler");
strcpy(cdizi2, "Sayılar");
cout << cdizi1 << " " << cdizi2 << "\n";
strcpy(cdizi1, cdizi2);
cout << cdizi1 << " " << cdizi2;
return 0;
}
Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:
1
2
3
4
Harfler Sayılar
Sayılar Sayılar
Program önce 20 elemanlık cdizi1 ve cdizi2 adlı iki adet dizi tanımlar. Sonra “Harfler” kelimesini cdizi1 dizinine, “Sayılar” kelimesini cdizi2 dizinine kopya eder. Her iki dizi değerini ekrana yazar. Daha sonra cdizi2 dizisinin içeriğini cdizi1 dizisine kopya eder. Bu durumda cdizi1 dizisinin içeriği silinir ve her iki dizi içeriği birbirine eş olur. Her iki dizi içeriğini tekrar ekrana yazar.
strcpy() fonksiyonu kullandığı dizi ile ilgili sınır kontrolü yapmadığından, dizi boyutunu tanımlarken, diziye kopya edilebilecek karakter dizisinin azami boyutunu göz önünde bulundurmak gerekir.
Bir karakter dizisinin içeriğini başka bir karakter dizisine ekleyen strcat() fonksiyonunun genel yapısı aşağıda gösterilmektedir:
1
2
3
char* strcat(char *dest, const char *src);
strcat() fonksiyonu src parametresi ile gösterilen ve boş bir karakter (‘\0’) ile sonlandırılmış karakter dizisini, dest parametresi ile gösterilen ve boş bir karakter (‘\0’) ile sonlandırılmış karakter dizisinin sonuna ekleyerek yine boş bir karakter (‘\0’) ile sonlandırılmış bir karakter dizisi oluşturur. dest parametre değerini geri döndürür.
Şimdi, örnekler üzerinde bu fonksiyonun kullanılmasını incelemeye çalışalım:
Örnek
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include <iostream>
#include <cstring>
using namespace std;
int main(void)
{
char cdizi[50];
strcpy(cdizi, "Harfler");
strcat(cdizi, " ve sayılar");
cout << cdizi;
return 0;
}
Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:
1
2
3
Harfler ve sayılar
Program önce 50 elemanlık cdizi adlı bir karakter dizisi tanımlar. Sonra “Harfler” kelimesini cdizi dizinine kopyalar, strcat() fonksiyonunu kullanarak “ ve sayılar” ifadesini cdizi dizisinin sonuna ekler. Daha sonra, cdizi dizisinin içeriğini bir defada ekrana yazar.
Örnek
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <iostream>
#include <cstring>
using namespace std;
int main(void)
{
char cdizi1[50], cdizi2[50];
strcpy(cdizi1, "Karakter dizisi");
strcpy(cdizi2, " ekleme işlemi");
strcat(cdizi1, cdizi2);
cout << cdizi1;
return 0;
}
Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:
1
2
3
Karakter dizisi ekleme işlemi
Program önce 50 elemanlık cdizi1 adlı ve 20 elemanlık cdizi2 adlı iki char dizi tanımlar. “Karakter dizisi” kelimesini cdizi1 dizinine, “ ekleme işlemi” kelimesini cdizi2 dizinine kopya eder. Sonra, cdizi2 dizininin içeriği olan “ ekleme işlemi” kelimesini cdizi1 dizinine ekler. Her iki dizinin içeriğini bir defada ekrana yazar.
İki karakter dizisini karşılaştıran strcmp() fonksiyonunun genel yapısı aşağıda gösterilmektedir:
1
2
3
int strcmp(const char *str1, const char *str2);
strcmp() fonksiyonu, Str1 parametresi ile gösterilen karakter dizisini str2 parametresi ile gösterilen karakter dizisi ile karşılaştırır. Eğer her iki karakter dizisindeki tüm karakterler aynı ise sıfır değeri, aksi takdirde sıfırdan farklı bir değer geri döndürür.
Fonksiyon str1 ve str2 parametreleri ile gösterilen karakter dizilerini ilk karakterden itibaren karşılaştırmaya başlar. Birbirlerine eşitse, karakterler farklı olana veya karakter dizisinin sonunu gösteren boş bir karakterle karşılaşana kadar karşılaştırma işlemine devam eder.
Fonksiyon aşağıdaki değerlerden birini geri döndürür:
- <0 ise str1 bellek içeriği str2 bellek içeriğinden küçüktür.
0 ise str2 bellek içeriği str1 bellek içeriğinden küçüktür.
- =0 ise str1 bellek içeriği str2 bellek içeriğine eşittir.
strcmp() fonksiyonu karakter dizilerine işlem yaparken, sözlük sırasına göre karşılaştırır. Bu karşılaştırmada, karakter dizilerinin uzunlukları dikkate alınmaz. Örneğin, aşağıdaki satırda yer alan karakter dizilerinden sol taraftaki daha küçüktür. Çünkü, sol taraftaki karakter dizisinin üçüncü harfi, sağ taraftaki karakter dizisinin üçüncü harfinden daha küçüktür:
“kalem” “kapı”
Bu fonksiyon ile yapılan karşılaştırma büyük ve küçük harf özelliğini de dikkate alır. Küçük harfler büyük harflerden daha büyük değer taşırlar.
Bu fonksiyonun çalışmasını da bir örnek üzerinde incelemeye çalışalım:
Örnek
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <iostream>
#include <cstring>
using namespace std;
int main(void)
{
int id1, id2, id3;
id1 = strcmp("karakter", "karakter");
id2 = strcmp("sayılarda", "sayıda");
id3 = strcmp("harfin", "harflerin");
cout << id1 << " " << id2 << " " << id3;
return 0;
}
Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:
1
2
3
0 1 -1
Program strcmp() fonksiyonuna ait üç farklı işleminin sonuçlarını göstermektedir. strcmp() fonksiyonunun kullanıldığı ilk satırda birbirine eşit iki karakter dizisi karşılaştırıldığından, id1 değişkenine 0 değerini, ikinci satırda ilk karakter dizisi ikinci karakter dizisinden büyük olduğu için id2 değişkenine 0’dan büyük olan 1 değerini, üçüncü satırda ise ilk karakter dizisi ikinci karakter dizisinden küçük olduğu için id3 değişkenine 0’dan küçük olan -1 değerini atar ve değişken değerlerini ekrana yazar.
Bir karakter dizisinin karakter olarak uzunluğunu geri döndüren strlen() fonksiyonunun genel yapısı aşağıda gösterilmektedir:
1
2
3
size_t strlen(const char *str);
strlen() fonksiyonu, str parametresi ile gösterilen ve boş bir karakter (‘\0’) ile sonlandırılmış karakter dizisinin uzunluğunu, dizi sonundaki boş karakter hariç olmak üzere, hesaplar. str parametresindeki karakter dizisinin uzunluğunu geri döndürür.
Karakter dizisinin uzunluğunu hesaplarken dizinin sonunda yer alan 0 değerini dikkate almaz.
Örnek
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <iostream>
#include <cstring>
using namespace std;
int main(void)
{
char cdizi[30];
int id;
strcpy(cdizi, "Karakter dizisi uzunluğu");
id = strlen(cdizi);
cout << id;
return 0;
}
Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:
1
2
3
24
Program oluşturduğu 30 elemanlık cdizi adlı bir char diziye “Karakter dizisi uzunluğu” cümlesini kopya eder. Sonra cdizi dizinindeki karakter dizisinin boyunu hesaplar ve bu değeri id değişkenine atayarak ekrana yazar.
Şimdi, dört fonksiyonun birlikte kullanıldığı bir örneği incelemeye çalışalım:
Örnek
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
#include <iostream>
#include <cstring>
#include <cstdio>
using namespace std;
int main(void)
{
char cdizi1[20], cdizi2[20];
strcpy(cdizi1, "Karakter dizisi");
strcpy(cdizi2, " işlemleri");
cout << cdizi1 << cdizi2 << "\n";
cout << "Karakter dizilerinin uzunlukları: " << strlen(cdizi1) << " " << strlen(cdizi2) << "\n";
if (!strcmp(cdizi1, cdizi2)) cout << "Karakter dizileri birbirine eşittir!";
else cout << "Karakter dizileri birbirine eşit değildir!";
cout << "\n";
strcat(cdizi1, cdizi2);
cout << cdizi1;
return 0;
}
Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:
1
2
3
4
5
6
Karakter dizisi işlemleri
Karakter dizilerinin uzunlukları: 15 10
Karakter dizileri birbirine eşit değildir!
Karakter dizisi işlemleri
Yukarıdaki örnekte, program cdizi1 ve cdizi2 adlı 2 adet karakter dizisi oluşturur. Bu dizilere birer karakter dizisi atar. Dizileri ve karakter uzunluklarını ekrana yazar. İki karakter dizisini karşılaştırarak sonucu ekrana yazar. Son aşamada, ikinci diziyi ilk diziye ekleyerek ekrana yazar.
Çok boyutlu diziler
C++’da, iki veya daha fazla boyutlu diziler tanımlayabiliriz.
Çok boyutlu dizi bildirimi
Çok boyutlu dizi tanımlamanın, tek boyutlu dizi tanımlamaktan çok büyük bir farkı yoktur. Diziye eklenen her bir boyut için [] işaretleri arasında bir sayı tanımlanmaktadır. Aşağıdaki işlem satırlarının ilki tek boyutlu, ikincisi iki boyutlu ve üçüncüsü ise üç boyutlu bir int dizi tanımlar:
1
2
3
4
5
int idizi1[12]; // Tek boyutlu dizi
int idizi2[3][4]; // İki boyutlu dizi
int idizi3[2][3][4]; // Üç boyutlu dizi
Yukarıda, ilk işlem satırında yapılan 12 elemanlı int dizi bildiriminin, ikinci işlem satırında tanımlanan bir diziden herhangi bir farkı yoktur. Çünkü, her iki dizininde eleman sayısı aynıdır ve bellekte aynı büyüklükte yer kaplarlar.
Çok boyutlu dizilere atama işlemcisi ile değer atama
Çok boyutlu dizilere atama yapmak için, her bir dizi elemanına farklı ve birbirinden bağımsız değerler atamak istediğimizde, her bir dizi elemanına farklı bir işlem satırında erişim sağlanır. Bu özelliği bir örnek üzerinde incelemeye çalışalım:
Örnek
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <iostream>
using namespace std;
int main(void)
{
int idizi[3][4];
idizi[0][0] = idizi[0][1] = idizi[0][2] = idizi[0][3] = 1 ; // 1
idizi[1][0] = idizi[1][1] = idizi[1][2] = idizi[1][3] = 2 ; // 2
idizi[2][0] = idizi[2][1] = idizi[2][2] = idizi[2][3] = 3 ; // 3
cout << idizi[0][0] << " " << idizi[0][1] << " " << idizi[0][2] << " " << idizi[0][3] << "\n";
cout << idizi[1][0] << " " << idizi[1][1] << " " << idizi[1][2] << " " << idizi[1][3] << "\n";
cout << idizi[2][0] << " " << idizi[2][1] << " " << idizi[2][2] << " " << idizi[2][3];
return 0;
}
Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:
1
2
3
4
5
1 1 1 1
2 2 2 2
3 3 3 3
Program, 3*4’lük ve 12 elemanlık iki boyutlu int bir dizi tanımlar. 1 sayısı ile gösterilen işlem satırında dizinin ilk satırındaki elemanlara 1 değerini, 2 sayısı ile gösterilen işlem satırında dizinin ikinci satırında yer alan elemanlara 2 değerini, 3 sayısı ile gösterilen işlem satırında ise dizinin üçüncü satırındaki elemanlara 3 değerini atar. Daha sonra, cout fonksiyonunun kullanıldığı işlem satırları ile dizinin satırlarını sırasıyla ekrana yazar.
Şimdi, aynı programı for döngüsü kullanarak tekrar düzenlemeye çalışalım:
Örnek
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
#include <iostream>
using namespace std;
int main(void)
{
int idizi[3][4];
int id1, id2;
// Diziye değer atama
for (id1=0; id1<3; id1++) {
for (id2=0; id2<4; id2++) {
idizi[id1][id2]=id1+1;
}
}
// Dizi değerlerini ekrana yazma
for (id1=0; id1<3; id1++) {
for (id2=0; id2<4; id2++) {
cout << idizi[id1][id2] << " ";
}
cout << "\n";
}
return 0;
}
Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:
1
2
3
4
5
1 1 1 1
2 2 2 2
3 3 3 3
Program, 3*4’lük ve 12 elemanlık iki boyutlu int bir dizi tanımlar. Bir içi içe for döngüsü ile dizinin ilk satırındaki elemanlara 1 değerini, ikinci satırında yer alan elemanlara 2 değerini, üçüncü satırındaki elemanlara 3 değerini atar. Başka bir iç içe for döngüsü ile dizinin satırlarını sırasıyla ekrana yazar.
Çok boyutlu dizilerin bellekte yerleşimi
Çok boyutlu dizilerin bellekte yerleşimi ile tek boyutlu dizilerinki arasında bir fark yoktur. Tek boyutlu diziler, ilk eleman en düşük adrese gelecek şekilde, dizi elemanları bellekte birbirlerine birleşik olarak sıra ile yerleştirilirken, iki boyutlu bir dizide, dizi satır sayısı kadar tek boyutlu dizi birbiri peşine belleğe yerleşir.
Yukarıdaki örneklerde bilgisayar bellek içeriği aşağıdaki şekilde gösterildiği gibidir:
| idizi[0][0] | idizi[0][1] | idizi[0][2] | idizi[0][3] | idizi[1][0] | idizi[1][1] | idizi[1][2] | idizi[1][3] | idizi[2][0] | idizi[2][1] | idizi[2][2] | idizi[2][3] |
|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | 1 | 1 | 1 | 2 | 2 | 2 | 2 | 3 | 3 | 3 | 3 |
Şimdi, bir adet tek boyutlu ve bir adet iki boyutlu olmak üzere aynı boyutta iki adet int dizi ile ilgili bir örneği incelemeye çalışalım:
Örnek
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
#include <iostream>
using namespace std;
int main(void)
{
int idizi1[12];
int idizi2[3][4];
int id1, id2;
// Diziye değer atama
for (id1=0, id2=1; id1<12; id1++) {
if(id1 && (id1%4==0)) id2++;
idizi1[id1]=id2;
}
// Dizi değerlerini ekrana yazma
cout << "Tek boyutlu dizi değerleri:" << "\n";
for (id1=0, id2=1; id1<12; id1++) {
cout << idizi1[id1] << " ";
}
// Diziye değer atama
for (id1=0; id1<3; id1++) {
for (id2=0; id2<4; id2++) {
idizi2[id1][id2]=id1+1;
}
}
// Dizi değerlerini ekrana yazma
cout << "\n\n" << "Çift boyutlu dizi değerleri:" << "\n";
for (id1=0; id1<3; id1++) {
for (id2=0; id2<4; id2++) {
cout << idizi2[id1][id2] << " ";
}
cout << "\n";
}
return 0;
}
Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:
1
2
3
4
5
6
7
8
9
Tek boyutlu dizi değerleri:
1 1 1 1 2 2 2 2 3 3 3 3
Çift boyutlu dizi değerleri:
1 1 1 1
2 2 2 2
3 3 3 3
Program, bir adet 12 elemanlı ve bir adet iki boyutlu 3*4 elemanlı int dizi bildirimi yapar. Döngüleri kullanarak, her iki diziye aynı değerleri atar ve dizi değerlerini ekrana yazar.
Dizinin bellekte kapladığı alanın hesaplanması
Bir dizinin eleman sayısını hesaplamak için, dizi boyut değerlerini birbiri ile çarpmak yeterlidir. Bu işlemin genel yapısı aşağıda gösterilmektedir:
Dizi eleman sayısı = Boyut1 * Boyut2 * Boyut3 * … * BoyutN
Aşağıdaki satır, m1[5][3][4]; olarak tanımlanmış bir dizinin eleman sayısını hesaplar:
Dizi eleman sayısı = 5 * 3 * 4 = 60
Dizinin bellekte kapladığı alanı hesaplamak için, aşağıda genel yapısı verilen işlem kullanılır:
Dizi bellek alanı = Dizi eleman sayısı * sizeof (veri-türü);
Yukarıdaki işlem satırında, dizi veri türünün boyutu ile dizi eleman sayısı çarpılarak, dizinin bellekte kapladığı alan byte olarak hesaplanır. Bu özelliği bir örnek üzerinde incelemeye çalışalım:
Örnek
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include <iostream>
using namespace std;
int main(void)
{
int idizi[3][5];
char cdizi[3][5];
float fdizi[3][5];
cout << "idizi dizisinin bellekte kapladığı alan: " << 3 * 5 * sizeof(int) << " byte" << "\n";
cout << "cdizi dizisinin bellekte kapladığı alan: " << 3 * 5 * sizeof(char) << " byte" << "\n";
cout << "fdizi dizisinin bellekte kapladığı alan: " << 3 * 5 * sizeof(float) << " byte";
return 0;
}
Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:
1
2
3
4
5
idizi dizisinin bellekte kapladığı alan: 60 byte
cdizi dizisinin bellekte kapladığı alan: 15 byte
fdizi dizisinin bellekte kapladığı alan: 60 byte
Program önce boyutları aynı olan char, int ve float veri türünden üç adet dizi oluşturur. Sonra, dizilerin bellekte kapladığı alanları birer birer hesaplayarak ekrana yazar.
Çok boyutlu dizilere klavyeden bir değer atama
Tek boyutlu dizilerde olduğu gibi, çok boyutlu dizilere de cin fonksiyonunu kullanarak klavyeden girdiğimiz değerleri atayabiliriz. Şimdi bu özelliği örnekler üzerinde incelemeye çalışalım:
Örnek
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
#include <iostream>
using namespace std;
int main(void)
{
int idizi[2][3];
int id1, id2;
for (id1=0; id1<2; id1++) {
for (id2=0; id2<3; id2++) {
cout << "Bir sayı giriniz: ";
cin >> idizi[id1][id2];
}
}
cout << "\n";
for (id1=0; id1<2; id1++) {
for (id2=0; id2<3; id2++) cout << idizi[id1][id2] << " ";
cout << "\n";
}
return 0;
}
Program, 2*3 elemanlı int bir dizi bildirimi yapar. Peşpeşe girilen 6 adet int değeri sıra ile dizi elemanlarına atar ve dizi değerlerini ekrana yazar.
Örnek
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
#include <iostream>
using namespace std;
int main(void)
{
long int lidizi[3][3];
int id1, id2;
for (id1=0; id1<3; id1++) {
cout << "Bir sayı giriniz: ";
cin >> lidizi[id1][0];
lidizi[id1][1] = lidizi[id1][0] * lidizi[id1][0];
lidizi[id1][2] = lidizi[id1][0] * lidizi[id1][0] * lidizi[id1][0];
}
cout << "\n";
for (id1=0; id1<3; id1++) {
for (id2=0; id2<3; id2++) cout << lidizi[id1][id2] << " ";
cout << "\n";
}
return 0;
}
Yukarıdaki örnekte, program 3*3 boyutlarında, 9 elemanlık long int bir dizi tanımlar. Sonra, klavyeden peş peşe girilen 3 sayıyı dizinin ilk sütununda yer alan elemanlara, sayıların karesini ikinci sütununda yer alan elemanlara, sayıların küpünü ise üçüncü sütununda yer alan elemanlara atar. Daha sonra, dizi eleman değerlerini ekrana yazar.
Çok boyutlu dizileri diğer dizilere kopyalama
Bir dizi diğer bir diziye direkt olarak kopya edilemez. Bu nedenle, çok boyutlu dizileri diğer bir diziye kopya ederken, dizi elemanlarını birer birer kopya etmek gerekir.
Örnek
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
#include <iostream>
using namespace std;
int main(void)
{
int idizi1[2][3][4];
int idizi2[2][3][4];
int id1, id2, id3;
for (id1=0; id1<2; id1++) {
for (id2=0; id2<3; id2++) {
for (id3=0; id3<4; id3++) {
idizi1[id1][id2][id3] = 21;
cout << idizi1[id1][id2][id3] << " ";
}
}
}
cout << "\n";
for (id1=0; id1<2; id1++) {
for (id2=0; id2<3; id2++) {
for (id3=0; id3<4; id3++) {
idizi2[id1][id2][id3] = idizi1[id1][id2][id3];
cout << idizi2[id1][id2][id3] << " ";
}
}
}
return 0;
}
Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:
1
2
3
4
21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21
21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21
Program bir dizinin tüm elemanlarına 21 sayısını atar ve ekrana yazar. Sonra, dizi elemanlarını teker teker başka bir diziye kopyalar ve yeni dizinin elemanlarını da ekrana yazar.
Örnek
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
#include <iostream>
using namespace std;
int main(void)
{
int idizi1[3][4], idizi2[3][4];
int id1, id2, id3;
for (id1=0, id3=1; id1<3; id1++) {
for (id2=0; id2<4; id2++, id3++) {
idizi1[id1][id2] = id3;
if (idizi1[id1][id2] % 2 == 0) idizi2[id1][id2] = idizi1[id1][id2];
else idizi2[id1][id2] = 5;
}
}
for (id1=0; id1<3; id1++) {
for (id2=0; id2<4; id2++) {
cout << idizi1[id1][id2] << " ";
}
cout << "\n";
}
cout << "\n";
for (id1=0; id1<3; id1++) {
for (id2=0; id2<4; id2++) {
cout << idizi2[id1][id2] << " ";
}
cout << "\n";
}
return 0;
}
Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:
1
2
3
4
5
6
7
8
9
1 2 3 4
5 6 7 8
9 10 11 12
5 2 5 4
5 6 5 8
5 10 5 12
Program önce 3*4 boyutlarında idizi1 ve idizi2 adlı 2 adet int dizi oluşturur. idizi1 dizisinin bütün elemanlarına 1-12 arasındaki sayıları, idizi2 dizisine ise idizi1 içindeki çift sayıları, tek sayılar yerine de 5 sayısını atar ve dizi değerlerini ekrana yazar.
Çok boyutlu dizilere ilk değer atama
Çok boyutlu dizilere de tek boyutlu diziler olduğu gibi ilk değer ataması yapılabilir. Örneğin, aşağıdaki işlem satırları 12 elemanlı ve 2 boyutlu idizi adlı int bir diziye ilk değer atama metodu ile 12 adet sayı atar:
1
2
3
4
5
6
7
int idizi [3][4] = {
1, 2, 3, 4,
5, 6, 7, 8,
9, 10, 11, 12
};
Şimdi, çok boyutlu dizilere ilk değer atanmasını bir örnek üzerinde incelemeye çalışalım:
Örnek
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
#include <iostream>
using namespace std;
int main(void)
{
int idizi[4][3] = {
1, 2, 3,
4, 5, 6,
7, 8, 9,
10, 11, 12
};
char cdizi[2][5] = {
'B', 'i', 'l', 'g', 'i',
's', 'a', 'y', 'a', 'r'
};
int id1, id2;
for (id1=0; id1<4; id1++)
for (id2=0; id2<3; id2++)
cout << idizi[id1][id2] << " ";
cout << "\n";
for (id1=0; id1<2; id1++)
for (id2=0; id2<5; id2++)
cout << cdizi[id1][id2] << " ";
return 0;
}
Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:
1
2
3
4
1 2 3 4 5 6 7 8 9 10 11 12
B i l g i s a y a r
Program biri int biri char olmak üzere iki adet çok boyutlu dizi tanımlar. 1’den 12’e kadar olan sayıları idizi dizisine, “BİLGİSAYAR” kelimesini cdizi dizisine ilk değer atama metodu ile atar ve her iki dizi içeriğini sıra ile ekrana yazar.
Şimdi, farklı örnekler üzerinde öğrendiklerimizi tekrar edelim:
Örnek
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
#include <iostream>
using namespace std;
int main(void)
{
int idizi1[3][4];
int idizi2[3][4];
int id1, id2;
// idizi1 dizi elemanlarına değer atayan döngü
for (id1=0; id1<3; id1++)
for (id2=0; id2<4; id2++) idizi1[id1][id2] = id1+1;
// idizi2 dizi elemanlarına idizi1 dizi eleman değerlerini atayan döngü
for (id1=0; id1<3; id1++)
for (id2=0; id2<4; id2++) idizi2[id1][id2] = idizi1[id1][id2];
// idizi2 dizi elemanlarını 5'er sayı artıran döngü
for (id1=0; id1<3; id1++)
for (id2=0; id2<4; id2++) idizi2[id1][id2] = idizi2[id1][id2] + 5;
// idizi1 dizi eleman değerlerini ekrana yazdıran döngü
for (id1=0; id1<3; id1++) {
for (id2=0; id2<4; id2++) cout << idizi1[id1][id2] << " ";
cout << "\n";
}
cout << "\n";
// idizi2 dizi eleman değerlerini ekrana yazdıran döngü
for (id1=0; id1<3; id1++) {
for (id2=0; id2<4; id2++) cout << idizi2[id1][id2] << " ";
cout << "\n";
}
return 0;
}
Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:
1
2
3
4
5
6
7
8
9
1 1 1 1
2 2 2 2
3 3 3 3
6 6 6 6
7 7 7 7
8 8 8 8
Program önce, 3*4 boyutlarında, 15 elemanlı idizi1 ve idizi2 adlı iki adet int dizi oluşturur. Bir for döngüsü kullanarak, idizi1 dizisinin ilk satırdaki elemanlarına 1 değerini, ikinci satırdaki elemanlarına 2 değerini, üçüncü satırdaki elemanlarına 3 değerini atar. Sonra yine bir for döngüsü kullanarak idizi1 dizi eleman değerlerini idizi2 dizi elemanlarına kopya eder. idizi2 dizi eleman değerlerini 5’er sayı artırır. En son olarak, her iki dizinin elemanlarını sıra ile ekrana yazar.
Şimdi, bir ve iki boyutlu dizileri aynı örnek içinde incelemeye çalışalım:
Örnek
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
#include <iostream>
using namespace std;
int main(void)
{
int idizi1[10];
int idizi2[2][5];
int id1, id2, id3;
for (id1=0; id1<10; id1++) {
idizi1[id1] = id1+1;
cout << idizi1[id1] << " ";
}
cout << "\n\n";
id3 = 1;
for (id1=0; id1<2; id1++) {
for (id2=0; id2<5; id2++, id3++) {
idizi2[id1][id2] = id3;
cout << idizi2[id1][id2] << " ";
}
cout << "\n";
}
cout << "\n";
id3 = 0;
for (id1=0; id1<2; id1++) {
for (id2=0; id2<5; id2++, id3++) {
idizi1[id3] += idizi2[id1][id2];
cout << idizi1[id3] << " ";
}
}
return 0;
}
Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:
1
2
3
4
5
6
7
8
1 2 3 4 5 6 7 8 9 10
1 2 3 4 5
6 7 8 9 10
2 4 6 8 10 12 14 16 18 20
Program, biri tek boyutlu diğeri iki boyutlu olmak üzere 10 elemanlı iki adet int dizi oluşturur. 1 ile 10 arasındaki sayıları önce idizi1 dizisine sonra idizi2 dizisine atayarak her iki diziyi ekrana yazar. Sonra, dizilerin karşılıklı gelen elemanlarını toplayarak idizi1 dizinine atar ve dizi değerlerini ekrana yazar.
Şimdi, üç boyutlu bir dizinin kullanılmasını bir örnekle incelemeye çalışalım:
Örnek
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
#include <iostream>
using namespace std;
int main(void)
{
int idizi[2][3][4];
int id1, id2, id3;
for (id1=0; id1<2; id1++) {
for (id2=0; id2<3; id2++) {
for (id3=0; id3<4; id3++) {
idizi[id1][id2][id3] = 1;
cout << idizi[id1][id2][id3] << " ";
}
}
}
cout << "\n";
idizi[0][2][2] = 5;
idizi[1][1][3] = 7;
for (id1=0; id1<2; id1++) {
for (id2=0; id2<3; id2++) {
for (id3=0; id3<4; id3++) {
cout << idizi[id1][id2][id3] << " ";
}
}
}
return 0;
}
Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:
1
2
3
4
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 1 1 5 1 1 1 1 1 1 1 1 7 1 1 1 1
Yukarıdaki örnekte, program 3 boyutlu ve 24 elemanlı int bir dizi tanımlar. Elemanlara 1 sayısını atar ve eleman değerlerini ekrana yazar. Sonra dizinin 11 nci ve 20 nci elemanlarına farklı değerler atayarak dizi değerlerini tekrar ekrana yazar.
Karakter dizisi dizileri
Daha önce, tek boyutlu char dizilere karakterler atayarak karakter dizilerinin oluşturulmasını birlikte incelemiştik. Şimdi, çok boyutlu dizilerle karakter dizilerinin kullanılmasını incelemeye çalışalım. Tek boyutlu char dizilerde tek bir karakter dizisi oluşturabilirken, çok boyutlu dizilerde birden fazla karakter dizisi aynı dizi adı altında tanımlanabilir. Aşağıdaki işlem satırı her biri azami 20 karakterden (NULL hariç) oluşan üç karakter dizisi alabilen bir karakter dizisi dizisi oluşturur:
1
2
3
char cdizi[3][21];
Üç boyutlu karakter dizisi dizileri de oluşturabilir. Aşağıdaki işlem satırı 3 ayrı karakter dizisi grubu oluşturur. Her grupta 4 karakter dizisi ve her karakter dizisinde 40 karakter yer alır:
1
2
3
char cdizi[3][4][41];
Şimdi, bir karakter dizisi dizisinde yer alan karakter dizilerinin her bir elemanına teker teker değer atayan ve ekrana yazan bir örneği incelemeye çalışalım. Karakter dizisine değer atama ve ekrana yazdırma işleminde karakter temelinde işlem yapıldığından, dizi sonu için ‘\0’ karakterine yer ayrılmadığına ve kullanılmadığına dikkat ediniz!
Örnek
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <iostream>
using namespace std;
int main(void)
{
char cdizi[5][20];
int id1, id2;
char cd;
for (id1=0, cd='A'; id1<5; id1++, cd++)
for (id2=0; id2<20; id2++) cdizi[id1][id2] = cd;
for (id1=0; id1<5; id1++) {
for (id2=0; id2<20; id2++) cout << cdizi[id1][id2] << " ";
cout << "\n";
}
return 0;
}
Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:
1
2
3
4
5
6
7
A A A A A A A A A A A A A A A A A A A A
B B B B B B B B B B B B B B B B B B B B
C C C C C C C C C C C C C C C C C C C C
D D D D D D D D D D D D D D D D D D D D
E E E E E E E E E E E E E E E E E E E E
Program önce 5*20 boyutunda bir karakter dizisi dizisi oluşturur. Alfabenin ilk 5 harfini dizideki karakter dizilerine 20 defa birer birer atar. Sonra yine birer birer olmak üzere dizideki bütün harfleri ekrana yazar.
Karakter dizisi dizilerine değer atamanın diğer bir yöntemi, program içinden direkt olarak karakter dizilerini dizilere kopya etmektir. Bu işlemi bir örnek üzerinde incelemeye çalışalım:
Örnek
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <iostream>
#include <cstring>
using namespace std;
int main(void)
{
char cdizi[3][21];
int id;
strcpy(cdizi[0], "Karakter dizileri");
strcpy(cdizi[1], "kopyalama");
strcpy(cdizi[2], "yöntemleri");
for (id=0; id<3; id++) cout << cdizi[id] << " ";
return 0;
}
Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:
1
2
3
Karakter dizileri kopyalama yöntemleri
Program azami 20 karakterlik 3 adet karakter dizisi alabilecek bir char dizi tanımlar. Diziye kopya ettiği karakter dizilerini ekrana yazar.
İki boyutlu karakter dizisi dizilerinde, karakter dizilerine erişmek için sadece ilk dizi boyutunu tanımlamak yeterlidir. Üç boyutlu bir karakter dizisi dizininde yer alan karakter dizilerine erişmek içinse ilk iki boyutu tanımlamak gerekir.
Örnek
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <iostream>
#include <cstring>
using namespace std;
int main(void)
{
char cdizi[2][3][11];
int id1, id2;
for (id1=0; id1<2; id1++) {
for (id2=0; id2<3; id2++) {
strcpy (cdizi[id1][id2], "Bilgi");
cout << cdizi[id1][id2] << " ";
}
}
return 0;
}
Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:
1
2
3
Bilgi Bilgi Bilgi Bilgi Bilgi Bilgi
Program önce toplam 3 adet ve 10 elemanlı (NULL değer hariç) karakter dizisinden oluşan 2 grupluk bir karakter dizi dizisi oluşturur. Dizi toplam 6 adet karakter dizisi alabilecek kapasitededir. Sonra, “Bilgi” karakter dizisini dizi elemanlarına kopya eder ve tüm karakter dizilerini ekrana yazar.
Boyutsuz olarak tanımlanan diziler
Dizilere ilk değer atama işlemini uygularken, dizilerin boyutunu tanımlamak şart değildir. Bu özellik programlarda büyük bir kolaylık sağlar. Çünkü, bu durumda dizi boyutunu doğru tanımlamamış olmak gibi bir endişe taşımaya gerek yoktur. Dizi boyutunu tanımlamadan ilk değer atama işlemi uygulandığında, derleyici diziye atanan sabit değerlerin sayısını kullanarak dizi boyutunu otomatik olarak hesaplar.
Şimdi, önce tek boyutlu bir dizi için, boyut tanımlamadan ilk değer atama işlemi gerçekleştiren aşağıdaki işlem satırını incelemeye çalışalım:
1
2
3
int idizi[] = { 1, 2, 3, 4 };
Yukarıdaki işlem satırı, boyutu tanımlanmamış olan idizi adlı int bir diziye ilk değer atama yöntemiyle 4 adet değer atar. Derleyici, diziye atanan değer sayısını kullanarak, otomatik olarak 4 boyutlu bir dizi oluşturur. İşlem satırındaki [] işaretleri arasında herhangi bir sayı olmadığına dikkat ediniz. Daha sonra, boyutu tanımlanmamış olan bir diziye atanan sabit sayısını değiştirildiğinde, derleyici programınızı yeniden değerlendirerek, yeni sabit sayısına göre, farklı boyutta bir dizi oluşturur. Örneğin, yukarıdaki işlem satırında diziye atanan sabit sayısını değiştirilerek, 2 int değeri daha aşağıdaki işlem satırı ile idizi dizisine eklendiğinde, derleyici programınızı yeniden derlerken, idizi dizisini 6 boyutlu bir dizi olarak oluşturur:
1
2
3
int idizi[] = { 1, 2, 3, 4, 5, 6 };
Boyutsuz dizileri kullanmanın en büyük avantajı dizi boyutunun, diziye atanan sabit sayısını değiştirerek ayarlanabilmesidir. Bu durumda, atanan sabit sayısını sayarak dizi boyutuna ayarlamaya gerek kalmaz.
Şimdi, öğrendiklerimizi örnekler üzerinde incelemeye çalışalım:
Örnek
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <iostream>
using namespace std;
int main(void)
{
int idizi[ ] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
int id1, id2;
for (id1=0, id2=0; id1<10; id1++) {
cout << idizi[id1] << " ";
id2 += idizi[id1];
}
cout << "\n";
cout << "Dizide yer alan sayıların toplamı: " << id2;
return 0;
}
Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:
1
2
3
4
1 2 3 4 5 6 7 8 9 10
Dizide yer alan sayıların toplamı: 55
Program, idizi adlı boyutsuz ve int bir dizi tanımlayarak, 1’den 10’a kadar olan sayıları bu diziye ilk değer atama metodu ile atar. Sonra, dizi elemanlarını ve dizi elemanlarının toplamını ekrana yazar.
Örnek
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include <iostream>
using namespace std;
int main(void)
{
char cdizi[ ] = "Diziler";
int id1, id2;
cout << cdizi << "\n";
for (id2=0; cdizi[id2]; id2++)
cout << cdizi[id2];
cout << "\n" << "Dizi eleman sayısı: " << id2 << "\n";
for (id1=0; id1<=id2; id1++)
cout << cdizi[id1];
return 0;
}
Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:
1
2
3
4
5
6
Diziler
Diziler
Dizi eleman sayısı: 7
Diziler
Program, cdizi adlı char ve boyutsuz bir dizi tanımlayarak 3 farklı yöntemle ekrana yazar. Önce “Diziler” kelimesini cdizi dizisine atar. İlk yöntemde diziyi direk ekrana yazar. İkinci yöntemde dizi eleman sayısını for döngüsünü içinde kontrol ederek, üçüncü yöntemde ise önceki yöntemde elde ettiği eleman sayısını for döngüsü içinde kullanarak diziyi ekrana yazar.
Örnek
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <iostream>
using namespace std;
int main(void)
{
int idizi1[] = { 1, 2, 3, 4, 5 };
int idizi2[] = { 21, 22, 23, 24, 25 };
int idizi3[5];
int id;
for (id=0; id<5; id++) {
idizi3[id] = idizi1[id] + idizi2[id];
cout << idizi3[id] << " ";
}
return 0;
}
Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:
1
2
3
22 24 26 28 30
Program, idizi1 ve idizi2 adlı 2 adet boyutsuz ve idizi3 adlı 5 elemanlı int dizi oluşturur. İlk değer atama yöntemi ile ilk iki diziye 5’er adet int değer atar. Sonra, idizi1 ve idizi2 dizi eleman değerlerinin toplamını idizi3 dizisinin elemanlarına atar ve idizi3 dizi eleman değerlerini ekrana yazar.
Çok boyutlu diziler için de, boyutsuz ilk değer atama metodu kullanılabilir. Bunun için, sadece çok boyutlu dizinin ilk boyutunu gösteren, [] işareti içindeki sayı tanımlanmaz. Diğer sayılar mutlaka tanımlanmalıdır.
Örneğin, aşağıdaki işlem satırları, atanan sabit değer sayısını hesap ederek 2 boyutlu 12 elemanlı int bir dizi oluşturur. İlk [] işaretleri arasında herhangi bir sayı tanımlanmadığına dikkat ediniz. Tanımlanan sabit sayısı dikkate alındığında derleyici burada 3 sayısı varmış gibi hareket eder. Başka bir ifade ile, ilk değer atamada girilen satır sayısı [] işaretleri arasında kalan değeri belirler.
1
2
3
4
5
6
7
int idizi[][4] = {
1, 2, 3, 4,
5, 6, 7, 8,
9, 10, 11, 12
};
Çok boyutlu dizilerde boyutsuz dizi yöntemi kullanmak, dizi boyutunu değiştirmeye gerek kalmadan dizi satır sayısını artırma veya azaltma olanağı sağlar. Şimdi konuyu bir örnek üzerinde incelemeye çalışalım:
Örnek
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <iostream>
using namespace std;
int main(void)
{
int idizi[][2] = {
1, 2,
3, 4,
5, 6
};
int id1, id2;
for (id1=0; id1<3; id1++)
for (id2=0; id2<2; id2++) cout << idizi[id1][id2] << " ";
return 0;
}
Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:
1
2
3
1 2 3 4 5 6
Yukarıdaki örnekte, program çok boyutlu idizi adlı int bir diziye ilk değer atama metodu ile sabit değerler atar ve dizi değerlerini ekrana yazar. Diziye ilk değer atamada verilen satır sayısını ve iilk for döngüsü değerinin artırırsanız, program yeni dizi boyutuna uygun olarak çalışır.
Şimdi de, iki boyutlu karakter dizisi dizilerinin boyutsuz olarak tanımlandığı ve dizilere ilk değer atama yönteminin kullanıldığı bir örneği incelemeye çalışalım:
Örnek
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include <iostream>
using namespace std;
int main(void)
{
int id;
char cdizi[][20] = {
"Çoklu", "karakter", "dizileri"
};
for (id=0; id<3; id++) cout << cdizi[id] << " ";
return 0;
}
Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:
1
2
3
Çoklu karakter dizileri
Program önce cdizi adlı boyutsuz bir karakter dizi dizisi tanımlar ve ilk değer atama metodu ile bu diziye 3 farklı karakter dizisi atayarak ekrana yazar.
Üç boyutlu karakter dizisi dizilerine de ilk değer atama yöntemi ile değerler atanabilir. Aşağıdaki işlem satırları 4 ayrı karakter dizisi grubu oluşturur. Her grupta 3 karakter dizisi ve her karakter dizisinde azami 20 karakter yer alır. Karakter dizisi grubu sayısını, diziye ilk değer atama yöntemi ile atanan karakter dizileri belirler:
1
2
3
4
5
6
7
8
char cdizi[][3][21] = {
"Harf", "Rakam", "Sayı",
"Ay", "Dünya", "Güneş",
"Saniye", "Dakika", "Saat",
"Gök", "Deniz", "Toprak"
};
Yukarıdaki dizide yer alan herhangi bir karakter dizisine erişmek için sadece ilk iki dizi boyutunu tanımlamak yeterlidir. Örneğin, aşağıdaki işlem satırı cdizi dizinindeki ikinci grubun ikinci karakter dizisi olan “Dünya” kelimesini ekrana yazar:
1
2
3
cout << cdizi[1][1]);
Şimdi, bu özelliği bir örnek üzerinde incelemeye çalışalım:
Örnek
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
#include <iostream>
#include <cstring>
using namespace std;
int main(void)
{
char cdizi1[][4][21] = {
"Ahmet", "Mülayim", "1974", "Ankara",
"Mehmet", "Kibar", "1987", "İstanbul",
"Kerim", "Candan", "1980", "Samsun",
"Nedim", "Sakin", "1961", "Konya",
"Mehmet", "Nazik", "1969", "Edirne",
"Murat", "Efendi", "1992", "Erzurum",
"Kadir", "Medeni", "1983", "Kars",
" ", " ", " ", " "
};
char cdizi2[21];
int id;
strcpy(cdizi2, "Mehmet");
for (id=0; strcmp(cdizi1[id][0], " "); id++) {
if (!strcmp(cdizi1[id][0], cdizi2)) {
cout << cdizi1[id][0] << " " << cdizi1[id][1] << " " << cdizi1[id][2] << " " << cdizi1[id][3] << "\n";
}
}
return 0;
}
Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:
1
2
3
4
Mehmet Kibar 1987 İstanbul
Mehmet Nazik 1969 Edirne
Yukarıdaki örnekte, program karakter dizisi grubu ilk değer atama yöntemi ile atanan karakter dizileri ile belirlenen 3 boyutlu bir karakter dizi dizisi oluşturur. Her grubu bir kayıt olarak kullanarak, şahıslar hakkındaki bilgileri diziye ilk değer atama yöntemi ile atar. Dizi içindeki kayıt sayısını istenilen miktarda artırılabilir. Sonra, “Mehmet” karakter dizisini dizi içinde aratır ve bulduğu iki kayıt bilgilerini ekrana yazar.
Dizilerin fonksiyonlara argüman olarak geçirilmesi
Bir diziyi bir fonksiyona argüman olarak geçirilebiliriz. Ancak, burada fonksiyona argüman olarak geçirilen dizinin tamamı değil, dizinin ilk elemanının bellekteki adresidir. Bu özelliği bir örnek üzerinde incelemeye çalışalım:
Örnek
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
#include <iostream>
using namespace std;
void fonk(int idizi[]);
int main(void)
{
int idizi[10];
int id;
for (id=0; id<10; id++) {
idizi[id] = id+1;
cout << idizi[id] << " ";
}
cout << "\n";
fonk(idizi); // fonk(&idizi[d1])
for (id=0; id<10; id++) cout << idizi[id] << " ";
return 0;
}
void fonk(int idizi[])
{
int id;
for (id=0; id<10; id++) idizi[id] += 4;
}
Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:
1
2
3
4
1 2 3 4 5 6 7 8 9 10
5 6 7 8 9 10 11 12 13 14
Program, 10 elemanlı int bir dizi tanımlar ve 1’den 10’a kadar olan sayıları bu diziye atar. Dizide yer alan değerleri ekrana yazdıktan sonra dizinin ilk elemanının adresini fonk() fonksiyonuna argüman olarak geçirir. fonk() fonksiyonu dizinin her elemanına 4 sayısını ekler. Sonra, dizi değerlerini tekrar ekrana yazar.
Dizilerin ilk elemanlarının adresleri fonksiyonlara argüman olarak geçirildiğinden, fonksiyon içinde diziye yapılan değişiklikler fonksiyon dışında da geçerlidir.
Şimdi, iki boyutlu bir dizinin bir fonksiyona argüman olarak geçirilme işlemini bir örnek üzerinde incelemeye çalışalım:
Örnek
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
#include <iostream>
using namespace std;
void fonk(int idizi[][5]);
int main(void)
{
int idizi[4][5];
int id1, id2;
for (id1=0; id1<4; id1++) {
for (id2=0; id2<5; id2++) {
idizi[id1][id2] = 1;
cout << idizi[id1][id2] << " ";
}
cout << "\n";
}
cout << "\n";
fonk(idizi); // fonk(&idizi[0][0])
for (id1=0; id1<4; id1++) {
for (id2=0; id2<5; id2++) {
cout << idizi[id1][id2] << " ";
}
cout << "\n";
}
return 0;
}
void fonk (int idizi[][5])
{
int id1, id2;
for (id1=0; id1<4; id1++)
for (id2=0; id2<5; id2++) idizi[id1][id2] = 3;
}
Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:
1
2
3
4
5
6
7
8
9
10
11
1 1 1 1 1
1 1 1 1 1
1 1 1 1 1
1 1 1 1 1
3 3 3 3 3
3 3 3 3 3
3 3 3 3 3
3 3 3 3 3
Program, bir önceki örnekte uyguladığı işlemin aynısını gerçekleştirir. Tek fark fonksiyona argüman olarak geçirilen dizinin bir boyutlu değil iki boyutlu olmasıdır. fonk() fonksiyonu 1 olan idizi eleman değerlerini 3 olarak değiştirir.
Değişken boyutlu diziler
C++’da, dizilerin boyutları çalışma zamanında belirlenebilmektedir.
Şimdi, değişken boyutlu dizi kullanımını bir örnek üzerinde incelemeye çalışalım:
Örnek
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
#include <iostream>
using namespace std;
void fonk(int len);
int main(void)
{
fonk(10);
cout << "\n";
fonk(20);
return 0;
}
void fonk(int len)
{
int idizi[len];
int id;
for (id=0; id<len; id++) {
idizi[id] = id+1;
cout << idizi[id] << " ";
}
}
Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:
1
2
3
4
1 2 3 4 5 6 7 8 9 10
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
Programda tanımlanan fonksiyona geçirilen parametre değeri fonksiyon içindeki int dizinin boyutunu belirlemektedir. Fonksiyon, int diziye 1 sayısından başlayarak dizi boyutu kadar değeri diziye atar ve dizi değerlerini ekrana yazar.