Mengapa kompiler C dan C ++ memungkinkan panjang array dalam tanda tangan fungsi ketika mereka tidak pernah ditegakkan?

Inilah yang saya temukan selama masa belajar saya:

#include<iostream>
using namespace std;
int dis(char a[1])
{
    int length = strlen(a);
    char c = a[2];
    return length;
}
int main()
{
    char b[4] = "abc";
    int c = dis(b);
    cout << c;
    return 0;
}  

Jadi dalam variabel int dis(char a[1]), [1]sepertinya tidak melakukan apa-apa dan tidak berfungsi sama
sekali, karena saya dapat menggunakan a[2]. Hanya suka int a[]atau char *a. Saya tahu nama array adalah pointer dan cara menyampaikan array, jadi teka-teki saya bukan tentang bagian ini.

Yang ingin saya ketahui adalah mengapa kompiler mengizinkan perilaku ini ( int a[1]). Atau apakah ada makna lain yang tidak saya ketahui?

Ini adalah kekhasan dari sintaks untuk meneruskan array ke fungsi.

Sebenarnya tidak mungkin untuk melewatkan array di C. Jika Anda menulis sintaks yang terlihat seperti harus melewati array, yang sebenarnya terjadi adalah pointer ke elemen pertama array dilewatkan.

Karena pointer tidak menyertakan informasi panjang, konten Anda []dalam daftar parameter formal fungsi sebenarnya diabaikan.

Keputusan untuk mengizinkan sintaks ini dibuat pada tahun 1970-an dan telah menyebabkan banyak kebingungan sejak ...

Panjang dimensi pertama diabaikan, tetapi panjang dimensi tambahan diperlukan untuk memungkinkan kompilator menghitung offset dengan benar. Dalam contoh berikut, foofungsi dilewatkan pointer ke array dua dimensi.

#include <stdio.h>

void foo(int args[10][20])
{
    printf("%zd\n", sizeof(args[0]));
}

int main(int argc, char **argv)
{
    int a[2][20];
    foo(a);
    return 0;
}

Ukuran dimensi pertama [10]diabaikan; kompiler tidak akan mencegah Anda mengindeks akhir (perhatikan bahwa formal menginginkan 10 elemen, tetapi sebenarnya hanya menyediakan 2). Namun, ukuran dimensi kedua [20]digunakan untuk menentukan langkah setiap baris, dan di sini, formal harus cocok dengan yang sebenarnya. Sekali lagi, kompiler tidak akan mencegah Anda mengindeks dari akhir dimensi kedua.

Byte offset dari basis array ke elemen args[row][col]ditentukan oleh:

sizeof(int)*(col + 20*row)

Perhatikan bahwa jika col >= 20, maka Anda benar-benar akan mengindeks ke baris berikutnya (atau dari akhir seluruh array).

sizeof(args[0]), mengembalikan 80mesin saya di mana sizeof(int) == 4. Namun, jika saya mencoba untuk mengambilsizeof(args) , saya mendapatkan peringatan kompiler berikut:

foo.c:5:27: warning: sizeof on array function parameter will return size of 'int (*)[20]' instead of 'int [10][20]' [-Wsizeof-array-argument]
    printf("%zd\n", sizeof(args));
                          ^
foo.c:3:14: note: declared here
void foo(int args[10][20])
             ^
1 warning generated.

Di sini, kompiler memperingatkan bahwa ia hanya akan memberikan ukuran pointer ke mana array telah membusuk, bukan ukuran array itu sendiri.

Masalahnya dan bagaimana cara mengatasinya di C ++

Masalahnya telah dijelaskan secara luas oleh Pat dan Matt . Compiler pada dasarnya mengabaikan dimensi pertama ukuran array secara efektif mengabaikan ukuran argumen yang diteruskan.

Di C ++, di sisi lain, Anda dapat dengan mudah mengatasi batasan ini dengan dua cara:

• menggunakan referensi
• menggunakan std::array(sejak C ++ 11)

Referensi

Jika fungsi Anda hanya mencoba membaca atau memodifikasi array yang ada (tidak menyalinnya), Anda dapat dengan mudah menggunakan referensi.

Misalnya, mari kita asumsikan Anda ingin memiliki fungsi yang me-reset array dari sepuluh intpengaturan setiap elemen 0. Anda dapat dengan mudah melakukannya dengan menggunakan tanda tangan fungsi berikut:

void reset(int (&array)[10]) { ... }

Tidak hanya ini akan berfungsi dengan baik , tetapi juga akan memperkuat dimensi array .

Anda juga dapat menggunakan templat untuk membuat kode di atas umum :

template<class Type, std::size_t N>
void reset(Type (&array)[N]) { ... }

Dan akhirnya Anda bisa memanfaatkan constkebenaran. Mari kita pertimbangkan fungsi yang mencetak array 10 elemen:

void show(const int (&array)[10]) { ... }

Dengan menerapkan constkualifikasi kami mencegah kemungkinan modifikasi .

Kelas perpustakaan standar untuk array

Jika Anda menganggap sintaks di atas jelek dan tidak perlu, seperti yang saya lakukan, kita bisa melemparkannya ke dalam kaleng dan menggunakannya std::arraysebagai gantinya (karena C ++ 11).

Berikut kode yang telah di-refactored:

void reset(std::array<int, 10>& array) { ... }
void show(std::array<int, 10> const& array) { ... }

Luar biasa bukan? Belum lagi bahwa trik kode generik yang saya ajarkan sebelumnya, masih berfungsi:

template<class Type, std::size_t N>
void reset(std::array<Type, N>& array) { ... }

template<class Type, std::size_t N>
void show(const std::array<Type, N>& array) { ... }

Bukan hanya itu, tetapi Anda mendapatkan salinan dan memindahkan semantik secara gratis. :)

void copy(std::array<Type, N> array) {
    // a copy of the original passed array 
    // is made and can be dealt with indipendently
    // from the original
}

Jadi tunggu apa lagi? Pergi gunakan std::array.

Ini adalah fitur menyenangkan dari C yang memungkinkan Anda untuk secara efektif menembak diri sendiri jika Anda ingin.

Saya pikir alasannya adalah bahwa C hanya satu langkah di atas bahasa assembly. Pengecekan ukuran dan fitur keselamatan serupa telah dihapus untuk memungkinkan kinerja puncak, yang bukan merupakan hal yang buruk jika programmer sedang sangat rajin.

Juga, menetapkan ukuran ke argumen fungsi memiliki keuntungan bahwa ketika fungsi tersebut digunakan oleh programmer lain, ada kemungkinan mereka akan melihat batasan ukuran. Hanya menggunakan pointer tidak menyampaikan informasi itu ke programmer berikutnya.

Pertama, C tidak pernah memeriksa batas array. Tidak masalah jika parameternya lokal, global, statis, apa pun. Memeriksa batas array berarti lebih banyak pemrosesan, dan C seharusnya sangat efisien, sehingga pemeriksaan batas array dilakukan oleh programmer ketika dibutuhkan.

Kedua, ada trik yang memungkinkan untuk melewatkan nilai array ke suatu fungsi. Dimungkinkan juga untuk mengembalikan array nilai dari suatu fungsi. Anda hanya perlu membuat tipe data baru menggunakan struct. Sebagai contoh:

typedef struct {
  int a[10];
} myarray_t;

myarray_t my_function(myarray_t foo) {

  myarray_t bar;

  ...

  return bar;

}

Anda harus mengakses elemen-elemen seperti ini: foo.a [1]. Ekstra ".a" mungkin terlihat aneh, tetapi trik ini menambahkan fungsionalitas hebat ke bahasa C.

Untuk memberi tahu kompiler bahwa myArray menunjuk ke array setidaknya 10 int:

void bar(int myArray[static 10])

Kompiler yang baik harus memberi Anda peringatan jika Anda mengakses myArray [10]. Tanpa kata kunci "statis", 10 tidak akan berarti apa-apa.

Ini adalah "fitur" terkenal dari C, diteruskan ke C ++ karena C ++ seharusnya mengkompilasi kode C dengan benar.

Masalah muncul dari beberapa aspek:

1. Nama array seharusnya sama dengan pointer.
2. C seharusnya cepat, awalnya dikembangkan untuk menjadi semacam "Assembler tingkat tinggi" (terutama dirancang untuk menulis "Sistem Operasi portabel" pertama: Unix), sehingga tidak seharusnya memasukkan kode "tersembunyi"; Pengecekan rentang runtime dengan demikian "terlarang".
3. Kode mesin yang dibuat untuk mengakses array statis atau dinamis (baik di stack atau dialokasikan) sebenarnya berbeda.
4. Karena fungsi yang dipanggil tidak dapat mengetahui "jenis" array yang dilewatkan sebagai argumen, semuanya dianggap sebagai pointer dan diperlakukan seperti itu.

Bisa dikatakan array tidak benar-benar didukung dalam C (ini tidak benar, seperti yang saya katakan sebelumnya, tetapi ini adalah perkiraan yang baik); sebuah array benar-benar diperlakukan sebagai pointer ke blok data dan diakses menggunakan pointer aritmatika. Karena C TIDAK memiliki bentuk RTTI, Anda harus mendeklarasikan ukuran elemen array dalam prototipe fungsi (untuk mendukung aritmatika pointer). Ini bahkan "lebih benar" untuk array multidimensi.

Pokoknya semua di atas tidak benar lagi: p

Paling modern C / C ++ compiler melakukan batas dukungan memeriksa, tapi standar membutuhkan untuk menjadi off secara default (untuk kompatibilitas). Versi terbaru gcc, misalnya, melakukan pengecekan rentang waktu-kompilasi dengan "-O3 -Wall -Wextra" dan batas waktu run penuh memeriksa dengan "-fbounds-checking".

C tidak hanya akan mengubah parameter tipe int[5]menjadi *int; diberikan deklarasi typedef int intArray5[5];, itu akan mengubah parameter tipe intArray5untuk *intjuga. Ada beberapa situasi di mana perilaku ini, meskipun aneh, berguna (terutama dengan hal-hal seperti yang va_listdidefinisikan dalam stdargs.h, yang didefinisikan oleh beberapa implementasi sebagai array). Akan tidak masuk akal untuk mengizinkan sebagai parameter tipe yang didefinisikan int[5](mengabaikan dimensi) tetapi tidak memungkinkan int[5]untuk ditentukan secara langsung.

Saya menemukan penanganan parameter parameter C menjadi tidak masuk akal, tetapi ini merupakan konsekuensi dari upaya untuk mengambil bahasa ad-hoc, sebagian besar yang tidak terlalu terdefinisi dengan baik atau dipikirkan, dan mencoba untuk datang dengan perilaku spesifikasi yang konsisten dengan apa yang dilakukan oleh implementasi yang ada untuk program yang ada. Banyak keanehan C masuk akal bila dilihat dalam cahaya itu, terutama jika orang menganggap bahwa ketika banyak dari mereka ditemukan, sebagian besar bahasa yang kita kenal sekarang belum ada. Dari apa yang saya mengerti, di pendahulunya ke C, disebut BCPL, kompiler tidak benar-benar melacak tipe variabel dengan sangat baik. Deklarasi int arr[5];setara dengan int anonymousAllocation[5],*arr = anonymousAllocation;; setelah alokasi disisihkan. kompiler tidak tahu atau tidak peduli apakaharradalah pointer atau array. Ketika diakses sebagai salah satu , itu akan dianggap sebagai penunjuk terlepas dari bagaimana itu dinyatakan.arr[x] atau*arr

Satu hal yang belum dijawab adalah pertanyaan sebenarnya.

Jawaban yang sudah diberikan menjelaskan bahwa array tidak dapat diteruskan oleh nilai ke fungsi dalam C atau C ++. Mereka juga menjelaskan bahwa suatu parameter yang dinyatakan sebagai int[]diperlakukan seolah-olah memiliki tipe int *, dan bahwa variabel tipe int[]dapat diteruskan ke fungsi tersebut.

Tetapi mereka tidak menjelaskan mengapa tidak pernah dibuat kesalahan untuk secara eksplisit memberikan panjang array.

void f(int *); // makes perfect sense
void f(int []); // sort of makes sense
void f(int [10]); // makes no sense

Mengapa kesalahan terakhir ini tidak terjadi?

Alasan untuk itu adalah bahwa hal itu menyebabkan masalah dengan typedef.

typedef int myarray[10];
void f(myarray array);

Jika kesalahan menentukan panjang array dalam parameter fungsi, Anda tidak akan dapat menggunakan myarraynama dalam parameter fungsi. Dan karena beberapa implementasi menggunakan tipe array untuk tipe pustaka standar seperti va_list, dan semua implementasi diperlukan untuk membuat jmp_buftipe array, akan sangat bermasalah jika tidak ada cara standar untuk mendeklarasikan parameter fungsi menggunakan nama-nama tersebut: tanpa kemampuan itu, bisa ada bukan menjadi implementasi portabel fungsi seperti vprintf.

Memungkinkan kompiler dapat memeriksa apakah ukuran array yang dilewati sama dengan yang diharapkan. Compiler dapat memperingatkan masalah jika bukan itu masalahnya.