[已解决]为什么在main函数中打印的两个sizeof和在doublesort打印的sizeof值不一样呢

Big-Man · 发表于 2023-12-13 23:12:14

马上注册，结交更多好友，享用更多功能^_^

您需要登录才可以下载或查看，没有账号？立即注册

x

void maopao(int arr[]) {
cout << sizeof(arr[0]) << endl;
cout << sizeof(arr) << endl;
cout << arr[8] << endl;
int len_arr = sizeof(arr) / sizeof(arr[0]);
cout << len_arr << endl;
for (int i = 0; i < len_arr ; i++)
{
for (int j = i; j < len_arr - i -1; j++)
{
if (arr[j] > arr[j+1])
{
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
}
int main() {
int arr[10] = { 4,3,6,9,1,2,10,8,7,5 };
cout << sizeof(arr[0]) << endl;
cout << sizeof(arr) << endl;
bubbleSort(arr);
system("pause");
return 0;
}

复制代码

最佳答案

月排行榜 / 总排行榜

行客

2024-8-11 21:55:38

我先将代码修改完善下，原来的没办法执行：

#include <iostream>
using namespace std;
void doublesort(int arr[]) {
cout << sizeof(arr[0]) << endl;
cout << sizeof(arr) << endl;
cout << arr[8] << endl;
int len_arr = sizeof(arr) / sizeof(arr[0]);
cout << len_arr << endl;
for (int i = 0; i < len_arr ; i++)
{
for (int j = i; j < len_arr - i -1; j++)
{
if (arr[j] > arr[j+1])
{
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
}
int main() {
int arr[10] = { 4,3,6,9,1,2,10,8,7,5 };
cout << sizeof(arr[0]) << endl;
cout << sizeof(arr) << endl;
doublesort(arr);
system("pause");
return 0;
}

复制代码

其他部分应该都好理解，核心是看一下void doublesort(int arr[]) 中的参数int arr[]到底传入的是什么：
数组作函数参数时，C语言标准规定，作为“类型的数组”的形参应该调整为“类型的指针”。在函数形参定义这个特殊情况下，编译器必须把数组形式改写成指向数组第 0 个元素的指针形式。编译器只向函数传递数组的地址，而不是整个数组的拷贝。
在函数内部，arr 会被转换成一个指针变量，编译器为 arr 分配 4 个字节的内存，用 sizeof(arr) 求得的是指针变量的长度，而不是数组长度。要想在函数内部获得数组长度必须额外增加一个参数专门用于传入数组的长度。
参数传递是一次赋值的过程，赋值也是一个表达式，函数调用时不管传递的是数组名还是数组指针，效果都是一样的，相当于给一个指针变量赋值。

C语言之所以把作为形参的数组和指针等同起来是出于效率方面的考虑。数组是若干类型相同的数据的集合，数据的数目没有限制，可能只有几个，也可能成千上万，如果要传递整个数组，无论在时间还是内存空间上的开销都可能非常大。而且绝大部分情况下，我们其实并不需要整个数组的拷贝，我们只想告诉函数在那一时刻对哪个特定的数组感兴趣。

跳转到最佳答案楼层

FishC · 发表于 2023-12-13 23:12:34

因为在main函数中打印的sizeof是整个数组的大小，而在doublesort函数中打印的sizeof是指针的大小。

在main函数中，传递给maopao函数的参数是一个数组，所以打印sizeof(arr)就是整个数组的大小。

而在doublesort函数中，传递给maopao函数的参数是一个指针，这个指针是指向数组的第一个元素的地址。所以打印sizeof(arr)其实是打印指针的大小，即4个字节（在32位系统中）。

如果你想在doublesort函数中打印整个数组的大小，你可以根据数组的元素类型和元素个数来计算。例如，如果数组的元素类型是int，数组的元素个数是n，那么整个数组的大小就是 sizeof(int) * n。你可以将这个值作为参数传递给doublesort函数，并在函数体中打印出来。

下面是示例代码：

#include <iostream>
using namespace std;

void maopao(int arr[], int size) {
cout << "数组的大小是：" << sizeof(int) * size << endl;
// 排序算法的实现
}

int main() {
int arr[] = { 5, 2, 8, 4, 1 };
int size = sizeof(arr) / sizeof(int);
cout << "数组的大小是：" << sizeof(arr) << endl;
maopao(arr, size);

return 0;
}

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

Big-Man · 发表于 2023-12-13 23:32:13

FishC 发表于 2023-12-13 23:12
因为在main函数中打印的sizeof是整个数组的大小，而在doublesort函数中打印的sizeof是指针的大小。

在main ...

maopao函数中的参数传递的是arr，arr代表的是arr数组的首地址，既然是地址为什么在maopao函数接收之后还可以使用arr[0] 这种下标访问的形式

FishC · 发表于 2023-12-13 23:32:28

Big-Man 发表于 2023-12-13 23:32
maopao函数中的参数传递的是arr，arr代表的是arr数组 ...

在C/C++语言中，数组名实际上是一个指向数组首元素的指针。当你将一个数组作为参数传递给函数时，实际上传递给函数的是数组的首地址。所以在maopao函数中，参数arr代表的是数组的首地址。

虽然形参arr是一个指针，但我们仍然可以使用下标访问的方式来操作数组。这是因为C/C++编译器对于指针和数组进行了隐式转换。你可以把arr[i]看作是 *(arr + i)，它根据指针arr和索引i来计算相应元素的地址，并返回该地址处的值。

所以，尽管arr在maopao函数中是一个指针，但使用数组下标的形式可以方便地访问数组中的元素。这样做的好处是能够更直观地操作数组，而不需要手动计算数组元素的地址。

需要注意的是，在使用指针方式访问数组时，要确保不越界访问数组元素，否则可能会导致程序异常或错误的结果。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

某一个“天” · 发表于 2024-8-6 16:13:38

可以把arr[i]看作是 *(arr + i)，它根据指针arr和索引i来计算相应元素的地址，并返回该地址处的值。

行客 · 发表于 2024-8-11 21:55:38

我先将代码修改完善下，原来的没办法执行：

#include <iostream>
using namespace std;
void doublesort(int arr[]) {
cout << sizeof(arr[0]) << endl;
cout << sizeof(arr) << endl;
cout << arr[8] << endl;
int len_arr = sizeof(arr) / sizeof(arr[0]);
cout << len_arr << endl;
for (int i = 0; i < len_arr ; i++)
{
for (int j = i; j < len_arr - i -1; j++)
{
if (arr[j] > arr[j+1])
{
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
}
int main() {
int arr[10] = { 4,3,6,9,1,2,10,8,7,5 };
cout << sizeof(arr[0]) << endl;
cout << sizeof(arr) << endl;
doublesort(arr);
system("pause");
return 0;
}

复制代码

其他部分应该都好理解，核心是看一下void doublesort(int arr[]) 中的参数int arr[]到底传入的是什么：
数组作函数参数时，C语言标准规定，作为“类型的数组”的形参应该调整为“类型的指针”。在函数形参定义这个特殊情况下，编译器必须把数组形式改写成指向数组第 0 个元素的指针形式。编译器只向函数传递数组的地址，而不是整个数组的拷贝。
在函数内部，arr 会被转换成一个指针变量，编译器为 arr 分配 4 个字节的内存，用 sizeof(arr) 求得的是指针变量的长度，而不是数组长度。要想在函数内部获得数组长度必须额外增加一个参数专门用于传入数组的长度。
参数传递是一次赋值的过程，赋值也是一个表达式，函数调用时不管传递的是数组名还是数组指针，效果都是一样的，相当于给一个指针变量赋值。

C语言之所以把作为形参的数组和指针等同起来是出于效率方面的考虑。数组是若干类型相同的数据的集合，数据的数目没有限制，可能只有几个，也可能成千上万，如果要传递整个数组，无论在时间还是内存空间上的开销都可能非常大。而且绝大部分情况下，我们其实并不需要整个数组的拷贝，我们只想告诉函数在那一时刻对哪个特定的数组感兴趣。

行客 · 发表于 2024-8-12 09:34:26

C语言为什么不允许直接传递数组的所有元素，而必须传递数组指针呢？

参数的传递本质上是一次赋值的过程，赋值就是对内存进行拷贝。所谓内存拷贝，是指将一块内存上的数据复制到另一块内存上。

对于像 int、float、char 等基本类型的数据，它们占用的内存往往只有几个字节，对它们进行内存拷贝非常快速。而数组是一系列数据的集合，数据的数量没有限制，可能很少，也可能成千上万，对它们进行内存拷贝有可能是一个漫长的过程，会严重拖慢程序的效率，为了防止技艺不佳的程序员写出低效的代码，C语言没有从语法上支持数据集合的直接赋值。

除了C语言，C++、Java、Python 等其它语言也禁止对大块内存进行拷贝，在底层都使用类似指针的方式来实现。

行客 · 发表于 2024-8-12 09:38:58

C语言标准规定，作为“类型的数组”的形参应该调整为“类型的指针”。在函数形参定义这个特殊情况下，编译器必须把数组形式改写成指向数组第 0 个元素的指针形式。编译器只向函数传递数组的地址，而不是整个数组的拷贝。

这种隐式转换意味着下面三种形式的函数定义是完全等价的：

void func(int *parr){ ...... }
void func(int arr[]){ ...... }
void func(int arr[5]){ ...... }

复制代码

行客 · 发表于 2024-8-12 10:30:37

行客发表于 2024-8-12 09:38
C语言标准规定，作为“类型的数组”的形参应该调整为“类型的指针”。在函数形参定义这个特殊情况下，编译 ...

在函数内部，arr 会被转换成一个指针变量，编译器为 arr 分配 4 个字节的内存，用 sizeof(arr) 求得的是指针变量的长度，而不是数组长度。

账号		自动登录	找回密码
密码			立即注册

[已解决]为什么在main函数中打印的两个sizeof和在doublesort打印的sizeof值不一样呢

马上注册，结交更多好友，享用更多功能^_^

浏览过的版块