Apa itu array to pointer decay?

Apa itu array to pointer decay? Apakah ada kaitannya dengan pointer array?

Dikatakan bahwa array "membusuk" menjadi pointer. Array C ++ dinyatakan sebagai int numbers [5]tidak dapat diarahkan kembali, yaitu Anda tidak bisa mengatakan numbers = 0x5a5aff23. Lebih penting lagi, istilah peluruhan menandakan hilangnya jenis dan dimensi; numberspembusukan int*dengan kehilangan informasi dimensi (hitungan 5) dan tipenya tidak int [5]lagi. Lihat di sini untuk kasus di mana pembusukan tidak terjadi .

Jika Anda melewatkan array berdasarkan nilai, apa yang sebenarnya Anda lakukan adalah menyalin pointer - pointer ke elemen pertama array akan disalin ke parameter (yang tipenya juga harus menjadi pointer tipe elemen array). Ini berfungsi karena sifat peluruhan array; sekali membusuk, sizeoftidak lagi memberikan ukuran array yang lengkap, karena pada dasarnya menjadi pointer. Inilah sebabnya mengapa lebih disukai (antara alasan lain) untuk melewati referensi atau pointer.

Tiga cara untuk lulus dalam array ¹ :

void by_value(const T* array)   // const T array[] means the same
void by_pointer(const T (*array)[U])
void by_reference(const T (&array)[U])

Dua yang terakhir akan memberikan sizeofinfo yang tepat , sedangkan yang pertama tidak akan karena argumen array telah meluruh untuk ditetapkan ke parameter.

^{1 U yang konstan harus diketahui pada waktu kompilasi.}

Array pada dasarnya sama dengan pointer di C / C ++, tetapi tidak cukup. Setelah Anda mengonversi array:

const int a[] = { 2, 3, 5, 7, 11 };

menjadi pointer (yang berfungsi tanpa casting, dan karenanya dapat terjadi secara tak terduga dalam beberapa kasus):

const int* p = a;

Anda kehilangan kemampuan sizeofoperator untuk menghitung elemen dalam array:

assert( sizeof(p) != sizeof(a) );  // sizes are not equal

Kemampuan yang hilang ini disebut sebagai "pembusukan".

Untuk detail lebih lanjut, lihat artikel ini tentang peluruhan array .

Inilah yang dikatakan standar (C99 6.3.2.1/3 - Operan lainnya - Lvalues, array, dan function designators):

Kecuali ketika itu adalah operan dari operator sizeof atau unary & operator, atau string literal digunakan untuk menginisialisasi array, ekspresi yang memiliki tipe '' array of type '' dikonversi menjadi ekspresi dengan tipe '' pointer ke ketik '' yang menunjuk ke elemen awal objek array dan bukan merupakan nilai.

Ini berarti bahwa kapan saja nama array digunakan dalam ekspresi, secara otomatis dikonversi menjadi pointer ke item pertama dalam array.

Perhatikan bahwa nama fungsi bertindak dengan cara yang serupa, tetapi pointer fungsi digunakan jauh lebih sedikit dan dengan cara yang jauh lebih khusus sehingga tidak menyebabkan kebingungan sebanyak konversi otomatis dari nama array ke pointer.

Standar C ++ (4.2 Array-to-pointer konversi) melonggarkan persyaratan konversi ke (penekanan tambang):

Nilai atau nilai tipe "array NT" atau "array batas tidak diketahui T" dapat dikonversi ke nilai tipe "pointer to T."

Jadi konversi tidak harus terjadi seperti biasanya di C (ini memungkinkan fungsi kelebihan atau templat cocok dengan jenis array).

Ini juga mengapa di C Anda harus menghindari menggunakan parameter array dalam prototipe fungsi / definisi (menurut saya - saya tidak yakin apakah ada kesepakatan umum). Mereka menyebabkan kebingungan dan fiksi - menggunakan parameter pointer dan kebingungan mungkin tidak hilang sepenuhnya, tetapi setidaknya deklarasi parameter tidak bohong.

"Decay" mengacu pada konversi tersirat dari ekspresi dari tipe array ke tipe pointer. Dalam sebagian besar konteks, ketika kompiler melihat ekspresi array, ia mengubah tipe ekspresi dari "N-element array of T" menjadi "pointer to T" dan menetapkan nilai ekspresi ke alamat elemen pertama dari array. . Pengecualian untuk aturan ini adalah ketika sebuah array adalah operan dari baik sizeofatau &operator, atau array adalah string literal digunakan sebagai initializer dalam deklarasi.

Asumsikan kode berikut:

char a[80];
strcpy(a, "This is a test");

Ekspresi aadalah tipe "80-elemen array char" dan ekspresi "Ini adalah tes" adalah tipe "16-elemen array char" (dalam C; dalam string C ++ string literal adalah array dari const char). Namun, dalam panggilan ke strcpy(), tidak ada ekspresi yang merupakan operan dari sizeofatau &, jadi tipe mereka secara implisit dikonversi menjadi "pointer ke char", dan nilainya diatur ke alamat elemen pertama di masing-masing. Apa yang strcpy()diterima bukan array, tetapi pointer, seperti yang terlihat dalam prototipe:

char *strcpy(char *dest, const char *src);

Ini bukan hal yang sama dengan pointer array. Sebagai contoh:

char a[80];
char *ptr_to_first_element = a;
char (*ptr_to_array)[80] = &a;

Kedua ptr_to_first_elementdan ptr_to_arraymemiliki yang sama nilai ; alamat dasar a. Namun, mereka berbeda jenis dan diperlakukan berbeda, seperti yang ditunjukkan di bawah ini:

a[i] == ptr_to_first_element[i] == (*ptr_to_array)[i] != *ptr_to_array[i] != ptr_to_array[i]

Ingat bahwa ekspresi a[i]ditafsirkan sebagai *(a+i)(yang hanya berfungsi jika tipe array dikonversi ke tipe pointer), jadi keduanya a[i]dan ptr_to_first_element[i]berfungsi sama. Ekspresi (*ptr_to_array)[i]diartikan sebagai *(*a+i). Ekspresi *ptr_to_array[i]dan ptr_to_array[i]dapat menyebabkan peringatan kompiler atau kesalahan tergantung pada konteksnya; mereka pasti akan melakukan hal yang salah jika Anda mengharapkan mereka untuk mengevaluasi a[i].

sizeof a == sizeof *ptr_to_array == 80

Sekali lagi, ketika sebuah array adalah operan sizeof, itu tidak dikonversi ke tipe pointer.

sizeof *ptr_to_first_element == sizeof (char) == 1
sizeof ptr_to_first_element == sizeof (char *) == whatever the pointer size
                                                  is on your platform

ptr_to_first_element adalah pointer sederhana ke char.

Array, dalam C, tidak memiliki nilai.

Di mana pun nilai suatu objek diharapkan tetapi objeknya adalah sebuah array, alamat elemen pertamanya digunakan sebagai gantinya, dengan tipe pointer to (type of array elements).

Dalam suatu fungsi, semua parameter dilewatkan oleh nilai (array tidak terkecuali). Ketika Anda melewatkan sebuah array dalam suatu fungsi, ia "meluruh menjadi sebuah pointer" (sic); ketika Anda membandingkan sebuah array dengan sesuatu yang lain, sekali lagi itu "meluruh menjadi sebuah pointer" (sic); ...

void foo(int arr[]);

Function foo mengharapkan nilai array. Tetapi, dalam C, array tidak memiliki nilai! Jadi, fooalih-alih mendapatkan alamat elemen pertama array.

int arr[5];
int *ip = &(arr[1]);
if (arr == ip) { /* something; */ }

Dalam perbandingan di atas, arrtidak memiliki nilai, sehingga menjadi pointer. Ini menjadi pointer ke int. Pointer itu dapat dibandingkan dengan variabel ip.

Dalam sintaks pengindeksan array Anda terbiasa melihat, sekali lagi, arr 'decayed to a pointer'

arr[42];
/* same as *(arr + 42); */
/* same as *(&(arr[0]) + 42); */

Satu-satunya kali array tidak membusuk menjadi pointer adalah ketika itu adalah operan dari operator sizeof, atau operator & (operator alamat), atau sebagai string string yang digunakan untuk menginisialisasi array karakter.

Saat itulah array membusuk dan sedang diarahkan ;-)

Sebenarnya, hanya saja jika Anda ingin melewatkan array di suatu tempat, tetapi pointernya malah dilewatkan (karena siapa yang akan melewati seluruh array untuk Anda), orang mengatakan bahwa array miskin membusuk ke pointer.

Array decaying berarti bahwa, ketika sebuah array dilewatkan sebagai parameter ke suatu fungsi, array diperlakukan secara identik dengan ("decay to") sebuah pointer.

void do_something(int *array) {
  // We don't know how big array is here, because it's decayed to a pointer.
  printf("%i\n", sizeof(array));  // always prints 4 on a 32-bit machine
}

int main (int argc, char **argv) {
    int a[10];
    int b[20];
    int *c;
    printf("%zu\n", sizeof(a)); //prints 40 on a 32-bit machine
    printf("%zu\n", sizeof(b)); //prints 80 on a 32-bit machine
    printf("%zu\n", sizeof(c)); //prints 4 on a 32-bit machine
    do_something(a);
    do_something(b);
    do_something(c);
}

Ada dua komplikasi atau pengecualian di atas.

Pertama, ketika berhadapan dengan array multidimensi dalam C dan C ++, hanya dimensi pertama yang hilang. Ini karena array diletakkan secara bersebelahan dalam memori, sehingga kompiler harus mengetahui semua kecuali dimensi pertama untuk dapat menghitung offset ke blok memori itu.

void do_something(int array[][10])
{
    // We don't know how big the first dimension is.
}

int main(int argc, char *argv[]) {
    int a[5][10];
    int b[20][10];
    do_something(a);
    do_something(b);
    return 0;
}

Kedua, di C ++, Anda bisa menggunakan templat untuk menyimpulkan ukuran array. Microsoft menggunakan ini untuk versi C ++ fungsi CRT Aman seperti strcpy_s , dan Anda bisa menggunakan trik serupa untuk secara andal mendapatkan jumlah elemen dalam array .

tl; dr: Saat Anda menggunakan array yang telah Anda tentukan, Anda akan benar-benar menggunakan pointer ke elemen pertamanya.

Jadi:

• Ketika Anda menulis arr[idx]Anda benar-benar hanya mengatakan*(arr + idx) .
• fungsi tidak pernah benar-benar mengambil array sebagai parameter, hanya pointer, bahkan ketika Anda menentukan parameter array.

Sortir pengecualian untuk aturan ini:

• Anda dapat meneruskan array panjang tetap ke fungsi dalam a struct.
• sizeof() memberikan ukuran yang diambil oleh array, bukan ukuran pointer.

Saya mungkin sangat berani berpikir ada empat (4) cara untuk melewatkan array sebagai argumen fungsi. Juga di sini adalah kode singkat tapi berfungsi untuk pembacaan Anda.

#include <iostream>
#include <string>
#include <vector>
#include <cassert>

using namespace std;

// test data
// notice native array init with no copy aka "="
// not possible in C
 const char* specimen[]{ __TIME__, __DATE__, __TIMESTAMP__ };

// ONE
// simple, dangerous and useless
template<typename T>
void as_pointer(const T* array) { 
    // a pointer
    assert(array != nullptr); 
} ;

// TWO
// for above const T array[] means the same
// but and also , minimum array size indication might be given too
// this also does not stop the array decay into T *
// thus size information is lost
template<typename T>
void by_value_no_size(const T array[0xFF]) { 
    // decayed to a pointer
    assert( array != nullptr ); 
}

// THREE
// size information is preserved
// but pointer is asked for
template<typename T, size_t N>
void pointer_to_array(const T (*array)[N])
{
   // dealing with native pointer 
    assert( array != nullptr ); 
}

// FOUR
// no C equivalent
// array by reference
// size is preserved
template<typename T, size_t N>
void reference_to_array(const T (&array)[N])
{
    // array is not a pointer here
    // it is (almost) a container
    // most of the std:: lib algorithms 
    // do work on array reference, for example
    // range for requires std::begin() and std::end()
    // on the type passed as range to iterate over
    for (auto && elem : array )
    {
        cout << endl << elem ;
    }
}

int main()
{
     // ONE
     as_pointer(specimen);
     // TWO
     by_value_no_size(specimen);
     // THREE
     pointer_to_array(&specimen);
     // FOUR
     reference_to_array( specimen ) ;
}

Saya mungkin juga berpikir ini menunjukkan keunggulan C ++ vs C. Setidaknya dalam referensi (pun intended) melewati array dengan referensi.

Tentu saja ada proyek yang sangat ketat tanpa alokasi tumpukan, tanpa pengecualian dan tanpa std :: lib. C ++ penanganan array asli adalah fitur bahasa misi kritis, bisa dikatakan.