Tại sao kích thước của một tham số mảng không giống như trong main?

Tại sao kích thước của một mảng được gửi dưới dạng tham số không giống như trong 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));
}

Kiểu mảng được chuyển đổi hoàn toàn thành kiểu con trỏ khi bạn chuyển nó vào một hàm.

Vì thế,

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

và

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

là tương đương. Vì vậy, những gì bạn nhận được là giá trị củasizeof(int*)

Đó là một con trỏ, đó là lý do tại sao cách triển khai phổ biến là truyền kích thước của mảng làm tham số thứ hai cho hàm

Như những người khác đã nêu, mảng phân rã thành con trỏ đến phần tử đầu tiên của chúng khi được sử dụng làm tham số hàm. Cũng cần lưu ý rằng sizeof không đánh giá biểu thức và không yêu cầu dấu ngoặc đơn khi được sử dụng với một biểu thức, do đó, tham số của bạn thực sự không được sử dụng, vì vậy bạn cũng có thể viết sizeof với kiểu thay vì giá trị.

#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] ) );
}

Vì vậy, bạn sẽ cần chuyển độ dài của mảng làm tham số thứ hai. Khi bạn đang viết mã, trong đó bạn vừa khai báo một mảng có kích thước không đổi, và sau đó truyền mảng đó cho một hàm, thật khó để hằng số độ dài mảng hiển thị một số vị trí trong mã của bạn ...

K&R để giải cứu:

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

Vì vậy, bây giờ bạn có thể làm ví dụ:

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

Bởi vì mảng phân rã thành con trỏ khi chúng được truyền dưới dạng tham số. Đây là cách C hoạt động, mặc dù bạn có thể truyền "mảng" trong C ++ bằng cách tham chiếu và khắc phục vấn đề này. Lưu ý rằng bạn có thể chuyển các mảng có kích thước khác nhau vào hàm này:

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

Hành vi bạn tìm thấy thực sự là một mụn cóc lớn trong ngôn ngữ C. Bất cứ khi nào bạn khai báo một hàm có tham số mảng, trình biên dịch sẽ bỏ qua bạn và thay đổi tham số thành con trỏ. Vì vậy, tất cả các khai báo này đều hoạt động giống như khai báo đầu tiên:

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

a sẽ là một con trỏ tới int trong cả bốn trường hợp. Nếu bạn chuyển một mảng cho func, nó sẽ ngay lập tức phân rã thành một con trỏ tới phần tử đầu tiên của nó. (Trên hệ thống 64 bit, con trỏ 64 bit lớn gấp đôi so với int 32 bit, vì vậy tỷ lệ sizeof của bạn trả về 2)

Mục đích duy nhất của quy tắc này là duy trì khả năng tương thích ngược với các trình biên dịch lịch sử không hỗ trợ chuyển các giá trị tổng hợp làm đối số hàm.

Điều này không có nghĩa là không thể truyền một mảng cho một hàm. Bạn có thể giải quyết vấn đề này bằng cách nhúng mảng vào một cấu trúc (về cơ bản đây là mục đích của std :: array của 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 */
}

hoặc bằng cách chuyển một con trỏ đến mảng:

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

Trong trường hợp kích thước mảng không phải là hằng số thời gian biên dịch, bạn có thể sử dụng kỹ thuật con trỏ đến mảng với mảng có độ dài thay đổi C99:

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

Trong c ++, bạn có thể chuyển một mảng bằng tham chiếu cho mục đích này:

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

Trong ngôn ngữ C, không có phương pháp nào để xác định kích thước của một mảng chưa biết, vì vậy số lượng cần được truyền cũng như một con trỏ đến phần tử đầu tiên.

Bạn không thể chuyển mảng cho các hàm.

Nếu bạn thực sự muốn in kích thước, bạn có thể chuyển một con trỏ đến một mảng, nhưng nó sẽ không chung chung chút nào vì bạn cũng cần xác định kích thước mảng cho hàm.

#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));
}

Hành vi là do thiết kế.

Cú pháp tương tự trong khai báo tham số hàm có nghĩa là hoàn toàn khác so với trong định nghĩa biến cục bộ.

Lý do được mô tả trong các câu trả lời khác.

Trong ngôn ngữ C, khi bạn truyền mảng làm đối số cho hàm, nó sẽ tự động được chuyển đổi thành con trỏ, mảng truyền từ một hàm này đến hàm khác được gọi là cuộc gọi bằng tham chiếu. Đó là lý do tại sao hàm được gọi chỉ nhận được con trỏ trỏ đến phần tử đầu tiên của hàm Đây là lý do

fun (int a []) tương tự như fun (int * a);

vì vậy khi bạn in kích thước của mảng, nó sẽ in kích thước của phần tử đầu tiên.

Trong lập trình 'C', uuange 'sizeof ()' là toán tử và trả về kích thước của đối tượng tính bằng byte. Đối số của toán tử 'sizeof ()' phải là kiểu giá trị bên trái (số nguyên, số thực, cấu trúc, mảng Vì vậy, nếu bạn muốn biết kích thước của một mảng tính bằng byte, bạn có thể làm điều đó rất đơn giản, chỉ cần sử dụng toán tử 'sizeof ()' và đối với đối số của anh ta, hãy sử dụng tên mảng. Ví dụ:

#include <stdio.h>

main(){

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

}

Kết quả đầu ra trên hệ thống 32 bit sẽ là: Kích thước của n là: 40 Vì trong hệ thống 32 bit là 4byte, trên 64x là 8byte, trong trường hợp này chúng ta có 10 số nguyên được khai báo trong một mảng. Vì vậy, kết quả là '10 * sizeof ( int) '.

Một số lời khuyên:

Nếu chúng ta có một mảng được khai báo như thế này 'int n [] = {1, 2, 3, ... 155 ..};'. Vì vậy, chúng tôi muốn biết có bao nhiêu phần tử được lưu trữ trong mảng này. Sử dụng thuật toán này:

sizeof (name_of_the_array) / sizeof (array_type)

Mã: #include

chủ yếu(){

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

}

Mảng chỉ có kích thước lỏng lẻo. Đối với hầu hết các phần, một mảng là một con trỏ tới bộ nhớ. Kích thước trong khai báo của bạn chỉ cho trình biên dịch biết có bao nhiêu bộ nhớ cần phân bổ cho mảng - nó không được liên kết với kiểu, vì vậy sizeof () không có gì để tiếp tục.