array

array
Array adalah serangkaian elemen dari jenis yang sama ditempatkan di lokasi memori yang berdekatan yang dapat secara individual direferensikan dengan menambahkan indeks pengenal unik.

Itu berarti bahwa, misalnya, lima nilai bertipe int dapat dideklarasikan sebagai array tanpa harus mendeklarasikan 5 variabel yang berbeda (masing-masing dengan identifier sendiri). Sebaliknya, menggunakan sebuah array, lima nilai-nilai int disimpan dalam lokasi memori yang berdekatan, dan semua lima dapat diakses menggunakan identifier yang sama, dengan indeks yang tepat.

Misalnya, array yang berisi 5 nilai integer bertipe int disebut foo bisa direpresentasikan sebagai:
  

di mana setiap panel kosong merupakan elemen dari array. Dalam hal ini, ini adalah nilai-nilai dari tipe int. Unsur-unsur ini diberi nomor dari 0 sampai 4, menjadi 0 pertama dan 4 yang terakhir; Dalam C ++, elemen pertama dalam array selalu dinomori dengan nol (tidak satu), tidak peduli panjangnya.

Seperti variabel biasa, array harus dideklarasikan sebelum digunakan. Sebuah deklarasi khas untuk sebuah array di C ++ adalah:

type name [elements];
dimana jenis tipe yang valid (seperti int, float ...), nama adalah identifier yang valid dan bidang elemen (yang selalu diapit oleh kurung siku []), menentukan panjang array dalam hal jumlah elemen.

Oleh karena itu, array foo, dengan lima elemen bertipe int, dapat dinyatakan sebagai: 

int foo [5];

CATATAN: Unsur-unsur bidang dalam tanda kurung siku [], mewakili jumlah elemen dalam array, harus menjadi ekspresi konstan, karena array blok memori statis yang ukurannya harus ditentukan pada waktu kompilasi, sebelum program berjalan.
      menginisialisasi array
Secara default, array biasa lingkup lokal (misalnya, mereka menyatakan dalam fungsi) yang tersisa diinisiasi. Ini berarti bahwa tidak ada unsur-unsur yang ditetapkan untuk setiap nilai tertentu; isinya belum ditentukan pada titik array dideklarasikan.

Namun unsur dalam array dapat diinisialisasi secara eksplisit dengan nilai-nilai tertentu ketika dinyatakan, dengan melampirkan nilai-nilai awal dalam kurung {}. Sebagai contoh: 

int foo [5] = { 16, 2, 77, 40, 12071 };

Pernyataan ini mendeklarasikan sebuah array yang dapat diwakili seperti ini:
 
Jumlah nilai antara kawat gigi {} tidak akan lebih besar dari jumlah elemen dalam array. Misalnya, dalam contoh di atas, foo dinyatakan memiliki 5 elemen (sebagaimana ditentukan oleh jumlah diapit oleh kurung siku, []), dan kawat gigi {} yang terdapat persis 5 nilai, satu untuk setiap elemen. Jika dinyatakan dengan kurang, unsur-unsur yang tersisa diatur ke nilai standar (yang untuk jenis fundamental, berarti mereka penuh dengan nol). Sebagai contoh:

int bar [5] = { 10, 20, 30 };

 Akan membuat sebuah array seperti ini:
  

Initializer bahkan dapat memiliki nilai-nilai, hanya kawat gigi:

int baz [5] = { };

 Hal ini menciptakan sebuah array dari lima nilai int, masing-masing diinisialisasi dengan nilai nol:
  
Ketika sebuah inisialisasi nilai disediakan untuk array, C ++ memungkinkan kemungkinan meninggalkan tanda kurung siku kosong []. Dalam hal ini, compiler akan menganggap otomatis ukuran untuk array yang sesuai dengan jumlah nilai dimasukkan antara kawat gigi {}:

int foo [] = { 16, 2, 77, 40, 12071 };

setelah deklarasi ini, berbagai foo akan 5 int panjang, karena kami telah menyediakan 5 nilai inisialisasi.

Akhirnya, evolusi C ++ telah menyebabkan adopsi inisialisasi yang universal juga untuk array. Oleh karena itu, tidak perlu lagi untuk tanda sama antara deklarasi dan initializer tersebut. Kedua pernyataan ini adalah sama:

1 2

int foo[] = { 10, 20, 30 }; int foo[] { 10, 20, 30 }; Array statis, dan mereka menyatakan secara langsung dalam namespace (di luar fungsi apapun), selalu diinisialisasi. Jika tidak ada inisialisasi eksplisit ditentukan, semua elemen yang diinisialisasi default-(dengan nol, untuk jenis fundamental).

Mengakses nilai array
Nilai-nilai dari setiap elemen dalam array dapat diakses seperti nilai variabel biasa dari jenis yang sama. Sintaksnya adalah:

Nama [index]
Berikut contoh sebelumnya di mana foo memiliki 5 elemen dan masing-masing elemen adalah tipe int, nama yang dapat digunakan untuk merujuk kepada setiap elemen adalah sebagai berikut:

Sebagai contoh, pernyataan berikut menyimpan nilai 75 dalam elemen ketiga dari foo:

foo [2] = 75;

dan, misalnya, salinan berikut nilai elemen ketiga dari foo ke variabel disebut x:

x = foo[2];

Oleh karena itu, ekspresi foo [2] itu sendiri merupakan variabel bertipe int.Perhatikan bahwa elemen ketiga dari foo ditentukan foo [2], karena yang pertama adalah foo [0], yang kedua adalah foo [1], dan oleh karena itu, yang ketiga adalah foo [2]. Dengan alasan yang sama, elemen terakhir adalah foo [4]. Oleh karena itu, jika kita menulis foo [5], kita akan mengakses elemen keenam foo, dan karena itu benar-benar melebihi ukuran array.Dalam C ++, itu adalah sintaksis benar melebihi kisaran valid indeks untuk array. Hal ini dapat menciptakan masalah, karena mengakses out-of-range elemen tidak menyebabkan kesalahan pada kompilasi, tetapi dapat menyebabkan kesalahan pada runtime. Alasan untuk ini diperbolehkan akan terlihat pada bab berikutnya ketika pointer diperkenalkan.Pada titik ini, penting untuk dapat dengan jelas membedakan antara dua penggunaan yang kurung [] telah berhubungan dengan array. Mereka melakukan dua tugas yang berbeda: satu adalah untuk menentukan ukuran array saat diumumkan; dan yang kedua adalah untuk menentukan indeks untuk elemen array beton ketika mereka diakses. Jangan bingung dua penggunaan ini mungkin kurung [] dengan array.

1 2

int foo[5]; // declaration of a new array foo[2] = 75; // access to an element of the array.

Perbedaan utama adalah bahwa deklarasi ini didahului oleh jenis elemen, sementara akses tidak.

Beberapa operasi lain yang berlaku dengan array:

1 2 3 4

foo[0] = a; foo[a] = 75; b = foo [a+2]; foo[foo[a]] = foo[2] + 5;

Sebagai contoh:

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

// arrays example 12206 #include <iostream> using namespace std; int foo [] = {16, 2, 77, 40, 12071}; int n, result=0; int main () { for ( n=0 ; n<5 ; ++n ) { result += foo[n]; } cout << result; return 0; }

 
array multidimensi
Array multidimensi dapat digambarkan sebagai "array dari array". Misalnya, array bidimensional dapat dibayangkan sebagai meja dua dimensi yang terbuat dari unsur-unsur, semua dari mereka dari tipe data yang seragam yang sama.
 
jimmy merupakan array bidimensional dari 3 per 5 elemen bertipe int. C ++ sintaks untuk ini adalah:

int jimmy [3][5];

dan, misalnya, cara untuk referensi elemen kedua vertikal dan horizontal keempat dalam sebuah ekspresi akan menjadi:

jimmy[1][3]

(ingat bahwa indeks array selalu dimulai dengan nol).

Array multidimensi tidak terbatas pada dua indeks (yaitu, dua dimensi). Mereka dapat berisi sebanyak indeks yang diperlukan. Meskipun hati-hati: jumlah memori yang dibutuhkan untuk sebuah array meningkat secara eksponensial dengan masing-masing dimensi. Sebagai contoh:

char century [100][365][24][60][60];

menyatakan sebuah array dengan elemen tipe char untuk setiap detik dalam satu abad. Jumlah ini lebih dari 3 miliar arang! Jadi deklarasi ini akan mengkonsumsi lebih dari 3 gigabyte memori!

Pada akhirnya, array multidimensi hanya sebuah abstraksi untuk programmer, karena hasil yang sama dapat dicapai dengan array sederhana, dengan mengalikan indeks nya:

1 2

int jimmy [3][5]; // is equivalent to int jimmy [15]; // (3 * 5 = 15)

Dengan perbedaan hanya bahwa dengan array multidimensi, compiler secara otomatis mengingat kedalaman masing-masing dimensi imajiner. Dua potongan kode berikut menghasilkan hasil yang sama persis, tetapi satu menggunakan array bidimensional sementara yang lain menggunakan array sederhana: 

multidimensional array	pseudo-multidimensional array
#define WIDTH 5 #define HEIGHT 3 int jimmy [HEIGHT][WIDTH]; int n,m; int main () { for (n=0; n<HEIGHT; n++) for (m=0; m<WIDTH; m++) { jimmy[n][m]=(n+1)*(m+1); } }	#define WIDTH 5 #define HEIGHT 3 int jimmy [HEIGHT * WIDTH]; int n,m; int main () { for (n=0; n<HEIGHT; n++) for (m=0; m<WIDTH; m++) { jimmy[n*WIDTH+m]=(n+1)*(m+1); } }

 blok yang disebut jimmy dengan cara berikut:
 
Perhatikan bahwa kode menggunakan konstanta yang ditetapkan untuk lebar dan tinggi, daripada menggunakan langsung nilai-nilai numerik mereka. Hal ini memberikan kode yang lebih mudah dibaca, dan memungkinkan perubahan kode yang akan dibuat dengan mudah di satu tempat.

Array sebagai parameter
Di beberapa titik, kita mungkin harus lulus array ke fungsi sebagai parameter. Dalam C ++, tidak mungkin untuk lulus seluruh blok memori diwakili oleh sebuah array ke fungsi secara langsung sebagai argumen. Tapi apa yang bisa dilalui malah alamatnya. Dalam prakteknya, ini memiliki efek hampir sama, dan itu adalah operasi lebih cepat dan lebih efisien.

Untuk menerima sebuah array sebagai parameter untuk fungsi, parameter dapat dinyatakan sebagai jenis array, tetapi dengan kurung kosong, menghilangkan ukuran sebenarnya dari array. Sebagai contoh:

void procedure (int arg[])

Fungsi ini menerima parameter tipe "array int" disebut arg. Untuk lolos ke fungsi ini array dinyatakan sebagai:

int myarray [40];

itu akan cukup untuk menulis panggilan seperti ini:

procedure (myarray);

 Di sini Anda memiliki contoh lengkap:

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

// arrays as parameters #include <iostream> using namespace std; void printarray (int arg[], int length) { for (int n=0; n<length; ++n) cout << arg[n] << ' '; cout << '\n'; } int main () { int firstarray[] = {5, 10, 15}; int secondarray[] = {2, 4, 6, 8, 10}; printarray (firstarray,3); printarray (secondarray,5); }

5 10 15 2 4 6 8 10

 Dalam kode di atas, parameter pertama (int arg []) menerima berbagai setiap elemen yang adalah tipe int, apa pun panjangnya. Untuk itu, kami telah menyertakan parameter kedua yang menceritakan fungsi panjang setiap array yang kita lulus untuk itu sebagai parameter pertama. Hal ini memungkinkan untuk loop yang mencetak array untuk mengetahui kisaran iterate dalam array berlalu, tanpa keluar dari jangkauan.

Dalam deklarasi fungsi, juga memungkinkan untuk memasukkan array multidimensi. Format untuk parameter array trimatra adalah:

base_type[][depth][depth]

Misalnya, fungsi dengan array multidimensi sebagai argumen bisa:

void procedure (int myarray[][3][4])

Perhatikan
 bahwa tanda kurung pertama [] dibiarkan kosong, sedangkan yang berikut 
menentukan ukuran untuk dimensi masing-masing. Hal ini diperlukan dalam rangka untuk compiler untuk dapat menentukan kedalaman masing-masing dimensi tambahan.
Di satu sisi, melewati array sebagai argumen selalu kalah dimensi. Alasan
 di belakang adalah bahwa, untuk alasan historis, array tidak dapat 
langsung disalin, dan dengan demikian apa yang benar-benar berlalu 
adalah pointer. Ini adalah sumber umum dari kesalahan untuk programmer pemula. Meskipun pemahaman yang jelas tentang pointer, dijelaskan dalam bab mendatang, banyak membantu.
Array perpustakaanArray menjelaskan di atas secara langsung diimplementasikan sebagai fitur bahasa, yang diwarisi dari bahasa C. Mereka adalah fitur yang hebat, tapi dengan membatasi copy dan mudah 
membusuk menjadi pointer, mereka mungkin menderita kelebihan optimasi.
Untuk
 mengatasi beberapa masalah ini dengan bahasa built-in array, C ++ 
menyediakan sebuah array tipe alternatif sebagai wadah standar. Ini adalah jenis template (template kelas, sebenarnya) didefinisikan dalam header <array yang>.
Kontainer
 adalah fitur perpustakaan yang jatuh dari lingkup tutorial ini, dan 
dengan demikian kelas tidak akan dijelaskan secara rinci di sini. Cukuplah
 untuk mengatakan bahwa mereka beroperasi dalam cara yang mirip dengan 
built-in array, kecuali bahwa mereka memungkinkan disalin (operasi 
sebenarnya mahal yang salinan seluruh blok memori, dan dengan demikian 
untuk menggunakan dengan hati-hati) dan pembusukan ke dalam pointer 
hanya ketika secara eksplisit diberitahu untuk melakukannya (dengan cara data anggotanya).
Hanya
 sebagai contoh, ini adalah dua versi dari contoh yang sama menggunakan 
bahasa built-in array yang dijelaskan dalam bab ini, dan wadah di 
perpustakaan:

language built-in array	container library array
#include <iostream> using namespace std; int main() { int myarray[3] = {10,20,30}; for (int i=0; i<3; ++i) ++myarray[i]; for (int elem : myarray) cout << elem << '\n'; }	#include <iostream> #include <array> using namespace std; int main() { array<int,3> myarray {10,20,30}; for (int i=0; i<myarray.size(); ++i) ++myarray[i]; for (int elem : myarray) cout << elem << '\n'; }

Seperti yang Anda lihat, kedua jenis array menggunakan sintaks yang sama untuk mengakses unsur-unsurnya: myarray [i]. Selain itu, perbedaan utama berbaring di deklarasi array, dan masuknya header tambahan untuk array perpustakaan. Perhatikan juga bagaimana mudah untuk mengakses ukuran array perpustakaan.

 

  summber dari terjemahan:http://www.cplusplus.com/doc/tutorial/arrays/