Mengapa ukuran parameter array tidak sama dengan main?

Mengapa ukuran array yang dikirim sebagai parameter tidak sama dengan main?

#include <stdio.h>

void PrintSize(int p_someArray[10]);

int main () {
    int myArray[10];
    printf("%d\n", sizeof(myArray)); /* As expected, 40 */
    PrintSize(myArray);/* Prints 4, not 40 */
}

void PrintSize(int p_someArray[10]){
    printf("%d\n", sizeof(p_someArray));
}

Sebuah tipe array secara implisit diubah menjadi tipe pointer ketika Anda meneruskannya ke sebuah fungsi.

Begitu,

void PrintSize(int p_someArray[10]) {
    printf("%zu\n", sizeof(p_someArray));
}

dan

void PrintSize(int *p_someArray) {
    printf("%zu\n", sizeof(p_someArray));
}

setara. Jadi apa yang Anda dapatkan adalah nilaisizeof(int*)

Ini adalah pointer, itulah mengapa implementasi umum untuk meneruskan ukuran array sebagai parameter kedua ke fungsi

Seperti yang dinyatakan orang lain, array meluruh menjadi pointer ke elemen pertamanya saat digunakan sebagai parameter fungsi. Perlu juga dicatat bahwa sizeof tidak mengevaluasi ekspresi dan tidak memerlukan tanda kurung saat digunakan dengan ekspresi, jadi parameter Anda tidak benar-benar digunakan sama sekali, jadi Anda sebaiknya menulis sizeof dengan tipe daripada nilainya.

#include <stdio.h>

void PrintSize1 ( int someArray[][10] );
void PrintSize2 ( int someArray[10] );

int main ()
{
    int myArray[10];
    printf ( "%d\n", sizeof myArray ); /* as expected 40 */
    printf ( "%d\n", sizeof ( int[10] ) ); /* requires parens */
    PrintSize1 ( 0 ); /* prints 40, does not evaluate 0[0] */
    PrintSize2 ( 0 ); /* prints 40, someArray unused */
}

void PrintSize1 ( int someArray[][10] )
{
    printf ( "%d\n", sizeof someArray[0] );
}

void PrintSize2 ( int someArray[10] )
{
    printf ( "%d\n", sizeof ( int[10] ) );
}

Jadi, Anda harus meneruskan lenght array sebagai parameter kedua. Saat Anda menulis kode, di mana Anda berdua mendeklarasikan sebuah array dengan ukuran konstan, dan kemudian meneruskan array itu ke sebuah fungsi, sangat merepotkan jika konstanta panjang array muncul di beberapa tempat dalam kode Anda ...

K&R untuk menyelamatkan:

#define N_ELEMENTS(array) (sizeof(array)/sizeof((array)[0])) 

Jadi sekarang Anda bisa melakukannya misalnya:

int a[10];
...
myfunction(a, N_ELEMENTS(a));

Karena array meluruh menjadi pointer ketika dilewatkan sebagai parameter. Ini adalah cara kerja C, meskipun Anda bisa meneruskan "array" di C ++ dengan referensi dan mengatasi masalah ini. Perhatikan bahwa Anda dapat meneruskan array dengan ukuran berbeda ke fungsi ini:

 // 10 is superfluous here! You can pass an array of different size!
void PrintSize(int p_someArray[10]);

Perilaku yang Anda temukan sebenarnya adalah kutil besar dalam bahasa C. Setiap kali Anda mendeklarasikan fungsi yang mengambil parameter array, compiler mengabaikan Anda dan mengubah parameter menjadi pointer. Jadi semua deklarasi ini berperilaku seperti yang pertama:

void func(int *a)
void func(int a[])
void func(int a
typedef int array_plz[5];
void func(array_plz a)

a akan menjadi penunjuk ke int dalam keempat kasus. Jika Anda meneruskan sebuah array ke func, array itu akan segera meluruh menjadi pointer ke elemen pertamanya. (Pada sistem 64-bit, penunjuk 64-bit dua kali lebih besar dari int 32-bit, sehingga rasio sizeof Anda kembali 2.)

Satu-satunya tujuan aturan ini adalah untuk mempertahankan kompatibilitas mundur dengan kompiler historis yang tidak mendukung penerusan nilai agregat sebagai argumen fungsi.

Ini tidak berarti bahwa tidak mungkin meneruskan array ke suatu fungsi. Anda dapat menyiasati kutil ini dengan menyematkan array ke dalam struct (ini pada dasarnya adalah tujuan dari std :: array C ++ 11):

struct array_rly {
int a[5];
};
void func(struct array_rly a)
{
printf("%zd\n", sizeof(a.a)/sizeof(a.a[0]));  /* prints 5 */
}

atau dengan meneruskan pointer ke array:

void func(const int (*a)[5])
{
printf("%zd\n", sizeof(*a)/sizeof((*a)[0]));  /* prints 5 */
}

Jika ukuran array bukan konstanta waktu kompilasi, Anda dapat menggunakan teknik pointer-ke-array dengan array panjang variabel C99:

void func(int n, const int (*a)[n])
{
printf("%zd\n", sizeof(*a)/sizeof((*a)[0]));  /* prints n */
}

Di c ++ Anda bisa melewatkan array dengan referensi untuk tujuan ini:

void foo(int (&array)[10])
{
    std::cout << sizeof(array) << "\n";
}

Dalam bahasa C, tidak ada metode untuk menentukan ukuran array yang tidak diketahui, jadi kuantitas perlu diteruskan serta penunjuk ke elemen pertama.

Anda tidak bisa meneruskan array ke fungsi.

Jika Anda benar-benar ingin mencetak ukurannya, Anda dapat meneruskan pointer ke array, tetapi itu tidak akan umum sama sekali karena Anda juga perlu menentukan ukuran array untuk fungsi tersebut.

#include <stdio.h>

void PrintSize(int (*p_anArray)[10]);

int main(void) {
    int myArray[10];
    printf("%d\n", sizeof(myArray)); /* as expected 40 */
    PrintSize(&myArray);/* prints 40 */
}

void PrintSize(int (*p_anArray)[10]){
    printf("%d\n", (int) sizeof(*p_anArray));
}

Perilaku itu memang sengaja.

Sintaks yang sama dalam deklarasi parameter fungsi berarti hal yang sama sekali berbeda dari pada definisi variabel lokal.

Alasannya dijelaskan dalam jawaban lain.

Dalam bahasa C ketika Anda melewatkan array sebagai argumen ke fungsi, itu secara otomatis diubah menjadi pointer, array yang lewat dari satu fungsi fungsi lain dikenal sebagai panggilan dengan referensi. Itulah alasan mengapa fungsi yang dipanggil hanya menerima penunjuk yang menunjuk ke elemen pertama dari fungsi Ini adalah alasannya

kesenangan (int a []) mirip dengan kesenangan (int * a);

jadi ketika Anda mencetak ukuran array itu akan mencetak ukuran elemen pertama.

Dalam 'C' bahasa pemrograman 'sizeof ()' adalah operator dan dia mengembalikan ukuran objek dalam byte.Arumen operator 'sizeof ()' harus berupa tipe nilai kiri (integer, angka float, struct, array Jadi jika Anda ingin mengetahui ukuran sebuah array dalam byte Anda dapat melakukannya dengan sangat sederhana, cukup gunakan operator 'sizeof ()' dan untuk argumennya gunakan nama array, misalnya:

#include <stdio.h>

main(){

 int n[10];
 printf("Size of n is: %d \n", sizeof(n)); 

}

Output pada sistem 32 bit akan menjadi: Size dari n adalah: 40. Karena ineteger pada sistem 32 adalah 4bytes. Pada 64x adalah 8bytes. Dalam hal ini kita memiliki 10 integer yang dideklarasikan dalam satu array, jadi hasilnya adalah '10 * sizeof ( int) '.

Beberapa tips:

Jika kita memiliki sebuah array yang dideklarasikan seperti ini 'int n [] = {1, 2, 3, ... 155 ..};'. Jadi kami ingin tahu berapa banyak elemen yang disimpan dalam array ini. Gunakan alghoritma ini:

sizeof (name_of_the_array) / sizeof (array_type)

Kode: #include

utama(){

int n[] = { 1, 2, 3, 44, 6, 7 };
printf("Number of elements: %d \n", sizeof(n) / sizeof(int));
return 0;

}

Array hanya berukuran longgar. Untuk sebagian besar, array adalah penunjuk ke memori. Ukuran dalam deklarasi Anda hanya memberi tahu kompiler berapa banyak memori yang harus dialokasikan untuk array - ini tidak terkait dengan tipe, jadi sizeof () tidak perlu dilanjutkan.