Array dan String
Pengantar
Sebelum sebuah array didefinisikan
secara formal, akan didiskusikan masalah berikut terlebih dahulu. Dimisalkan
bahwa Anda ingin menuliskan sebuah program C++ yang membaca lima angka, mencari
penjumlahan atas tiap angka, dan menampilkan tiap angka dengan urutan terbalik.
Pada Bab 4, Anda telah belajar
bagaimana membaca angka, menampilkannya, dan menghitung penjumlahan atas tiap
angka yang dibaca. Perbedaannya di sini adalah bahwa Anda akan menampilkan
angka – angka tersebut dengan urutan terbalik. Ini berarti bahwa Anda tidak
dapat menampilkan empat angka pertama sampai setelah Anda menampilkan angka
kelima, dan seterusny. Untuk melakukannya, Anda perlu menyimpan semua angka
sebelum menampilkannya dengan urutan terbalik. Dari apa yang telah Anda
pelajari sejauh ini, program berikut dapat menyelesaikan permasalahan ini.
//Program untuk membaca lima angka, mencari
penjumlahan, dan menampilkan
//angka - angka dengan urutan terbalik.
#include
<iostream>
using namespace
std;
int main()
{
int item0, item1, item2, item3, item4;
int jum;
cout
<< "Masukkan lima integer:
";
cin >>
item0 >> item1 >> item2 >> item3 >> item4;
cout
<< endl;
jum = item0
+ item1 + item2 + item3 + item4;
cout
<< "Penjumlahan atas semua
angka = " << jum << endl;
cout
<< "Angka - angka dalam
urutan terbalik adalah: ";
cout
<< item4 << " " << item3 << " "
<< item2 << " "
<< item1 << " " << item0 << endl;
return 0;
}
Keluaran Program:
Masukkan lima integer: 1 2 3 4 5
Penjumlahan atas semua angka = 15
Angka - angka dalam urutan terbalik adalah: 5 4 3 2 1
Program ini dapat bekerja dengan baik.
Tetapi, jika Anda perlu membaca 100 (atau lebih) angka dan menampilkannya
dengan urutan terbalik, maka Anda harus mendeklarasikan 100 variabel dan
menuliskan banyak sekali statemen cin
dan cout. Jadi, untuk data berukuran
besar, jeni program semacam ini tidak diinginkan.
Perhatikan hal – hal berikut pada
program tersebut:
1. Lima variabel
harus dideklarasikan karena lima angka akan ditampilkan dalam urutan terbalik.
2. Semua variabel
bertipe int, jadi, semua variabel bertipe
sama.
3.
Cara bagaimana semua variabel
dideklarasikan mengindikasikan bahwa setiap variabel untuk menyimpan setiap
angka memiliki nama sama, kecuali karakter terakhir (yang merupakan sebuah
angka).
Statemen 1 memberitahu Anda bahwa Anda
harus mendeklarasikan lima variabel. Statemen 3 memberitahu Anda bahwa akan
lebih mudah jika Anda menempatkan karakter terakhir, yang merupakan sebuah
angka, pada sebuah variabel kounter dan menggunakan satu loop for untuk beriterasi dari 0 sampai 4
untuk membaca dan satu loop for lain
untuk beriterasi dari 4 sampai 0 untuk menampilkan. Terakhir, karena semua
variabel bertipe sama, Anda dapat menetapkan berapa banyak variabel yang harus
dideklarasikan, dengan statemen yang lebih sederhana dari yang digunakan pada
statemen tersebut.
Struktur data yang memampukan Anda
melakukannya dalam C++ disebut dengan array.
Array
Array merupakan sebuah koleksi yang
memuat komponen – komponen bertipe data sama, dengan jumlah komponen tetap.
Array satu – dimensi merupakan sebuah array dimana di dalamnya setiap komponen
ditata dalam format sebuah daftar (deret atau senarai). Bagian ini hanya akan
mendiskusikan array satu – dimensi. Array dua – dimensi akan didiskusikan nanti
pada bab ini.
Bentuk umum dalam mendeklarasikan
sebuah array satu – dimensi adalah:
tipeData namaArray[intEksp];
dimana intEksp merupakan sembarang ekspresi konstanta yang dievaluasi
menjadi sebuah integer positif. Selain itu, intEksp menetapkan jumlah komponen yang dimuat di dalam array.
Contoh 8.1
|
Statemen:
int angka[5];
mendeklarasikan sebuah array angka dengan lima komponen. Setiap
komponen bertipe int. Komponen –
komponen tersebut adalah angka[0], angka[1], angka[2], angka[3], dan angka[4]. Gambar 8.1 mengilustrasikan
array angka.
Gambar 8.1 Array angka
Mengakses
Komponen Array
Sintaks umum yang digunakan untuk
mengakses sebuah komponen array adalah:
namaArray[indeksEksp]
dimana indeksEksp, disebut pula dengan indeks, merupakan sembarang
ekspresi yang memiliki nilai integer tak – negatif. Nilai indeks menetapkan
posisi komponen di dalam array.
Dalam C++, [ ] merupakan operator yang
disebut dengan operator subskript array.
Dalam C++, indeks array dimulai dari 0.
Perhatikan statemen berikut:
int
list[10];
Statemen ini mendeklarasikan sebuah
array list yang memuat 10 komponen.
Komponen – komponen tersebut adalah list[0],
list[1], ..., list[9]. Dengan kata lain, Anda telah mendeklarasikan 10 variabel
(lihat Gambar 8.2).
Gambar 8.2 Array list
Statemen penugasan:
list[5] = 34;
menyimpan 34 di dalam list[5], yang merupakan komponen keenam
pada array list (lihat Gambar 8.3).
Gambar 8.3 Array list
setelah eksekusi terhadap statemen list[5]
= 34;
Dimisalkan bahwa i merupakan sebuah
variabel int. Kemudian, statemen
penugasan:
list[3] = 63;
ekivalen dengan dua statemen penugasan
berikut:
i = 3;
list[i] = 63;
Jika i adalah 4, maka statemen
penugasan:
list[2 * i - 3] = 58;
menyimpan 58 di dalam list[5] karena 2 * 5 – 3 dievaluasi menjadi 5. Ekspresi indeks dievaluasi terlebih
dahulu, menghasilkan posisi komponen pada array.
Selanjutnya, perhatikan beberapa
statemen berikut:
list[3] = 10;
list[6] = 35;
list[5] = list[3] + list[6];
Statemen pertama menyimpan 10 di dalam list[3], statemen kedua menyimpan 35 di
dalam list[6], dan statemen ketiga
menambahkan isi dari list[3] dan list[6] dan menyimpan hasilnya di dalam
list[5]. Lihat Gambar 8.4.
Gambar 8.4 Array list setelah eksekusi statemen list[3] = 10; list[6] = 35; list[5] = list[3] +
list[6];
Contoh 8.2
|
Anda juga dapat mendeklarasikan array
sebagai berikut:
const int UKURAN_ARRAY = 10;
int
list[UKURAN_ARRAY];
Yaitu, Anda dapat terlebih dahulu
mendeklarasikan sebuah konstanta bernama dan kemudian menggunakan nilainya
untuk mendeklarasikan sebuah array dan menetapkan ukurannya.
Memproses
Array Satu – Dimensi
Beberapa operasi dasar yang dapat
diterapkan pada sebuah array satu – dimensi adalah penginisialisasian,
pembacaan data, penampilan data, dan pencarian elemen terbesar dan/atau
terkecil. Selain itu, jika data berupa angka numerik, beberapa operasi dasar
lain yang dapat diterapkan pada sebuah array satu – dimensi adalah mencari
penjumlahan dan rerata elemen – elemen array. Setiap operasi ini mensyaratkan kemampuan
untuk menjelajah elemen – elemen array. Hal ini dilakukan menggunakan sebuah
loop. Sebagai contoh, dimisalkan bahwa Anda memiliki beberapa statemen berikut:
int list[100]; //list merupakan sebuah array dengan ukuran 100
int
i;
Loop for berikut melangkah melalui tiap elemen pada array list, dimulai dari elemen pertama array
list:
for (i = 0; i < 100; i++) //Baris
1
//memproses list[i] //Baris 2
Jika pemrosesan array list memerlukan pembacaan data ke dalam
list, maka statemen pada baris 2
berupa sebuah statemen masukan, seperti statemen cin. Sebagai contoh, beberapa statemen berikut membaca 100 angka
dari papanketik dan menyimpannya di dalam array list:
for (i = 0; i < 100; i++) //Baris
1
cin >> list[i]; //Baris 2
Sama halnya, jika pemrosesan list memerlukan penampilan data, maka
statemen pada baris 2 berupa sebuah statemen keluaran. Contoh 8.3 lebih lanjut
akan mengilustrasikan bagaimana memproses array satu – dimensi.
Contoh 8.3
|
Contoh ini akan menunjukkan bagaimana
loop dipakai untuk memproses array. Deklarasi berikut digunakan pada contoh
ini:
double penjualan[10];
int indeks;
double penjualanTerbesar,
jum, rerata;
Statemen pertama mendeklarasikan sebuah
array penjualan yang memuat 10
komponen, dimana tiap komponen bertipe double.
Makna dari dua statemen lain cukup jelas.
a.
Penginisialisasian
array: Loop berikut menginisialisasi setiap komponen
dari array penjualan dengan 0.0.
for (indeks = 0; indeks < 10; indeks++)
penjualan[indeks] = 0.0;
b. Pembacaan data ke dalam sebuah array: Loop berikut membaca data ke dalam
array penjualan. Agar lebih
sederhana, diasumsikan bahwa data dientrikan dari papanketik.
for (indeks = 0; indeks < 10; indeks++)
cin >> penjualan[indeks];
c.
Penampilan
sebuah array: Loop berikut akan menampilkan array penjualan. Agar sederhana, diasumsikan
bahwa keluaran akan ditampilkan pada layar.
for (indeks = 0; indeks < 10; indeks++)
cout << penjualan[indeks] <<
" ";
d.
Penghitungan penjumlahan
dan rerata sebuah array: Karena array penjualan, seperti yang diindikasikan namanya, merepresentasikan
data penjualan, adalah hal yang wajar untuk mencari total penjualan dan rerata
penjualan. Kode C++ berikut menghitung penjumlahan tiap elemen array penjualan dan reratanya:
jum = 0;
for (indeks = 0; indeks < 10; indeks++)
jum = jum + penjualan[indeks];
rerata = jum / 10;
Sekarang setelah Anda mengetahui
bagaimana mendekalrasikan dan memproses array, selanjutnya akan ditulis – ulang
program yang didiskusikan di awal bab ini. Ingat bahwa program ini membaca lima
angka, menghitung penjumlahan elemen, dan menampilkan tiap elemen dengan urutan
terbalik.
Contoh 8.4
|
//Program untuk membaca lima angka, menghitung
penjumlahannya, dan
//menampilkan tiap angka dalam urutan terbalik.
#include
<iostream>
using namespace
std;
int main()
{
int item[5]; //Mendeklarasikan sebuah
array item dengan lima komponen
int jum;
int kounter;
cout
<< "Masukkan lima angka:
";
jum = 0;
for (kounter = 0; kounter < 5;
kounter++)
{
cin
>> item[kounter];
jum =
jum + item[kounter];
}
cout
<< endl;
cout
<< "Penjumlahan atas tiap
angka adalah: " << jum << endl;
cout
<< "Angka - angka dalam urutan
terbalik adalah: ";
//Menampilkan angka - angka dalam urutan terbalik.
for (kounter = 4; kounter >= 0;
kounter--)
cout
<< item[kounter] << " ";
cout
<< endl;
return 0;
}
Keluaran Program:
Masukkan lima angka: 13 43 53 -87 89
Penjumlahan atas tiap angka adalah: 111
Angka - angka dalam urutan terbalik adalah: 89 -87 53
43 13
Indeks
Array di Luar Batas
Perhatikan deklarasi berikut:
double angka[10];
int
i;
Tiap komponen angka[i] valid, jika i merupakan sebuah indeks valid dengan nilai i
= 0, 1, ..., 9.
Indeks sebuah array berada di dalam
batas jika indeks > = 0 dan indeks <= UKURAN_ARRAY. Jika indeks < 0
atau indeks > UKURAN_ARRAY - 1,
maka dikatakan bahwa indeks array di luar batas.
Sayangnya, dalam C++, tidak ada
pengawal untuk mengawasi indeks agar tidak berada di luar rentang. Jadi, C++
tidak memeriksa apakah nilai indeks di dalam rentang atau tidak. Jika indeks
berada di luar batas dan program mencoba mengakses komponen yang dispesifikasi
oleh indeks tersebut, maka apapun lokasi memori yang diindikasikan oleh indeks
akan diakses. Situasi ini dapat menyebabkan pengubahan atau pengaksesa data
sebuah lokasi memori yang Anda sendiri tidak berniat untuk mengakses atau
memodifikasinya. Akibatnya, beberapa hal aneh dapat terjadi jika indeks berada
di luar rentang selama eksekusi berlangsung. Ini merupakan tanggung jawab
programer untuk memastikan bahwa indeks berada di dalam batas yang diijinkan.
Sebuah loop seperti berikut dapat
dipakai untuk mengakibatkan indeks berada di luar batas:
for (i = 0; i <= 10; i++)
list[i] = 0;
Di sini, diasumsikan bahwa list merupakan sebuah array dengan 10
komponen. Ketika i menjadi 10, maka
kondisi pengujian loop, i < = 10,
akan dievaluasi menjadi true dan
tubuh loop akan dieksekusi, yang menyebabkan penyimpanan 0 di dalam list[10]. Padahal, list[10] tidak ada.
Inisialisasi
Array Selama Deklarasi
Sama seperti sembarang variabel
sederhana, sebuah array dapat diinisialisasi ketika ia sedang dideklarasikan.
Sebagai contoh, statemen C++ berikut mendeklarasikan sebuah array, penjualan, dengan lima komponen dan
menginisialisasi semua komponen tersebut:
double penjualan[5]
= {12.25, 32.50, 16.90, 23, 45.68};
Nilai – nilai ditempatkan di antara dua
kurung kurawal dan dipisahkan oleh koma. Di sini, penjualan[0] = 12.25, penjualan[1]
= 32.50, penjualan[2] = 16.90, penjualan[3] = 23.00, dan penjualan[4] = 45.68.
Ketika menginisialisasi array pada saat
pendeklarasian, Anda tidak diharuskan menetapkan ukuran array. Ukuran
ditentukan oleh jumlah nilai awal yang diapit oleh sepasang kurung kurawal.
Namun, Anda harus mencantumkan sepasang kurung kurawal yang ditempatkan setelah
nama array. Statemen sebelumnya ekivalen dengan:
double penjualan[]
= {12.25, 32.50, 16.90, 23, 45.68};
Inisialisasi
Parsial atas Array Selama Deklarasi
Ketika Anda mendeklarasikan dan
menginisialisasi sebuah array secara bersamaan, Anda tidak harus
menginisialisasi semua komponen array. Prosedur
ini dikenal dengan inisialisasi parsial atas sebuah array selama pendeklarasian.
Namun, jika Anda secara parsial menginisialisasi sebuah array selama
pendeklarasian array, Anda harus berhati – hati dalam beberapa hal. Beberapa
contoh berikut dipakai untuk menjelaskan apa yang terjadi ketika Anda
mendeklarasikan dan secara parsial menginisialisasi sebuah array.
Statemen:
int
list[10] = {0};
mendeklarasikan list sebagai sebuah array dengan 10 komponen dan menginisialisasi
semua komponen dengan 0.
Statemen:
int
list[10] = {8, 5, 12};
mendeklarasikan list sebagai sebuah array dengan 10 komponen dan menginisialisasi list[0] dengan 8, list[1] dengan 5, list[2]
dengan 12, dan semua komponen lain dengan 0. Jadi, jika semua nilai tidak
ditetapkan pada statemen inisialisasi, maka komponen – komponen yang nilai –
nilainya tidak ditetapkan diinisialisasi dengan 0. Perhatikan bahwa, di sini,
ukuran array pada statemen deklarasi harus menjadi perhatian. Sebagai contoh,
statemen:
int list[] = {5, 6, 3};
mendeklarasikan list sebagai sebuah array dengan tiga komponen dan menginisialisasi
list[0] dengan 5, list[1] dengan 6, dan list[2] dengan 3. Selanjutnya,
statemen:
int list[25] = {4, 7};
mendeklarasikan list sebagai sebuah array denagan 25 komponen. Dua komponen pertama
diinisialisasi dengan 4 dan 7, dan semua komponen lain diinisialisasi dengan 0.
Ketika Anda secara parsial
menginisialisasi sebuah array, maka semua elemen yang terletak setelah elemen
tak – terinisialisasi terakhir harus tidak diinisialisasi. Oleh karena itu,
statemen berikut akan menyebabkan error sintaks:
int
list[10] = {2, 5, 6, , 8}; //illegal
Pada inisialisasi ini, karena elemen
keempat tidak diinisialisasi, maka semua elemen setelahnya harus tidak
diinisialisasi.
Beberapa
Pembatasan pada Pemrosesan Array
Perhatikan beberapa statemen berikut:
int arrayKu[5] = {0, 4, 8, 12, 16}; //Baris
1
int arrayMu[5];
//Baris 2
Statemen pada baris 1 mendeklarasikan
dan menginisialisasi arrayKu, dan
statemen pada baris 2 mendeklarasikan arrayMu.
Perhatikan bahwa kedua array ini bertipe sama dan memiliki jumlah komponen yang
sama. Dimisalkan bahwa Anda ingin menyalin elemen – elemen dari arrayKu ke dalam arrayMu. Statemen berikut adalah ilegal:
arrayMu = arrayKu; //ilegal
Statemen ini akan menghasilkan error
sintaks. C++ tidak membolehkan operasi agregat pada sebuah array. Sebuah
operasi agregat pada suatu array adalah sembarang operasi yang memanipulasi
keseluruhan array sebagai unit tunggal.
Untuk menyalin sebuah array ke dalam
array lain, Anda harus menyalinnya komponen demi komponen. Ini dapat dilakukan
menggunakan sebuah loop, seperti berikut:
for (int indeks = 0; indeks <
5; indeks++)
arrayMu[indeks] = arrayKu[indeks];
Selanjutnya, dimisalkan bahwa Anda
ingin membaca data ke dalam array arrayMu.
Statemen berikut adalah salah dan akan menghasilkan error sintaks.
cin >> arrayMu; //ilegal
Untuk membaca data ke dalam arrayMu, Anda harus membaca komponen
demi komponen, menggunakan sebuah loop seperti berikut:
for (int indeks = 0; indeks <
5; indeks++)
cin >> arrayMu[indeks];
Sama halnya, penentuan apakah kedua
array memiliki elemen – elemen yang sama dan penampilan isi sebuah array harus
dilakukan komponen demi komponen. Perhatikan bahwa beberapa statemen berikut
adalah ilegal, karena akan menghasilkan error sintaks.
cout << arrayMu;
if (arrayKu <= arrayMu)
...
Array
sebagai Parameter pada Fungsi
Karena Anda telah melihat bagaimana
bekerja dengan array, pertanyaan berikutnya akan muncul: Bagaimana array
dilewatkan sebagai parameter kepada fungsi?
Hanya lewat referensi: Dalam C++, array
dilewatkan hanya dengan referensi.
Karena array hanya dilewatkan dengan
referensi, Anda tidak perlu menggunakan simbol & ketika mendeklarasikan sebuah array
sebagai parameter formal.
Ketika mendeklarasikan sebuah array
satu – dimensi sebagai parameter formal, ukuran array biasanya diabaikan. Jika
Anda menetapkan ukuran sebuah array satu – dimensi ketika mendeklarasikannya
sebagai parameter formal, maka ukuran tersebut akan diabaikan oleh kompiler.
Contoh 8.5
|
Perhatikan fungsi berikut:
void fungArrayParam(int listSatu[],
double listDua[])
{
.
.
.
}
Fungsi fungArrayParam memiliki dua parameter formal: (1) listSatu, sebuah array satu – dimensi
bertipe int (yaitu, tipe komponen
adalah int) dan (2) listDua, sebuah array satu – dimensi
bertipe double. Pada deklarasi ini,
ukuran kedua array tidak ditetapkan.
Kadangkala, jumlah elemen di dalam
array dapat berjumlah kurang dari ukuran array. Sebagai contoh, jumlah elemen
di dalam sebuah array yang menyimpan data mahasiswa dapat bertambah atau
berkurang seiring dengan kemauan mahasiswa dalam mengambil atau membatalkan
matakuliah. Pada situasi semacam itu, Anda ingin memproses hanya komponen –
komponen array yang menampung data aktual. Untuk menuliskan sebuah fungsi dalam
memproses array semacam itu, di samping mendeklarasikan sebuah array sebagai
parameter formal, Anda perlu mendeklarasikan suatu parameter formal lain yang
menetapkan jumlah elemen di dalam array, seperti pada fungsi berikut:
void inisialisasi(int list[], int ukuranList)
{
int hitung;
for (hitung = 0; hitung < ukuranList; hitung++)
list[hitung] = 0;
}
Parameter pertama pada fungsi inisialisasi adalah sebuah array int, dengan ukuran sembarang. Ketika
fungsi inisialisasi dipanggil,
ukuran dari array aktual dilewatkan sebagai parameter kedua dari fungsi inisialisasi.
Array
Konstan sebagai Parameter Formal
Ingat bahwa ketika parameter formal
adalah sebuah parameter referensi, maka kapanpun parameter formal berubah,
parameter aktual pun ikut berubah. Namun, meskipun sebuah array selalu
dilewatkan dengan referensi, Anda masih bisa mencegah fungsi agar tidak
mengubah parameter aktual. Anda bisa melakukannya menggunakan katakunci const di dalam deklarasi parameter
formal. Perhatikan fungsi berikut:
void contoh(int x[], const int y[], int ukuranX, int ukuranY)
{
...
}
Di sini, fungsi contoh dapat memodifikasi array x, tetapi tidak bisa memodifikasi array y. Setiap percobaan untuk mengubah y akan menyebabkan error kompilasi. Hal ini merupakan teknik
pemrograman yang baik dalam mendeklarasikan sebuah array konstan sebagai
parameter formal jika Anda tidak ingin fungsi memodifikasi array.
Contoh 8.6
|
Contoh ini menunjukkan bagaimana
menulis fugnsi untuk pemrosesan array dan mendeklarasikan sebuah array sebagai
parameter formal.
//Fungsi untuk menginisialisasi sebuah array int dengan 0.
//Array yang akan diinisialisasi dan ukurannya dilewatkan
//sebagai parameter. Parameter ukuranList menetapkan
//jumlah elemen yang akan diinisialisasi.
void inisialisasiArray(int
list[], int ukuranList)
{
int indeks;
for (indeks = 0; indeks < ukuranList; indeks++)
list[indeks] = 0;
}
//Fungsi untuk membaca dan menyimpan data ke dalam sebuah array int.
//Array tempat penyimpanan dan ukurannya dilewatkan sebagai
//paramer. Parameter ukuranList menetapkan jumlah
//elemen yang akan dibaca.
void isiArray(int list[], int ukuranList)
{
int indeks;
for (indeks = 0; indeks < ukuranList; indeks++)
cin >> list[indeks];
}
//Fungsi untuk menampilkan elemen-elemen sebuah array int.
//Array yang akan ditampilkan dan jumlah elemen dilewatkan
//sebagai parameter. Parameter ukuranList menetapkan
//jumlah elemen yang akan ditampilkan.
void tampilArray(const int list[], int ukuranList)
{
int indeks;
for (indeks = 0; indeks < ukuranList; indeks++)
cout << list[indeks]
<< " ";
}
//Fungsi untuk menghitung dan menjadikan nilai balik penjumlahan
//elemen-elemen sebuah array int. Parameter ukuranList
//menetapkan jumlah elemen yang akan dijumlahkan.
int jumArray(const int list[], int ukuranList)
{
int indeks;
int jum = 0;
for (indeks = 0; indeks < ukuranList; indeks++)
jum = jum + list[indeks];
return jum;
}
//Fungsi untuk mencari elemen terbesar pertama di dalam array int
//dan menjadikan indeksnya sebagai nilai balik. Parameter ukuranList
//menetapkan jumlah elemen di dalam array.
int indeksElemenTerbesar(const int list[], int ukuranList)
{
int indeks;
int indeksMaks = 0; // diasumsikan elemen
terbesar adalah yang pertama
for (indeks = 1; indeks < ukuranList; indeks++)
if (list[indeksMaks] < list[indeks])
indeksMaks = indeks;
return indeksMaks;
}
//Fungsi untuk menyalin semua atau beberapa elemen sebuah array
//ke dalam array lain. Dimulai dari posisi yang dispesifikasi
//oleh sumber, elemen-elemen dari list1 disalin ke dalam list2
//dimulai pada posisi yang dispesifikasi oleh target. Parameter
//jumElemen menetapkan jumlah elemen dari list1
//yang akan disalin ke dalam list2. Dimulai pada posisi yang ditetapkan
//oleh target, list2 harus memiliki cukup komponen untuk menyalin
//elemen-elemen dari list1. Pemanggilan berikut menyalin semua
//elemen dari list1 ke dalam list2:
//salinArray(list1, 0, list2, 0, jumElemen);
void salinArray(int list1[], int sumber, int list2[],
int target, int
jumElemen)
{
for (int indeks = sumber;
indeks < sumber + jumElemen; indeks++)
{
list2[indeks] = list1[target];
target++;
}
}
Contoh 8.7 akan mengilustrasikan
bagaimana menggunakan fungsi – fungsi tersebut di dalam sebuah program.
Alamat
Basis Sebuah Array
Alamat basis sebuah array adalah alamat
(lokasi memori) dari komponen array pertama. Sebagai contoh, jika list adalah sebuah array satu –
dimensi, maka alamat basis dari list
adalah alamat dari komponen list[0].
Perhatikan statemen berikut:
int listKu[5];
//Baris 1
Statemen ini mendeklarasikan listKu sebagai sebuah array dengan lima
komponen bertipe int. Komponen –
komponen tersebut aralah listKu[0], listKu[1], listKu[2], listKu[3],
dan listKu[4]. Komputer
mengalokasikan lima ruang memori, yang cukup besar untuk menyimpan sebuah nilai
int, untuk stiap komponen. Kelima
ruang memori tersebut bertetangga.
Alamat basis dari array listKu adalah alamat dari komponen listKu[0]. Dimisalkan bahwa alamat basis
dari array listKu adalah 1000. Maka,
alamat dari listKu[0] adalah 1000.
Umumnya, memori yang dialokasikan untuk sebuah variabel int adalah empat byte.
Ingat bahwa memori utama adalah sebuah runtun sel terurut, dimana setiap sel
mempunyai alamat unik. Umumnya, setiap sel adalah satu byte. Oleh karena itu,
untuk menyimpan sebuah nilai ke dalam listKu[0],
dimulai dari alamat 1000, maka keempat byte berikutnya dialokasikan untuk listKu[0]. Dapat dipahami bahwa alamat
awal dari listKu[1] adalah 1004,
alamat awal dari listKu[2] adalah
1008, dan seterusnya (lihat Gambar 8.5).
Gambar 8.5 Array lisKu dan
alamat dari tiap komponennya
listKu adalah nama sebuah array. Terdapat sebuah ruang memori yang
berkaitan dengan pengenal listKu,
dan alamat basis dari array tersebut disimpan di dalam ruang memori itu.
Perhatikan statemen berikut:
cout << listKu <<
endl; //Baris 2
Sebelumnya, telah dikatakan bahwa
statemen ini tidak akan memberikan hasil yang diinginkan. Jadi, statemen ini
tidak akan menampilkan nilai tiap komponen dari listKu. Statemen ini sebenarnya menampilkan nilai dari listKu, yang merupakan alamat basis
dari array tersebut. Inilah mengapat statemen ini tidak menghasilkan error
sintaks.
Dimisalkan bahwa Anda juga memiliki
statemen berikut:
int listMu[5];
Maka, di dalam statemen:
if (listKu <= listMu) //Baris 3
...
ekspresi listKu <= listMu dievaluasi menjadi true jika alamat basis dari array listKu kurang dari alamat basis dari array listMu; dan dievaluasi menjadi flase
jika sebaliknya. Hal ini tidak menentukan apakah elemen – elemen dari listKu bernilai kurang dari atau sama
dengan elemen – elemen dari listMu.
Anda mungkin heran mengapa alamat basis
sebuah array menjadi sangat penting. Alasannya adalah bahwa ketika Anda
mendeklarasikan sebuah array, satu – satunya hal tentang array yang diingat
komputer adalah nama array, alamat basisnya, dan tipe data dari tiap
komponennya, dan jumlah komponennya. Dengan menggunakan alamat basis array dan
indeks dari tiap komponennya, komputer dapat menentukan alamat dari komponen
tertentu. Sebagai contoh, dimisalkan bahwa Anda ingin mengakses nilai dari listKu[3]. Diketahui bahwa alamat basis
dari listKu adalah 1000. Setiap komponen dari listKu bertipe int, jadi
ia menggunakan empat byte untuk menyimpan sebuah nilai, dan indeks bernilai 3.
Untuk mengakses nilai dari listKu[3],
komputer menghitung alamat 1000 + 4 * 3 = 1012. Jadi, 1003 adalah alamat awal
dari listKu[3].
Ketika Anda melewatkan array sebagai
sebuah parameter, alamat basis dari array aktual dilewatkan kepada parameter
formal. Sebagai contoh, dimisalkan bahwa Anda memiliki fungsi berikut:
void arraySbgParam(int list[], int ukuran)
{
...
list[2] = 28; //Baris 4
...
}
Juga, dimisalkan bahwa Anda memiliki
pemanggilan terhadap fungsi ini sebagai berikut:
arraySbgParam(listKu, 5); //Baris
5
Pada statemen ini, alamat basis dari listKu dilewatkan kepada parameter
formal list. Oleh karena itu, alamat
basis dari list adalah 1000.
Definisi atas fungsi arraySbgParam
memuat statemen list[2] = 28;.
Statemen ini menyimpan 28 ke dalam list[2].
Untuk mengakses list[2], komputer
menghitug alamatnya sebagai berikut: 1000
+ 4 * 2 = 1008. Jadi, dimulai dari alamat awal 1008, komputer mengakses
empat byte berikutnya dan menyimpan nilai 28. Perhatikan bahwa 1008 merupakan
alamat dari listKu[2] (lihat Gambar
8.5). Dapat dipahami bahwa selama eksekusi terhadap statemen pada baris 5,
statemen pada baris 4 menyimpan 28 ke dalam listKu[2]. Dapat dipahami pula bahwa selama eksekusi terhadap
statemen pemanggilan fungsi pada baris 5, list[indeks]
dan listKu[indeks] merujuk ke ruang
memori yang sama, yaitu 0 < = indeks
dan indeks < 5.
Fungsi
Tidak Bisa Menghasilkan Nilai Balik Bertipe Array
C++ tidak membolehkan fungsi untuk
menghasilkan nilai balik bertipe array. Perhatikan bahwa fungsi jumArray dan indeksElemenTerbesar yang dijelaskan sebelumnya menghasilkan nilai
balik bertipe int.
Contoh 8.7
|
Program berikut mengilustrasikan
bagaimana array dilewatkan sebagai parameter aktual di dalam sebuah pemanggilan
fungsi. Perhatikan bahwa program ini menggunakan fungsi – fungsi yang ditulis
pada contoh 8.6.
//Array sebagai
parameter pada fungsi
#include <iostream>
using namespace std;
const int UKURAN_ARRAY = 10;
void inisialisasiArray(int x[],int ukuranX);
void isiArray(int x[],int ukuranX);
void tampilArray(const int x[],int ukuranX);
int jumArray(const int x[],int ukuranX);
int indeksElemenTerbesar(const int x[],int ukuranX);
void salinArray(int list1[], int sumber, int list2[],
int target, int jumElemen);
int main()
{
int
listA[UKURAN_ARRAY] = {0}; //Mendeklarasikan array listA
//dengan 10
komponen dan
//menginisialisasi setiap komponen
//dengan 0.
int
listB[UKURAN_ARRAY]; //Mendeklarasikan array listB
//dengan 10
komponen.
cout << "Baris 1: elemen-elemen listA: "; //Baris 1
//Menampilkan elemen-elemen dari listA
menggunakan
//fungsi tampilArray
tampilArray(listA, UKURAN_ARRAY); //Baris 2
cout << endl; //Baris 3
//Inisialisasi listB menggunakan fungsi
//inisialisasiArray
inisialisasiArray(listB, UKURAN_ARRAY); //Baris 4
cout << "Baris 5: elemen-elemen listB: "; //Baris 5
//Menampilkan elemen-elemen dari listB
menggunakan
//fungsi tampilArray
tampilArray(listB, UKURAN_ARRAY); //Baris 6
cout << endl; //Baris 7
cout << "Baris 8: Masukkan " << UKURAN_ARRAY
<< " buah integer: "; //Baris
8
//Membaca data ke dalam listA menggunakan
//function fillArray
isiArray(listA, UKURAN_ARRAY); //Baris 9
cout << endl; //Baris 10
cout << "Baris 11: Setelah mengisi listA, "
<< "elemen-elemennya adalah:" << endl; //Baris 11
//Menampilkan elemen-elemen dari listA
tampilArray(listA, UKURAN_ARRAY); //Baris 12
cout << endl << endl; //Baris 13
//Menghitung dan menampilkan penjumlahan
atas
//elemen-elemen dari listA
cout << "Baris 14: Penjumlahan atas
elemen-elemen "
<< "dari listA adalah:
"
<< jumArray(listA, UKURAN_ARRAY)
<< endl
<< endl; //Baris 14
//Mencari dan menampilkan posisi dari
elemen
//terbesar di dalam listA
cout << "Baris 15: Posisi dari elemen terbesar "
<< "di dalam listA adalah: "
<< indeksElemenTerbesar(listA,
UKURAN_ARRAY)
<< endl; //Baris 15
//Menghitng dan menampilkan elemen terbesar
//di dalam listA
cout << "Baris 16: Elemen terbesar di dalam "
<< "listA adalah: "
<<
listA[indeksElemenTerbesar(listA, UKURAN_ARRAY)]
<< endl << endl; //Baris 16
//Menyalin elemen-elemen dari listA ke
dalam listB
//menggunakan fungsi salinArray
salinArray(listA, 0, listB, 0,
UKURAN_ARRAY); //Baris
17
cout << "Baris 18: Setelah penyalinan elemen-elemen "
<< "dari listA ke dalam listB," << endl
<< "Elemen-elemen dari listB adalah: "; //Baris 18
//Menampilkan elemen-elemen dari listB
tampilArray(listB, UKURAN_ARRAY); //Baris 19
cout << endl; //Baris 20
return
0;
}
//Fungsi untuk
menginisialisasi sebuah array int dengan 0.
//Array yang
akan diinisialisasi dan ukurannya dilewatkan
//sebagai
parameter. Parameter ukuranList menetapkan
//jumlah elemen
yang akan diinisialisasi.
void inisialisasiArray(int list[], int ukuranList)
{
int
indeks;
for
(indeks = 0; indeks < ukuranList; indeks++)
list[indeks] = 0;
}
//Fungsi untuk
membaca dan menyimpan data ke dalam sebuah array int.
//Array tempat
penyimpanan dan ukurannya dilewatkan sebagai
//paramer.
Parameter ukuranList menetapkan jumlah
//elemen yang
akan dibaca.
void isiArray(int list[], int ukuranList)
{
int
indeks;
for
(indeks = 0; indeks < ukuranList; indeks++)
cin >> list[indeks];
}
//Fungsi untuk
menampilkan elemen-elemen sebuah array int.
//Array yang
akan ditampilkan dan jumlah elemen dilewatkan
//sebagai
parameter. Parameter ukuranList menetapkan
//jumlah elemen
yang akan ditampilkan.
void tampilArray(const int list[], int
ukuranList)
{
int
indeks;
for
(indeks = 0; indeks < ukuranList; indeks++)
cout << list[indeks] <<
" ";
}
//Fungsi untuk
menghitung dan menjadikan nilai balik penjumlahan
//elemen-elemen
sebuah array int. Parameter ukuranList
//menetapkan
jumlah elemen yang akan dijumlahkan.
int jumArray(const int list[], int
ukuranList)
{
int
indeks;
int
jum = 0;
for
(indeks = 0; indeks < ukuranList; indeks++)
jum = jum + list[indeks];
return
jum;
}
//Fungsi untuk
mencari elemen terbesar pertama di dalam array int
//dan menjadikan
indeksnya sebagai nilai balik. Parameter ukuranList
//menetapkan
jumlah elemen di dalam array.
int indeksElemenTerbesar(const int list[], int
ukuranList)
{
int
indeks;
int
indeksMaks = 0; //diasumsikan elemen
terbesar adalah yang pertama
for
(indeks = 1; indeks < ukuranList; indeks++)
if
(list[indeksMaks] < list[indeks])
indeksMaks = indeks;
return
indeksMaks;
}
//Fungsi untuk
menyalin semua atau beberapa elemen sebuah array
//ke dalam array
lain. Dimulai dari posisi yang dispesifikasi
//oleh sumber,
elemen-elemen dari list1 disalin ke dalam list2
//dimulai pada
posisi yang dispesifikasi oleh target. Parameter
//jumElemen
menetapkan jumlah elemen dari list1
//yang akan
disalin ke dalam list2. Dimulai pada posisi yang ditetapkan
//oleh target,
list2 harus memiliki cukup komponen untuk menyalin
//elemen-elemen
dari list1. Pemanggilan berikut menyalin semua
//elemen dari
list1 ke dalam list2:
//salinArray(list1,
0, list2, 0, jumElemen);
void salinArray(int list1[], int sumber, int list2[],
int target, int
jumElemen)
{
for
(int indeks = sumber; indeks <
sumber + jumElemen; indeks++)
{
list2[indeks] = list1[target];
target++;
}
}
Keluaran Program:
Baris 1: elemen-elemen listA: 0 0 0 0 0 0 0 0 0 0
Baris 5: elemen-elemen listB: 0 0 0 0 0 0 0 0 0 0
Baris 8: Masukkan 10 buah integer: 1 2 3 4 5 6 7 8 9 0
Baris 11: Setelah mengisi listA, elemen-elemennya
adalah:
1 2 3 4 5 6 7 8 9 0
Baris 14: Penjumlahan atas elemen-elemen dari listA
adalah: 45
Baris 15: Posisi dari elemen terbesar di dalam listA
adalah: 8
Baris 16: Elemen terbesar di dalam listA adalah: 9
Baris 18: Setelah penyalinan elemen-elemen dari listA
ke dalam listB,
Elemen-elemen dari listB adalah: 1 2 3 4 5 6 7 8 9 0
Keluaran dari program ini cukup
sederhana untuk dimengerti. Pertama, array listA
dideklarasikan dengan 10 komponen dan setiap komponennya diinisialisasi dengan
0. Kemudian, array listB
dideklarasikan dengan 10 komponen. Statemen pada baris 2 memanggil fungsi tampilArray dan menampilkan nilai –
nilai yang disimpan di dalam listA.
Statemen pada baris 9 memanggil fungsi isiArray
untuk menempatkan data ke dalam listA.
Statemen pada baris 14 memanggil fungsi jumArray
dan menampilkan hasil penjumlahan atas semua elemen listA. Sama halnya, statemen pada baris 16 menampilkan nilai dari
elemen terbesar di dalam listA.
Tipe
Data Integral dan Indeks Array
Selain integer, C++ membolehkan
sembarang tipe integral lain untuk digunakan sebagai indeks array. Fitur ini
dapat meningkatkan keterbacaan sebuah program. Perhatikan beberapa statemen
berikut:
enum tipeWarna{HIJAU, MERAH, BIRU, COKLAT, PUTIH, ORANYE, KUNING};
double penjualanWarna[7];
tipeWarna warna;
Loop berikut menginisialisasi setiap
komponen array penjualanWarna dengan
0:
for (warna = HIJAU; warna <= KUNING;
warna = static_cast<tipeWarna>(warna
+ 1))
penjualanWarna[warna] = 0.0;
Statemen berikut memperbarui jumlah
penjualan dari warna MERAH:
penjualanWarna[MERAH] = penjualanWarna[MERAH]
+ 75.69;
Seperti yang dapat Anda lihat, kode
tersebut jauh lebih mudah dipahami daripada kode yang memakai integer sebagai
indeks. Karena alasan ini, Anda sebaiknya menggunakan tipe enumerasi untuk
indeks array atau tipe integral lain jika memungkinkan. Perhatikan bahwa ketika
menggunakan tipe enumerasi sebagai indeks array, Anda perlu menggunakan nilai –
nilai default dari tiap pengenal. Yaitu, nilai dari pengenal pertama harus 0,
dan seterusnya.
Cara
Lain Mendeklarasikan Array
Dimisalkan bahwa sebuah kelas mempunyai
20 mahasiswa dan Anda perlu menjejak skor tiap mahasiswa tersebut. Karena
jumlah mahasiswa dapat berubah dari semester ke semester berikutnya, daripada
menetapkan ukuran array ketika mendeklarasikannya, Anda dapat mendeklerasikan
array dengan cara seperti ini:
const int JUMLAH_MHS = 20;
int skorUjian[JUMLAH_MHS];
Beberapa cara lain untuk
mendeklarasikan array adalah:
const int UKURAN = 50; //Baris 1
typedef double list[UKURAN];
//Baris 2
list listMu; //Baris
3
list listKu; //Baris 4
Statemen pada baris 2 mendefinisikan
sebuah tipe data list, yang
merupakan sebuah array dengan 50 komponen bertipe double. Statemen pada baris 3 dan 4 mendeklarasikan dua variabel, listMu dan listKu. Keduanya merupakan array dengan 50 komponen bertipe double. Statemen – statemen tersebut
ekivalen dengan:
double listMu[50];
double listKu[50];
Pencarian
Item pada Array
Pencarian sebuah item tertentu pada
array merupakan salah satu operasi yang paling umum dilakukan. Algoritma
pencarian yang akan dijelaskan adalah pencarian sekuensial atau pencarian
linier. Seperti terimplikasi dari namanya, Anda melakukan pencarian pada array
secara sekuensial, dimulai dari elemen pertama array. Anda membandingkan itemCari dengan elemen – elemen lain di
dalam array dan terus melakukan pencarian sampai Anda menemukan item yang dicari
atau sampai tidak ada lagi data yang akan dibandingkan dengan itemCari.
Perhatikan array list dengan tujuh elemen yang ditunjukkan pada Gambar 8.6.
Gambar 8.6 Sebuah array dengan tujuh elemen
Dimisalkan bahwa Anda ingin menentukan
apakah 27 ada di dalam list atau
tidak. Pencarian sekuensial bekerja sebagai berikut: Pertama, Anda
membandingkan 27 dengan list[0],
yaitu membandingkan 27 dengan 35. Karena list[0]
27, Anda kemudian membandingkan 27 dengan list[1], yaitu membandingkan 27 dengan 12. Karena list[1]
12, Anda kemudian membandingkan 27 dengan
list[2], dan pencarian berhenti.
Pencarian ini sukses menemukan 27 di dalam list.
Sekarang Anda diminta untuk melakukan
pencarian apakah 10 ada di dalam list
atau tidak. Seperti sebelumnya, pencarian dimulai dari elemen pertama array di
dalam list, yaitu list[0]. Anda melihat bahwa itemCari, yaitu 10, dibandingkan dengan
setiap item di dalam list. Akhirnya,
tidak ada lagi data di dalam list
untuk dibandingkan dengan itemCari.
Pencarian ini tidak berhasil menemukan 10 di dalam list.
Dapat dipahami bahwa, setelah pencarian
menemukan sebuah elemen di dalam list
yang sama dengan itemCari, pencarian
harus berhenti dan melaporkan hasil. (Pada kasus ini, Anda juga akan melaporkan
lokasi di dalam list dimana itemCari ditemukan). Sebaliknya,
setelah itemCari tidak berhasil ditemukan
pada setiap elemen list, Anda harus
menghentikan pencarian dan melaporkan kegagalan.
Dimisalkan bahwa nama array yang
digunakan adalah list. Diskusi ini
diterjemahkan menjadi algoritma berikut untuk pencarian sekuensial:
ditemukan ditetapkan menjadi false;
lok = 0;
while (lok < panjangList dan tidak ditemukan)
if (list[lok] sama dengan itemCari)
ditemukan ditetapkan
menjadi true
else
menginkremen lok
if (ditemukan)
return lok;
else
return -1;
Fungsi berikut melakukan pencarian
sekuensial terhadap sebuah array. Agar lebih sederhana, diasumsikan bahwa
setiap elemen list bertipe int.
int pencarianSek(const int list[], int panjangList, int itemCari)
{
int lok;
bool ditemukan = false;
lok = 0;
while (lok < panjangList && ! ditemukan)
if (list[lok] == itemCari)
ditemukan = true;
else
lok++;
if (ditemukan)
return lok;
else
return -1;
}
Jika fungsi pencarianSek menghasilkan sebuah nilai lebih besar dari atau sama
dengan 0, maka pencarian berhasil; sebaliknya, pencarian gagal.
Seperti yang dapat Anda lihat dari kode
ini, Anda memulai pencarian dengan membandingkan itemCari dengan elemen pertama di dalam list. Jika itemCari sama
dengan elemen pertama di dalam list,
maka Anda keluar dari loop; sebaliknya, lok
diinkremen sebesar 1 untuk menunjuk ke elemen berikutnya di dalam list. Anda kemudian membandingkan itemCari dengan elemen berikutnya di
dalam list, dan seterusnya.
Contoh 8.8
|
// Program ini
mengilustrasikan bagaimana menggunakan pencarian
// sekuensial di
dalam program.
#include <iostream> //Baris
1
using namespace std; //Baris
2
const int UKURAN_ARRAY = 10; //Baris
3
int pencarianSek(const int list[], int
panjangList, int itemCari); //Baris 4
int main() //Baris
5
{ //Baris
6
int
intList[UKURAN_ARRAY]; //Baris
7
int
angka; //Baris 8
cout << "Baris 9: Masukkan " << UKURAN_ARRAY
<< " integer." << endl; //Baris 9
for
(int indeks = 0; indeks <
UKURAN_ARRAY; indeks++) //Baris
10
cin >> intList[indeks]; //Baris 11
cout << endl; //Baris 12
cout << "Baris 13: Masukkan angka yang "
<< "akan dicari: "; //Baris
13
cin >> angka; //Baris 14
cout << endl; //Baris 15
int
pos = pencarianSek(intList, UKURAN_ARRAY, angka); //Baris 16
if
(pos!= -1) //Baris
17
cout <<"Baris 18: " << angka
<< " ditemukan pada posisi " <<
pos
<< endl; //Baris
18
else
//Baris
19
cout << "Baris 20: " << angka
<< " tidak ada di dalam list." <<
endl; //Baris 20
return
0; //Baris
21
} //Baris
22
int pencarianSek(const int list[], int
panjangList, int itemCari)
{
int
lok;
bool
ditemukan = false;
lok
= 0;
while
(lok < panjangList && ! ditemukan)
if
(list[lok] == itemCari)
ditemukan = true;
else
lok++;
if
(ditemukan)
return
lok;
else
return
-1;
}
Array Karakter (String-C)
Sampai sejauh ini, diskusi mengenai
array karakter dihindari karena alasan sederhana: Array karakter merupakan
array spesial, dan Anda memprosesnya secara berbeda dari ketika Anda memproses
array lain.C++ menyediakan banyak fungsi terpradefinisi yang dapat dipakai
terhadap array karakter.
Array karakter: Sebuah array dengan
komponen – komponen bertipe char.
Ingat bahwa himpunan karakter yang
paling sering digunakan adalah ASCII dan EBCDIC. Karakter pertama di dalam
himpunan karakter ASCII adalah karakter null, yang tidak bisa dicetak atau
ditampilkan. Selain itu, ingat bahwa dalam C++, karakter null direpresentasikan
sebagai ‘\0’.
Statemen:
ch = '\0';
menyimpan karakter null di dalam ch, dimana ch merupakan sebuah variabel char.
Seperti yang akan Anda lihat, karakter
null berperan penting dalam pemrosesan karakter array.
Karena karakter null merupakan karakter
pertama di dalam himpunan ASCII, ia bernilai lebih rendah dari sembarang
karakter lain di dalam himpunan karakter ASCII.
Istilah yang umum digunakan untuk array
karakter adalah string – C . Namun, ada perbedaan kecil antara array karakter
dan string – C. Ingat bahwa string adalah sebuah runtun yang memuat nol atau
lebih karakter, dan string selalu diapit oleh dua tanda kutip ganda. Dalam C++,
string – C selalu diakhir dengan karakter null; yang berarti bahwa karakter
terakhir dalam string – C selalu karakter null. Array karakter tidak harus
memuat karakter null, tetapi karakter terakhir di dalam string – C selalu
berupa karakter null. Seperti yang akan Anda lihat, karakter null sebaiknya
tidak ditempatkan di dalam string – C kecuali di posisi terakhir. Selain itu,
string – C disimpan di dalam array karakter satu – dimensi.
Berikut adalah beberapa contoh dari
string – C:
"Robert T. Baringin"
"Hallo semua."
Dari definisi atas string – C, jelaslah
bahwa ada perbedaan antaran ‘A’ dan “A”. Yang pertama adalah karakter A; yang
kedua adalah string – C A. Karena string – C selalu diakhiri oleh karakter
null, “A” merepresentasikan dua karakter: ‘A’ dan ‘\0’. Sama halnya, string – C
“Hallo” merepresentasikan enam karakter: ‘H’, ‘a’, ‘l’, ‘l’, ‘o’, dan ‘\0’.
Untuk menyimpan ‘A’, Anda hanya membutuhkan satu sel memori bertipe char; untuk menyimpan “A”, Anda
membutuhkan dua sel memori bertipe char,
yaitu satu untuk ‘A’ dan satu lagi untuk ‘\0’.
Perhatikan statemen berikut:
char
nama[16];
Statemen ini mendeklarasikan sebuah
array, nama, dengan 16 komponen
bertipe char. Karena string – C
selalu diakhiri oleh karakter null dan nama
memiliki 16 komponen, maka string terbesar yang dapat disimpan di dalam nama adalah dengan panjang 15. Jika
Anda menyimpan sebuah string – C dengan panjang 10 di dalam nama, maka 11 komponen pertama pada nama akan digunakan dan 5 karakter
terakhir tidak akan digunakan.
Statemen:
char nama[16] = {'J', 'o', 'h', 'n', '\0'};
mendeklarasikan sebuah array, nama, yang memuat 16 komponen bertipe char dan menyimpan string – C “John” di dalamnya. Selama deklarasi
variabel char, C++ membolehkan
penggunaan notasi string – C pada statemen inisialisasi. Statemen di atas
ekivalen dengan:
char
nama[16] = "John"; //Baris A
Ingat bahwa ukuran dari sebuah array
diabaikan jika array diinisialisasi selama pendeklarasian.
Statemen:
char nama[]
= "John"; //Baris B
mendeklarasikan sebuah variabel string
– C, nama, dengan panjang cukup
besar, pada kasus ini 5, dan menyimpan “John”
di dalamnya. Ada perbedaan antara statemen A dan statemen B: Kedua statemen
menyimpan “John” di dalam nama, tetapi ukuran dari nama pada statemen A adalah 16, dan
ukuran dari nama pada statemen B
adalah 5.
Hampir semua aturan yang berlaku pada
array dapat diterapkan terhadap array karakter. Perhatikan statemen berikut:
char namaMahasiswa[26];
Dimisalkan bahwa Anda ingin menyimpan “Robert T. Baringin” di dalam namaMahasiswa. Karena operasi seperti
penugasan dan perbandingan tidak diijinkan pada array, statemen berikut menjadi
tak legal:
namaMahasiswa = "Robert T.
Baringin"; //ilegal
C++ menyediakan himpunan fungsi yang
dapat dipakai untuk menipulasi string – C. File header cstring mendeskripsikan tiap fungsi tersebut. Anda akan sering
menggunakan tiga fungsi berikut: cstrpy
(untuk menyalin sebuah string – C ke dalam suatu variabel string – C); strcmp (untuk membandingkan string –
C); dan strlen (untuk mencari
panjang dari sebuah string – C). Tabel 8.1 menyimpulkan ketiga fungsi ini.
Tabel 8.1 Fungsi strcpy, strcmp, dan strlen
Fungsi
|
Penjelasan
|
strcpy(s1, s2)
|
Menyalin
string s2 ke dalam variabel string
s1. Panjang dari s1 sedikitnya sebesar s2.
|
strcmp(s1, s2)
|
Menghasilkan
sebuah nilai < 0 jika s1
bernilai kurang dari s2.
Menghasilkan
sebuah nilai 0 jika s1 bernilai
sama dengan s2.
Menghasilkan
sebuah nilai > 0 jika s1
bernilai lebih dari s2.
|
strlen(s)
|
Menghasilkan
panjang dari string s, tidak
termasuk karakter null.
|
Untuk menggunakan fungsi – fungsi ini,
program harus mencantumkan file header cstring
melalui statemen include. Statemen
berikut harus dicantumkan di dalam program:
#include <cstring>
Perbandingan
String
Dalam C++, string – C dibandingkan
karakter demi karakter menggunakan himpunan karakter ASCII atau EBCDIC.
Diasumsikan bahwa Anda menggunakan himpunan karakter ASCII.
1. String – C “Air” bernilai kurang dari string – C “Badan” karena karakter pertama dari “Air” bernilai kurang dari karakter
pertama dari “Badan”.
2. String – C “Air” bernilai kurang dari string – C “An” karena meskipun karakter pertama
pada kedua string sama, tetapi karakter kedua ‘i’ dari “Air” bernilai kurang dari karakter kedua ‘n’ dari “An”.
3. String – C “Bill” bernilai kurang dari string – C “Billy” karena empat karakter pertama dari “Bill” dan “Billy”,
tetapi karakter kelima dari “Bill”,
yang merupakan ‘\0’, bernilai kurang dari karakter kelima dari “Billy”, yaitu ‘y’.
4.
String – C “Hallo”
bernilai kurang dari “hallo” karena
karakter pertama ‘H’ dari string – C “Hallo”
bernilai kurang dari karakter pertama ‘h’ dari string – C “hallo”.
Contoh 8.9
|
Dimisalkan bahwa Anda memiliki beberapa
statemen berikut:
char namaMahasiswa[21];
char namaKu[16];
char namaMu[16];
Statemen – statemen berikut menunjukkan
bagaimana fungsi – fungsi string bekerja:
Statemen
|
Efek
|
strcpy(namaKu, "Tobat Sudirman");
|
namaKu = "Tobat
Sudirman"
|
strlen("Tobat Sudirman");
|
Menghasilkan 14, panjang dari
string “Tobat Sudirman”.
|
int pjg;
pjg =
strlen("Hari Indah");
|
Menyimpan 10 pada pjg.
|
strcpy(namaMu,
"Lisa Sibarani");
|
namaMu = "Lisa
Sibarani"
|
strcpy(namaMahasiswa,
namaMu);
|
namaMahasiswa = "Lisa
Sibarani"
|
strcmp("Bill", "Lisa");
|
Menghasilkan sebuah nilai < 0
|
strcpy(namaMu,
"Katerina Sasak");
|
namaMu = "Katerina
Sasak"
|
strcpy(namaKu,
"Minto Klatenov");
|
namaKu = "Minto
Klatenov"
|
strcmp(namaKu,
namaMu);
|
Menghasilkan sebuah nilai > 0
|
Operasi
Masukan dan Keluaran pada String
Seperti disebutkan sebelumnya, hampir
semua aturan yang berlaku pada array dapat diterapkan terhadap string – C.
Operasi penugasan dan komparasi tidak diijinkan diterapkan pada array. Bahkan,
operasi masukan / keluaran pada array dilakukan komponen demi komponen. Namun,
operasi masukan / keluaran pada string – C dilakukan secara berbeda. Deklarasi
berikut akan dipakai pada diskusi ini:
char
nama[31];
Membaca
String
Karena operasi agregat (sekaligus,
tidak komponen demi komponen) diijinkan untuk pembacaan string – C, statemen:
cin >>
name;
menyimpan string – C masukan berikutnya
ke dalam nama. Panjang dari string –
C masukan harus lebih rendah atau sama dengan 30. Jika panjang string masukan
adalah 4, maka komputer akan menyimpan keempat karakter yang dimasukkan dan
sebuah karakter null ‘\0’. Jika panjang string – C masukan lebih dari 30, maka
karena tidak ada pemeriksaan terhadap batas indeks array, komputer akan terus
menyimpan string di dalam sel – sel memori yang ditempatkan setelah nama (sel – sel memori yang bertetangga
dengan nama). Proses ini dapat
menyebabkan masalah serius, karena data di dalam sel – sel memori bertetangga
akan rusak.
Ingat bahwa operator ekstraksi,
>>, akan melompati semua karakter spasi – putih dan berhenti membaca data
ke dalam variabel begitu ia menemukan karakter spasi – putih pertama.
Akibatnya, string – C yang memuat spasi tidak akan dibaca menggunakan operator
ekstraksi >>. Sebagai contoh, jika nama pertama dan nama akhir dipisahkan
oleh spasi, maka keduanya tidak bisa dibaca / disimpan ke dalam nama.
Untuk membaca string – C, sintaks umum
dari fungsi get adalah:
cin.get(str, m + 1);
Statemen ini menyimpan m karakter berikutnya, atau semua
karakter sampai karakter garis – baru ‘\n’ ditemukan, ke dalam str. Karakter garis – baru tidak
disimpan di dalam str. Jika string –
C masukan memiliki panjang lebih sedikit dari m karakter, maka pembacaan akan berhenti pada karakter garis –
baru.
Perhatikan beberapa statemen berikut:
char str[31];
cin.get(str, 31);
Jika masukan adalah
Robert T. Baringin
maka “Robert T. Baringin” akan disimpan
di dalam str. Dimisalkan bahwa
masukan adalah:
Hallo semua. Nama saya adalah Roro
Kusuma.
Maka, karena str hanya dapat menyimpan maksimum 30 karakter, string – C “Hallo
semua. Nama saya adalah “ disimpan di dalam str.
Sekarang, dimisalkan bahwa dimiliki
beberapa statemen berikut:
char str1[26];
char str2[26];
char dibuang;
dan dua baris masukan:
Hari yang cerah.
Hari yang dingin.
Selanjutnya, dimisalkan bahwa Anda
ingin menyimpan string – C pertama di dalam str1 dan string – C kedua di dalam str2. Kedua str1 dan str2 dapat menyimpan sampai 25
karakter. Karena jumlah karakter pada baris pertama adalah 16, maka pembacaan
akan berhenti pada ‘\n’. Anda harus membaca dan membuang karakter garis – baru
di akhir baris pertama untuk mengimpan baris kedua di dalam str2. Beberapa statemen berikut akan
menyimpan baris pertama di dalam str1
dan baris kedua di dalam str2:
cin.get(str1, 26);
cin.get(dibuang);
cin.get(str2, 26);
Untuk membaca dan menyimpan sebaris
masukan, termasuk karakter – karakter garis – putih, Anda dapat menggunakan
fungsi aliran getline. Dimisalkan
bahwa Anda memiliki deklarasi berikut:
char barisTeks[100];
Statemen berikut akan membaca dan
menyimpan 99 karakter berikutnya, atau sampai karakter garis – baru ditemukan,
ke dalam barisTeks. Karakter null
secara otomatis akan ditempelkan sebagai karakter terakhir pada barisTeks.
cin.getline(textLine, 100);
Menampilkan
String
Anda dapat menampilkan string – C
menggunakan sebuah variabel aliran keluaran, seperti cout, disertai dengan operator penyisipan <<. Sebagai contoh
statemen:
cout << nama;
menampilkan isi dari nama pada layar. Operator penyisipan
<< berlanjut menampilkan isi dari nama
sampai ia menemukan karakter null. Jadi, jika panjang nama adalah 4, maka statemen tersebut hanya akan menampilkan empat
karakter. Jika nama tidak memuat
karakter null, maka Anda akan melihat keluaran aneh karena operator penyisipan
akan tetap menampilkan data dari memori tetangga sampai ‘\0\ ditemukan.
File
Masukan / Keluaran pada saat Eksekusi
Perhatikan beberapa statemen berikut:
ifstream infile;
ofstream outfile;
char namaFile[51]; //diasumsikan
bahwa nama file memiliki
//panjang
maksimum 50 karakter
Statemen – statemen berikut akan
meminta pengguna untuk menetapkan file masukan dan file keluaran pada saat
eksekusi:
cout << "Masukkan nama
file masukan: ";
cin >> namaFile;
infile.open(namaFile); //membuka file masukan
...
cout << "Masukkan nama
file keluaran: ";
cin >> namaFile;
outfile.open(namaFile); //membuka
file keluaran
Array Dua - Dimensi
Array dua – dimensi: Sebuah koleksi yang
memuat sejumlah tetap komponen yang ditata dalam baris dan kolom, dimana semua
komponen bertipe sama.
Sintaks dalam mendeklarasikan sebuah
array dua – dimensi adalah:
tipeData namaArray[intEksp1][ intEksp2];
dimana intEksp1 dan intEksp2
adalah ekspresi konstanta yang menghasilkan nilai integer positif. Dua
ekspresi, intEksp1 dan intEksp2, menetapkan jumlah barus dan
jumlah kolom di dalam array.
Statemen:
double penjualan[10][5];
mendeklarasikan sebuah array dua –
dimensi, penjualan, dengan 10 baris
dan 5 kolom, dimana setiap komponen bertipe double. Sama seperti pada array satu – dimensi, baris dinomori
0...9 dan kolom dinomori 0...4. Lihat Gambar 8.7.
Gambar 8.7 Array dua – dimensi penjualan
Mengakses
Komponen Array
Untuk mengakses komponen – komponen
sebuah array dua – dimensi, Anda memerlukan sepasang indeks: satu untuk posisi
baris dan satu untuk posisi kolom.
Sintaks untuk mengakses sebuah komponen
array dua – dimensi adalah:
namaArray[ekspIndeks1][ekspIndeks2]
dimana ekspIndeks1 dan ekspIndeks2
merupakan ekspresi yang menghasilkan nilai integer tak – negatif. Ekspresi ekspIndeks1 menetapkan posisi barus; ekspIndeks2 menetapkan posisi kolom.
Statemen:
penjualan[5][3] = 25.75;
menyimpan 25.75 ke nomor baris 5 dan
nomor kolom 3 (yaitu baris keenam dan kolom keempat) pada array penjualan. Lihat Gambar 8.8.
Gambar 8.8 penjualan[5][3]
Dimisalkan bahwa:
int i = 5;
int j = 3;
Maka, statemen sebelumnya:
penjualan[5][3] = 25.75;
ekivalen dengan:
penjualan[i][j] = 25.75;
Jadi, indeks dapat juga berupa
variabel.
Inisialisasi
Array Dua – Dimensi Selama Deklarasi
Sama seperti array satu – dimensi,
array dua – dimensi dapat diinisialisasi ketika ia dideklarasikan. Contoh
berikut mengilustrasikan konsep ini. Perhatikan beberapa statemen berikut:
int papan[4][3] = {{2, 3, 1},
{15, 25, 13},
{20, 4, 7},
{11, 18, 14}};
Statemen ini mendeklarasikan papan sebagai sebuah array dua –
diemensi dengan empat baris dan tiga kolom. Komponen – komponen dari baris
pertama adalah 2, 3, dan 1; komponen – komponen dari baris kedua adalah 15, 25,
dan 13; komponen – komponen dari baris ketiga adalah 20, 4, dan 7; dan komponen
– komponen dari baris keempat adalah 11, 18, dan 14. Gambar 8.9 menunjukkan
array papan.
Gambar 8.9 Array dua – dimensi papan
Untuk menginisialisasi sebuah array dua
– dimensi ketika ia dideklarasikan:
1. Elemen – elemen
tiap baris harus diapit dengan sepasang kurung kurawal dan dipisahkan oleh koma
– koma.
2. Semua baris
harus diapit oleh sepasang kurung kurawal.
3. Untuk array
angka, jika semua komponen sebuah baris tidak ditetapkan, maka komponen –
komponen yang tak ditetapkan akan diinisialisasi dengan 0. Pada kasus ini,
sedikitnya satu nilai harus diberikan untuk menginisialisasi semua komponen
pada suatu baris.
Array Dua – Dimensi dan Tipe
Enumerasi
Anda dapat pula menggunakan tipe
enumerasi untuk indeks array. Perhatikan beberapa statemen berikut:
const int JUMLAH_BARIS = 6;
const int JUMLAH_KOLOM = 5;
enum tipeMobil {GM, FORD, TOYOTA, BMW, NISSAN, VOLVO};
enum tipeWarna
{MERAH, COKLAT, HITAM, PUTIH, ABU};
int bursa[JUMLAH_BARIS][JUMLAH_KOLOM];
Statemen – statemen tersebut
mendefinisikan tipe enumerasi tipeMobil
dan tipeWarna dan mendefinisikan bursa sebagai sebuah array dua –
dimensi dengan enam baris dan lima kolom. Dimisalkan bahwa setiap baris pada bursa berkaitan dengan tipe mobil, dan
tiap kolom pada bursa berkaitan
dengan tipe warna. Yaitu, baris pertama berkaitan dengan tipe mobil GM, baris
kedua berkaitan dengan tipe mobil FORD, dan seterusnya. Sama halnya, kolom
pertama berkaitan dengan warna MERAH, kolom kedua berkaitan dengan warna COKLAT,
dan seterusnya. Selanjutnya, dimisalkan bahwa setiap entri di dalam bursa merepresentasikan jumlah mobil
dengan tipe dan warna tertentu. Lihat Gambar 8.10.
Gambar 8.10 Array dua – dimensi bursa
Statemen:
bursa[1][3] = 15;
ekivalen dengan statemen berikut (lihat
Gambar 8.11):
bursa[FORD][PUTIH] = 15;
Gambar 8.11 bursa[FORD][PUTIH]
Statemen kedua dengan mudah
menyampaikan pesan bahwa mobil FORD berwarna putih berjumlah 15. Contoh ini
mengilustrasikan bahwa tipe enumerasi dapat dipakai secara efektif untuk
membuat keterbacaan program semakin mudah.
Memproses
Array Dua – Dimensi
Sebuah array dua – dimensi dapat
diproses dengan tiga cara:
1. Memproses
keseluruhan array.
2. Memproses baris
tertentu dari array, yang dikenal dengan pemrosesan baris.
3.
Memproses kolom tertentu dari array,
yang dikenal dengan pemrosesan kolom.
Penginisialisasian dan penampilan array
merupakan dua contoh pemrosesan array dua – dimensi secara keseluruhan.
Pencarian elemen terbesar pada sebuah baris (kolom) atau penghitungan
penjumlahan elemen – elemen pada sebuah baris (kolom) merupakan dua contoh
pemrosesan baris (kolom). Deklarasi berikut akan digunakan untuk diskusi ini:
const int JUMLAH_BARIS = 7;
const int JUMLAH_KOLOM = 6;
int matriks[JUMLAH_BARIS][JUMLAH_KOLOM];
int baris;
int kolom;
int jum;
int terbesar;
int temp;
Gambar 8.12 menunjukkan array matriks.
Gambar 8.12 Array dua – dimensi matriks
Karena komponen – komponen sebuah array
dua – dimensi bertipe sama, maka komponen – komponen dari sembarang baris atau
kolom juga bertipe sama. Ini berarti bahwa setiap baris dan setiap kolom dari
sebuah array dua – dimensi merupakan sebuah array satu – dimensi. Oleh karena
itu, ketika memproses baris atau kolom tertentu pada array dua – dimensi, akan
digunakan algoritma yang sama dengan pada kasus array satu – dimensi. Konsep
ini akan dijelaskan lebih lanjut dengan bantuan array dua – dimensi matriks, seperti yang telah
dideklarasikan sebelumnya.
Dimisalkan bahwa Anda ingin memproses
nomor baris 5 pada matriks (yaitu,
baris keenam pada matriks). Komponen
– komponen dari nomor baris 5 pada matriks
adalah:
matriks[5][0], matriks[5][1], matriks[5][2], matriks[5][3],
matriks [5][4], matriks[5][5]
Anda melihat bahwa pada tiap komponen
ini, indeks pertama (posisi baris) adalah tetap 5. Indeks kedua (posisi kolom)
memiliki rentang 0 sampai 5. Oleh karena itu, Anda dapat menggunakan loop for berikut untuk memproses baris nomor
5:
for (kolom = 0; kolom < JUMLAH_KOLOM; kolom++)
memproses matriks[5][kolom]
Jelaslah bahwa loop for ini ekivalen
dengan loop for berikut:
baris = 5;
for (kolom = 0; kolom < JUMLAH_KOLOM; kolom++)
process matriks[baris][kolom]
Sama halnya, dimisalkan bahwa Anda
ingin memproses nomor kolom 2 pada matriks,
yaitu kolom ketiga pada matriks.
Komponen – komponen pada kolom ini adalah:
matriks[0][2], matriks[1][2], matriks[2][2], matriks[3][2],
matriks [4][2], matriks[5][2], matriks[6][2]
Di sini, indeks kedua (yaitu, posisi
kolom) tetap pada 2. Indeks pertama (yaitu, posisi baris) memiliki rentang dari
0 sampai 6. Pada kasus ini, Anda dapat menggunakan loop for berikut untuk memproses kolom 2 pada matriks:
for (baris = 0;
baris < JUMLAH_BARIS; baris++)
memproses matriks[baris][2]
Jelaslah bahwa loop for ini ekivalen dengan loop for berikut:
kolom = 2;
for (baris = 0; baris < JUMLAH_BARIS; baris++)
memproses matriks[baris][kolom]
Selanjutnya, akan didiskusikan
algoritma – algoritma pemrosesan array dua – dimensi secara spesifik.
Inisialisasi
Dimisalkan bahwa Anda ingin
menginisialisasi nomor baris 4, yaitu baris kelima, dengan 0. Seperti
dijelaskan sebelumnya, loop for
berikut melakukan hal ini:
baris = 4;
for (kolom = 0; kolom < JUMLAH_KOLOM; kolom++)
matrix[baris][kolom] = 0;
Jika Anda ingin menginsialisasi
keseluruhan matriks dengan 0, maka
Anda dapat pula menempatkan indeks pertama, yaitu posisi baris, di dalam sebuah
loop. Dengan menggunakan loop for
bersarang, Anda dapat menginisialisasi setiap komponen matriks dengan 0:
for (baris = 0; baris < JUMLAH_BARIS; baris++)
for (kolom = 0; kolom < JUMLAH_KOLOM; kolom++)
matriks[baris][kolom] = 0;
Menampilkan
Dengan menggunakan sebuah loop for bersarang, Anda dapat menampilkan
komponen – komponen dari matriks.
Loop for bersarang berikut
menampilkan komponen – komponen dari matriks,
satu baris komponen – komponen dari matriks
per baris:
for (baris = 0; baris < JUMLAH_BARIS; baris++)
{
for (kolom = 0; kolom < JUMLAH_KOLOM; kolom++)
cout << setw(5)
<< matriks[baris][kolom] << " ";
cout << endl;
}
Membaca
Loop for berikut membaca data ke dalam nomor baris 4, yaitu baris kelima
dari matriks:
baris = 4;
for (kolom = 0; kolom < JUMLAH_KOLOM; kolom++)
cin >> matriks[baris][kolom];
Seperti sebelumnya, dengan menempatkan
nomor baris pada sebuah loop, Anda dapat membaca data ke dalam tiap komponen matriks. Loop for berikut membaca data ke dalam tiap komponen matriks:
for (baris = 0; baris < JUMLAH_BARIS; baris++)
for (kolom = 0; kolom < JUMLAH_KOLOM; kolom++)
cin >> matriks[baris][kolom];
Penjumlahan
secara Baris
Loop for berikut menghitung penjumlahan nomor baris 4 pada matriks; yaitu, ia menjumlahkan setiap komponen
pada nomor baris 4.
jum = 0;
baris = 4;
for (kolom = 0; kolom < JUMLAH_KOLOM; kolom++)
jum = jum + matriks[baris][kolom];
Lagi, dengan menempatkan nomor baris
pada sebuah loop, Anda dapat mencari penjumlahan tiap baris secara terpisah. Berikut
adalah kode C++ untuk mencari penjumlahan tiap baris secara terpisah:
for (baris = 0; baris < JUMLAH_BARIS; baris++)
{
jum = 0;
for (kolom = 0; kolom < JUMLAH_KOLOM; kolom++)
jum = jum + matriks[baris][kolom];
cout << "Penjumlahan baris " << baris
+ 1 << " = "
<< jum << endl;
}
Penjumlahan
secara Kolom
Seperti pada kasus penjumlahan secara
baris, loop for bersarang berikut mencari penjumlahan atas tiap kolom secara
terpisah:
for (kolom = 0; kolom < JUMLAH_KOLOM; kolom++)
{
jum = 0;
for (baris = 0; baris < JUMLAH_BARIS; baris++)
jum = jum + matriks[baris][kolom];
cout << "Penjumlahan kolom " << kolom
+ 1 << " = "
<< jum
<< endl;
}
Mencari
Elemen Terbesar pada Tiap Baris dan Tiap Kolom
Seperti disebutkan sebelumnya, dua
operasi lain yang dapat diterapkan pada sebuah array dua – dimensi adalah
pencarian elemen terbesar pada tiap baris dan tiap kolom dan penghitungan
penjumlahan kedua diagonal. Selanjutnya, akan diberikan kode C++ untuk
melakukan kedua operasi ini.
Loop for berikut menentukan elemen terbesar pada nomor baris 4:
baris = 4;
terbesar = matriks[row][0]; //Diasumsikan bahwa elemen pertama
//pada
baris adalah yang terbesar.
for (kolom = 1; kolom < JUMLAH_KOLOM; kolom++)
if (terbesar < matriks[baris][kolom])
terbesar = matriks[baris][kolom];
Kode C++ berikut menentukan elemen terbesar pada tiap baris dan tiap
kolom:
//Elemen terbesar pada tiap baris
for (baris = 0; baris < JUMLAH_BARIS; baris++)
{
terbesar = matriks[baris][0];
//Diasumsikan bahwa elemen pertama
//pada baris adalah yang terbesar.
for (kolom = 1; kolom < JUMLAH_KOLOM; kolom++)
if (terbesar < matriks[baris][kolom])
terbesar = matriks[baris][kolom];
cout << "Elemen terbesar pada baris "
<< baris + 1 << " =
"
<< terbesar
<< endl;
}
//Elemen terbesar pada tiap kolom
for (kolom = 0; kolom < JUMLAH_KOLOM; kolom++)
{
terbesar = matriks[0][kolom];
//Diasumsikan bahwa elemen pertama
//pada kolom adalah yang terbesar.
for (baris = 1; baris < JUMLAH_BARIS; baris++)
if (terbesar < matriks[baris][kolom])
terbesar = matriks[baris][kolom];
cout << "Elemen terbesar pada kolom "
<< kolom + 1
<< " = " << terbesar <<
endl;
}
Melewatkan
Array Dua – Dimensi sebagai Parameter kepada Fungsi
Array dua – dimensi dapat dilewatkan sebagai parameter kepada sebuah
fungsi, dan hal itu dilakukan dengan pelewatan dengan referensi. Alamat basis
(yaitu, alamat dari komponen pertama dari parameter aktual) dilewatkan kepada
parameter formal. Jika matriks adalah
nama dari sebah array dua – dimensi, maka matriks[0][0]
merupakan komponen pertama pada matriks.
Ketika menyimpan sebuah array dua – dimensi di dalam memori komputer, C++
menggunakan format urutan baris. Yaitu, baris pertama disimpan terlebih dahulu,
diikuti dengan baris kedua, dan seterusnya.
Pada kasus array satu – dimensi, ketika mendeklarasikannya sebagai
parameter formal, Anda biasanya mengabaikan ukuran array. Karena C++ menyimpan
array dua – dimensi dengan format urutan baris, untuk menghitung alamat dari
sebuah komponen secara tepat, kompiler harus mengetahui di mana satu baris
berakhir dan di mana baris berikutnya dimulai. Jadi, ketika mendeklarasikan
sebuah array dua – dimensi sebagai parameter formal, Anda dapat mengabaikan
ukuran dari dimensi pertama, tetapi tidak dimensi kedua; yaitu, Anda harus
menetapkan jumlah kolom.
Dimisalkan bahwa Anda memiliki deklarasi berikut:
const int JUMLAH_BARIS = 6;
const int JUMLAH_KOLOM = 5;
Perhatikan definisi berikut atas fungsi tampilMatriks:
void tampilMatriks(int matriks[][JUMLAH_KOLOM],
int jlhBaris)
{
int baris, kolom;
for (baris = 0; baris < jlhBaris; baris++)
{
for (kolom = 0; kolom <
JUMLAH_KOLOM; kolom++)
cout << setw(5)
<< matriks[baris][kolom] << " ";
cout << endl;
}
}
Fungsi ini mengambil sebuah array dua – dimensi sebagai parameter dengan
jumlah baris yang tidak ditetapkan dan dengan lima kolom, dan menampilkan isi
dari array dua – dimensi. Selama pemanggilan fungsi, jumlah kolom dari parameter aktual harus
sesuai dengan jumlah kolom dari parameter formal.
Sama halnya, fungsi berikut menampilkan penjumlahan atas elemen – elemen
tiap baris pada sebuah array dua – dimensi yang bertipe int.
void jumBaris(int matriks[][JUMLAH_KOLOM],
int jlhBaris)
{
int baris, kolom;
int jum;
//Penjumlahan atas tiap baris
secara terpisah
for
(baris = 0; baris < jlhBaris; baris++)
{
jum = 0;
for (kolom = 0; kolom < JUMLAH_KOLOM; kolom++)
jum = jum + matriks[baris][kolom];
cout << "Penjumlahan baris " << (baris
+ 1) << " = "
<< jum
<< endl;
}
}
Fungsi berikut menentukan elemen terbesar pada tiap baris:
void terbesarBaris(int matriks[][JUMLAH_KOLOM],
int jlhBaris)
{
int baris, kolom;
int terbesar;
//Elemen terbesar pada tiap
baris
for (baris = 0; baris < jlhBaris; baris++)
{
terbesar = matriks[baris][0];
//Diasumsikan bahwa elemen
pertama
//pada baris adalah
yang terbesar.
for (kolom = 1; kolom < JUMLAH_KOLOM; kolom++)
if (terbesar < matriks[baris][ kolom])
terbesar = matriks[baris][
kolom];
cout << "Elemen terbesar pada baris "
<< (baris + 1)
<< " = " << terbesar <<
endl;
}
}
Contoh 8.10 menunjukkan bagaimana fungsi tampilMatriks, jumBaris,
dan terbesarBaris digunakan pada
sebuah program.
Contoh 8.10
|
// Array
dua-dimensi sebagai parameter kepada fungsi.
#include <iostream>
#include <iomanip>
using namespace std;
const int JUMLAH_BARIS = 6;
const int JUMLAH_KOLOM = 5;
void tampilMatriks(int matriks[][JUMLAH_KOLOM], int JUMLAH_BARIS);
void jumBaris(int matriks[][JUMLAH_KOLOM], int JUMLAH_BARIS);
void terbesarBaris(int matriks[][JUMLAH_KOLOM], int JUMLAH_BARIS);
int main()
{
int
papan[JUMLAH_BARIS][JUMLAH_KOLOM]
= {{23, 5, 6, 15, 18},
{4, 16, 24, 67, 10},
{12, 54, 23, 76, 11},
{1, 12, 34, 22, 8},
{81, 54, 32, 67, 33},
{12, 34, 76, 78, 9}}; //Baris 1
tampilMatriks(papan, JUMLAH_BARIS); //Baris 2
cout << endl; //Baris 3
jumBaris(papan, JUMLAH_BARIS); //Baris 4
cout << endl; //Baris 5
terbesarBaris(papan, JUMLAH_BARIS); //Baris 6
return
0;
}
void tampilMatriks(int matriks[][JUMLAH_KOLOM], int jlhBaris)
{
int
baris, kolom;
for
(baris = 0; baris < jlhBaris; baris++)
{
for
(kolom = 0; kolom < JUMLAH_KOLOM; kolom++)
cout << setw(5) <<
matriks[baris][kolom] << " ";
cout << endl;
}
}
void jumBaris(int matriks[][JUMLAH_KOLOM], int jlhBaris)
{
int
baris, kolom;
int
jum;
//Penjumlahan atas tiap baris secara
terpisah
for
(baris = 0; baris < jlhBaris; baris++)
{
jum = 0;
for
(kolom = 0; kolom < JUMLAH_KOLOM; kolom++)
jum = jum + matriks[baris][kolom];
cout << "Penjumlahan baris " <<
(baris + 1) << " = "
<< jum
<< endl;
}
}
void terbesarBaris(int matriks[][JUMLAH_KOLOM], int jlhBaris)
{
int
baris, kolom;
int
terbesar;
//Elemen terbesar pada tiap baris
for
(baris = 0; baris < jlhBaris; baris++)
{
terbesar = matriks[baris][0];
//Diasumsikan bahwa elemen pertama
//pada
baris adalah yang terbesar.
for
(kolom = 1; kolom < JUMLAH_KOLOM; kolom++)
if (terbesar < matriks[baris][ kolom])
terbesar = matriks[baris][
kolom];
cout << "Elemen terbesar pada baris "
<< (baris + 1)
<< " = " << terbesar <<
endl;
}
}
Keluaran Program:
23 5
6 15 18
4 16
24 67 10
12 54
23 76 11
1 12
34 22 8
81 54
32 67 33
12 34
76 78 9
Penjumlahan baris 1 = 67
Penjumlahan baris 2 = 121
Penjumlahan baris 3 = 176
Penjumlahan baris 4 = 77
Penjumlahan baris 5 = 267
Penjumlahan baris 6 = 209
Elemen terbesar pada baris 1 = 23
Elemen terbesar pada baris 2 = 67
Elemen terbesar pada baris 3 = 76
Elemen terbesar pada baris 4 = 34
Elemen terbesar pada baris 5 = 81
Elemen terbesar pada baris 6 = 78
No comments:
Post a Comment