Array (C++)

Array adalah urutan objek dengan jenis yang sama yang menempati area memori yang berdampingan. Array gaya C tradisional adalah sumber dari banyak bug, tetapi masih umum, terutama dalam basis kode yang lebih lama. Dalam C++modern, sebaiknya gunakan std::vector atau std::array alih-alih array gaya C yang dijelaskan di bagian ini. Kedua jenis pustaka standar ini menyimpan elemennya sebagai blok memori yang bersebelahan. Namun, mereka memberikan keamanan jenis yang lebih besar, dan mendukung iterator yang dijamin menunjuk ke lokasi yang valid dalam urutan. Untuk informasi selengkapnya, lihat Kontainer.

Deklarasi tumpukan

Dalam deklarasi array C++, ukuran array ditentukan setelah nama variabel, bukan setelah nama jenis seperti dalam beberapa bahasa lain. Contoh berikut mendeklarasikan array 1000 ganda untuk dialokasikan pada tumpukan. Jumlah elemen harus disediakan sebagai bilangan bulat harfiah atau sebagai ekspresi konstanta. Itu karena pengkompilasi harus tahu berapa banyak ruang tumpukan yang akan dialokasikan; ini tidak dapat menggunakan nilai yang dihitung pada run-time. Setiap elemen dalam array diberi nilai default 0. Jika Anda tidak menetapkan nilai default, setiap elemen awalnya berisi nilai acak apa pun yang terjadi di lokasi memori tersebut.

    constexpr size_t size = 1000;

    // Declare an array of doubles to be allocated on the stack
    double numbers[size] {0};

    // Assign a new value to the first element
    numbers[0] = 1;

    // Assign a value to each subsequent element
    // (numbers[1] is the second element in the array.)
    for (size_t i = 1; i < size; i++)
    {
        numbers[i] = numbers[i-1] * 1.1;
    }

    // Access each element
    for (size_t i = 0; i < size; i++)
    {
        std::cout << numbers[i] << " ";
    }

Elemen pertama dalam array adalah elemen nol. Elemen terakhir adalah elemen (n-1), di mana n adalah jumlah elemen yang dapat dikandung array. Jumlah elemen dalam deklarasi harus dari jenis integral dan harus lebih besar dari 0. Anda bertanggung jawab untuk memastikan bahwa program Anda tidak pernah meneruskan nilai ke operator subskrip yang lebih besar dari (size - 1).

Array berukuran nol hanya legal ketika array adalah bidang terakhir dalam struct atau union dan saat ekstensi Microsoft diaktifkan (/Za atau /permissive- tidak diatur).

Array berbasis tumpukan lebih cepat untuk dialokasikan dan diakses daripada array berbasis timbunan. Namun, ruang tumpukan terbatas. Jumlah elemen array tidak boleh begitu besar sehingga menggunakan terlalu banyak memori tumpukan. Berapa banyak yang terlalu banyak tergantung pada program Anda. Anda dapat menggunakan alat pembuatan profil untuk menentukan apakah array terlalu besar.

Deklarasi tumpuk

Anda mungkin memerlukan array yang terlalu besar untuk dialokasikan pada tumpukan, atau yang ukurannya tidak diketahui pada waktu kompilasi. Dimungkinkan untuk mengalokasikan array ini pada timbunan dengan menggunakan new[] ekspresi. Operator mengembalikan penunjuk ke elemen pertama. Operator subskrip bekerja pada variabel pointer dengan cara yang sama seperti pada array berbasis tumpukan. Anda juga dapat menggunakan aritmatika penunjuk untuk memindahkan penunjuk ke elemen arbitrer apa pun dalam array. Anda bertanggung jawab untuk memastikan bahwa:

• Anda selalu menyimpan salinan alamat penunjuk asli sehingga Anda dapat menghapus memori saat Anda tidak lagi memerlukan array.
• Anda tidak menaikkan atau mengurangi alamat penunjuk melewati batas array.

Contoh berikut menunjukkan cara menentukan array pada timbunan pada run time. Ini menunjukkan cara mengakses elemen array menggunakan operator subskrip dan dengan menggunakan aritmatika penunjuk:

void do_something(size_t size)
{
    // Declare an array of doubles to be allocated on the heap
    double* numbers = new double[size]{ 0 };

    // Assign a new value to the first element
    numbers[0] = 1;

    // Assign a value to each subsequent element
    // (numbers[1] is the second element in the array.)
    for (size_t i = 1; i < size; i++)
    {
        numbers[i] = numbers[i - 1] * 1.1;
    }

    // Access each element with subscript operator
    for (size_t i = 0; i < size; i++)
    {
        std::cout << numbers[i] << " ";
    }

    // Access each element with pointer arithmetic
    // Use a copy of the pointer for iterating
    double* p = numbers;

    for (size_t i = 0; i < size; i++)
    {
        // Dereference the pointer, then increment it
        std::cout << *p++ << " ";
    }

    // Alternate method:
    // Reset p to numbers[0]:
    p = numbers;

    // Use address of pointer to compute bounds.
    // The compiler computes size as the number
    // of elements * (bytes per element).
    while (p < (numbers + size))
    {
        // Dereference the pointer, then increment it
        std::cout << *p++ << " ";
    }

    delete[] numbers; // don't forget to do this!

}
int main()
{
    do_something(108);
}

Menginisialisasi array

Anda dapat menginisialisasi array dalam perulangan, satu elemen pada satu waktu, atau dalam satu pernyataan. Konten dari dua array berikut identik:

    int a[10];
    for (int i = 0; i < 10; ++i)
    {
        a[i] = i + 1;
    }

    int b[10]{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

Meneruskan array ke fungsi

Saat array diteruskan ke fungsi, array diteruskan sebagai penunjuk ke elemen pertama, baik itu array berbasis tumpukan atau berbasis timbunan. Penunjuk tidak berisi informasi ukuran atau jenis lainnya. Perilaku ini disebut penunjuk membusuk. Saat meneruskan array ke fungsi, Anda harus selalu menentukan jumlah elemen dalam parameter terpisah. Perilaku ini juga menyiratkan bahwa elemen array tidak disalin saat array diteruskan ke fungsi. Untuk mencegah fungsi memodifikasi elemen, tentukan parameter sebagai penunjuk ke const elemen.

Contoh berikut menunjukkan fungsi yang menerima array dan panjang. Penunjuk menunjuk ke array asli, bukan salinan. Karena parameternya bukan const, fungsi dapat memodifikasi elemen array.

void process(double *p, const size_t len)
{
    std::cout << "process:\n";
    for (size_t i = 0; i < len; ++i)
    {
        // do something with p[i]
    }
}

Deklarasikan dan tentukan parameter pconst array untuk membuatnya baca-saja dalam blok fungsi:

void process(const double *p, const size_t len);

Fungsi yang sama juga dapat dideklarasikan dengan cara ini, tanpa perubahan perilaku. Array masih diteruskan sebagai penunjuk ke elemen pertama:

// Unsized array
void process(const double p[], const size_t len);

// Fixed-size array. Length must still be specified explicitly.
void process(const double p[1000], const size_t len);

Array multidimensi

Array yang dibangun dari array lain adalah array multidmensional. Array multidemitis ini ditentukan dengan menempatkan beberapa ekspresi konstanta kurung secara berurutan. Misalnya, pertimbangkan deklarasi ini:

int i2[5][7];

Ini menentukan array jenis int, secara konseptual disusun dalam matriks dua dimensi lima baris dan tujuh kolom, seperti yang ditunjukkan pada gambar berikut:

Gambar adalah kisi lebar 7 sel dan tinggi 5 sel. Setiap sel berisi indeks sel. Indeks sel pertama diberi label 0,0. Sel berikutnya dalam baris tersebut adalah 0,1 dan seterunya ke sel terakhir dalam baris tersebut yaitu 0,6. Baris berikutnya dimulai dengan indeks 1,0. Sel setelah itu memiliki indeks 1,1. Sel terakhir dalam baris tersebut adalah 1,6. Pola ini berulang hingga baris terakhir, yang dimulai dengan indeks 4,0. Sel terakhir di baris terakhir memiliki indeks 4,6.

Anda dapat mendeklarasikan array multidimensi yang memiliki daftar inisialisasi (seperti yang dijelaskan dalam Initializer). Dalam deklarasi ini, ekspresi konstanta yang menentukan batas untuk dimensi pertama dapat dihilangkan. Contohnya:

// arrays2.cpp
// compile with: /c
const int cMarkets = 4;
// Declare a float that represents the transportation costs.
double TransportCosts[][cMarkets] = {
   { 32.19, 47.29, 31.99, 19.11 },
   { 11.29, 22.49, 33.47, 17.29 },
   { 41.97, 22.09,  9.76, 22.55 }
};

Deklarasi sebelumnya mendefinisikan array yang tiga baris dengan empat kolom. Baris mewakili pabrik dan kolom mewakili pasar tempat pabrik dikirim. Nilai-nilainya adalah biaya transportasi dari pabrik ke pasar. Dimensi pertama array dibiarkan keluar, tetapi pengompilasi mengisinya dengan memeriksa penginisialisasi.

Penggunaan operator tidak langsung (*) pada jenis array n-dimensi menghasilkan array dimensi n-1. Jika n adalah 1, skalar (atau elemen array) dihasilkan.

Array C++ disimpan dalam urutan baris-utama. Urutan utama baris berarti subskrip terakhir bervariasi paling cepat.

Contoh

Anda juga dapat menghilangkan spesifikasi batas untuk dimensi pertama array multidmensional dalam deklarasi fungsi, seperti yang ditunjukkan di sini:

// multidimensional_arrays.cpp
// compile with: /EHsc
// arguments: 3
#include <limits>   // Includes DBL_MAX
#include <iostream>

const int cMkts = 4, cFacts = 2;

// Declare a float that represents the transportation costs
double TransportCosts[][cMkts] = {
   { 32.19, 47.29, 31.99, 19.11 },
   { 11.29, 22.49, 33.47, 17.29 },
   { 41.97, 22.09,  9.76, 22.55 }
};

// Calculate size of unspecified dimension
const int cFactories = sizeof TransportCosts /
                  sizeof( double[cMkts] );

double FindMinToMkt( int Mkt, double myTransportCosts[][cMkts], int mycFacts);

using namespace std;

int main( int argc, char *argv[] ) {
   double MinCost;

   if (argv[1] == 0) {
      cout << "You must specify the number of markets." << endl;
      exit(0);
   }
   MinCost = FindMinToMkt( *argv[1] - '0', TransportCosts, cFacts);
   cout << "The minimum cost to Market " << argv[1] << " is: "
       << MinCost << "\n";
}

double FindMinToMkt(int Mkt, double myTransportCosts[][cMkts], int mycFacts) {
   double MinCost = DBL_MAX;

   for( size_t i = 0; i < cFacts; ++i )
      MinCost = (MinCost < TransportCosts[i][Mkt]) ?
         MinCost : TransportCosts[i][Mkt];

   return MinCost;
}

The minimum cost to Market 3 is: 17.29

Fungsi FindMinToMkt ini ditulis sewaktu-waktu sehingga menambahkan pabrik baru tidak memerlukan perubahan kode apa pun, hanya kompilasi ulang.

Menginisialisasi Array

Array objek yang memiliki konstruktor kelas diinisialisasi oleh konstruktor. Ketika ada lebih sedikit item dalam daftar penginisialisasi daripada elemen dalam array, konstruktor default digunakan untuk elemen yang tersisa. Jika tidak ada konstruktor default yang ditentukan untuk kelas , daftar inisialisasi harus lengkap, yaitu, harus ada satu penginisialisasi untuk setiap elemen dalam array.

Point Pertimbangkan kelas yang mendefinisikan dua konstruktor:

// initializing_arrays1.cpp
class Point
{
public:
   Point()   // Default constructor.
   {
   }
   Point( int, int )   // Construct from two ints
   {
   }
};

// An array of Point objects can be declared as follows:
Point aPoint[3] = {
   Point( 3, 3 )     // Use int, int constructor.
};

int main()
{
}

Elemen aPoint pertama dibangun menggunakan konstruktor Point( int, int ); dua elemen yang tersisa dibangun menggunakan konstruktor default.

Array anggota statis (apakah const dapat diinisialisasi atau tidak) dalam definisi mereka (di luar deklarasi kelas). Contohnya:

// initializing_arrays2.cpp
class WindowColors
{
public:
    static const char *rgszWindowPartList[7];
};

const char *WindowColors::rgszWindowPartList[7] = {
    "Active Title Bar", "Inactive Title Bar", "Title Bar Text",
    "Menu Bar", "Menu Bar Text", "Window Background", "Frame"   };
int main()
{
}

Mengakses elemen array

Anda dapat mengakses elemen individual array dengan menggunakan operator subskrip array ([ ]). Jika Anda menggunakan nama array satu dimensi tanpa subskrip, array tersebut akan dievaluasi sebagai penunjuk ke elemen pertama array.

// using_arrays.cpp
int main() {
   char chArray[10];
   char *pch = chArray;   // Evaluates to a pointer to the first element.
   char   ch = chArray[0];   // Evaluates to the value of the first element.
   ch = chArray[3];   // Evaluates to the value of the fourth element.
}

Saat Anda menggunakan array multidimensi, Anda dapat menggunakan berbagai kombinasi dalam ekspresi.

// using_arrays_2.cpp
// compile with: /EHsc /W1
#include <iostream>
using namespace std;
int main() {
   double multi[4][4][3];   // Declare the array.
   double (*p2multi)[3];
   double (*p1multi);

   cout << multi[3][2][2] << "\n";   // C4700 Use three subscripts.
   p2multi = multi[3];               // Make p2multi point to
                                     // fourth "plane" of multi.
   p1multi = multi[3][2];            // Make p1multi point to
                                     // fourth plane, third row
                                     // of multi.
}

Dalam kode sebelumnya, multi adalah array tiga dimensi jenis double. Penunjuk p2multi menunjuk ke array jenis double ukuran tiga. Dalam contoh ini, array digunakan dengan satu, dua, dan tiga subskrip. Meskipun lebih umum untuk menentukan semua subskrip, seperti dalam cout pernyataan, terkadang berguna untuk memilih subset elemen array tertentu, seperti yang ditunjukkan dalam pernyataan yang mengikuti cout.

Operator subskrip kelebihan beban

Seperti operator lain, operator subskrip ([]) dapat ditentukan ulang oleh pengguna. Perilaku default operator subskrip, jika tidak kelebihan beban, adalah menggabungkan nama array dan subskrip menggunakan metode berikut:

*((array_name) + (subscript))

Seperti semua penambahan yang melibatkan jenis pointer, penskalaan dilakukan secara otomatis untuk menyesuaikan ukuran jenis. Nilai yang dihasilkan bukan n byte dari asal array_name; sebagai gantinya, ini adalah elemen nth dari array. Untuk informasi selengkapnya tentang konversi ini, lihat Operator aditif.

Demikian pula, untuk array multidansa, alamat diturunkan menggunakan metode berikut:

((array_name) + (subscript1 * max2 * max3 * ... * maxn) + (subscript2 * max3 * ... * maxn) + ... + subscriptn))

Array dalam Ekspresi

Saat pengidentifikasi jenis array muncul dalam ekspresi selain sizeof, alamat (&), atau inisialisasi referensi, itu dikonversi ke penunjuk ke elemen array pertama. Contohnya:

char szError1[] = "Error: Disk drive not ready.";
char *psz = szError1;

Penunjuk menunjuk psz ke elemen pertama dari array szError1. Array, tidak seperti pointer, bukan nilai l yang dapat dimodifikasi. Itulah sebabnya tugas berikut ilegal:

szError1 = psz;

Lihat juga

std::array