C++中理解不太了地址传递中的sizeof

yzhkkxx

#include <iostream>
using namespace std;
#include "inc.h"
void maxmin(int str[],int *maxx,int *minx)
{
        cout << sizeof(str)<<endl;
        for (int a = 0; a < sizeof(str)/sizeof(str[0]); a++)
        {
                if (*minx>str[a])
                {
                        *minx = str[a];
                }
                if (*maxx < str[a])
                {
                        *maxx = str[a];
                }
        }
}
int main()
{
        int aa[10] = {1,2,3,4,5,6,7,8,9,10};
        cout << sizeof(aa)<<endl
                ;
        int a = aa[0];
        int b = aa[0];
        maxmin(aa, &a, &b);
        cout << "最大值为" << a << "最小值为" << b << endl;
        return 0;
}

LEEzeal

本来是过来打卡的，看到新手提问，顺便装个B。（吐个糙，问问题就只要标记核心代码，你贴这么多垃圾代码，没用！）

1. cout << "整个数组所占用的空间：" << sizeof(a) << endl;
   
2. cout << "数组有多少个元素：" << sizeof(a)/ sizeof(a[0]) << endl;
   
3. cout << "数组a的地址指针：" << a << "(0x)\t"<<"十进制表达：" << (int)a <<endl;
   
4. cout << "数组a[0]的地址指针：" << &a[0] << "(0x)\t" << "十进制表达：" << (int)&a[0] << endl;
   
5. cout << "数组a[1]的地址指针：" << &a[1] << "(0x)\t" << "十进制表达：" << (int)&a[1] << endl;
   
6. //数组a的首地址指针和a[0]的地址指针一样。a[1]和a[0]的差值正好是4个Byte。32个bit

复制代码

在32位CPU中，无论是char和int 其指针大小都是4Bytes。而内容只有1Byte和4Bytes。

貌似：
1、你想写一个冒泡算法获得数组的最大和最小值。
2、又想写一个函数避开形参不能改变实参的情况，直接用指针进行数据交换。
我写个简单点的。你参考下。你理解对了我就不考虑了科普了。

1. #include <iostream>
   
2. #include <ctime>
   
3. #include "C_001.h"
   
4. using namespace std;
   
5. int main()
   
6. {
   
7.     int a[] = { 1,2,10,33,62,60,33,16,88,11 ,100,110,120,3};
   
8.     int temp = 0;
   
9.     for (int i = 0; i < (sizeof(a) / sizeof(a[0])); i++)
   
10.     {
    
11.         cout << a[i] << ",";
    
12.     }
    
13.     cout << endl;
    
14.     //FF检测是否进行过内存交换，如没有则直接停止冒泡，输出结果
    
15.     //Fjishu是计数进行过几轮冒泡才完成排序工作
    
16.     int FF = 0;
    
17.     int Fjishu = 0;
    
18.     for (int j = ((sizeof(a) / sizeof(a[0])) - 1); j > 0; j--)
    
19.     {
    
20.         FF = 0;
    
21.         for (int i = ((sizeof(a) / sizeof(a[0])) - 1); i > 0; i--)
    
22.         {
    
23.             if (a[i] < a[i - 1])
    
24.             {
    
25.                 temp = a[i - 1];
    
26.                 a[i - 1] = a[i];
    
27.                 a[i] = temp;
    
28.                 FF = 1;
    
29.             }
    
30.         }
    
31.         Fjishu = Fjishu + 1;
    
32.         if (FF == 0)
    
33.         {
    
34.             break;
    
35.         }
    
36.     }
    
37.     for (int i = 0;i< (sizeof(a) / sizeof(a[0]));i++)
    
38.     {
    
39.         cout << a[i] <<",";
    
40.     }
    
41.     cout << endl << "经过冒泡轮数：" << Fjishu << endl;
    
42.     system("pause");
    
43. }

复制代码

LEEzeal

是你自己的代码把自己搞迷糊了。针对你自己的代码说明下。

1. int main()
   
2. {
   
3.         int aa[10] = {1,2,3,4,5,6,7,8,9,10};
   
4.         cout << sizeof(aa)<<endl; //答这个结果是40，【第一步显示】
   
5. ...
   
6.         maxmin(aa, &a, &b);【第二步】调用你的函数
   
7. ...
   
8.         return 0;
   
9. }

复制代码

你的函数maxmin

1. void maxmin(int str[],int *maxx,int *minx) //【第三步】这里面的int str[]行参进来的只是aa[10]数组的指针
   
2. {
   
3.         cout << sizeof(str)<<endl;//【第四步显示】而这里就是显示数组指针占用字节的大小 4Byte。
   
4.         for (int a = 0; a < sizeof(str)/sizeof(str[0]); a++)//【误区】sizeof(str)/sizeof(str[0])实际结果是1
   
5.         {
   
6.                 ...
   
7.         }
   
8. }

复制代码

解决你疑惑的代码调试更改：

1. #include <iostream>
   
2. #include "inc.h"
   
3. using namespace std;
   
4. 
   
5. void maxmin(int str[], int* maxx, int* minx)
   
6. {
   
7.     cout << "sizeof(str)" << sizeof(str) << endl;
   
8.     for (int a = 0; a < sizeof(str) / sizeof(str[0]); a++)
   
9.     {
   
10.         cout << "sizeof(str) / sizeof(str[0])这个数值：" << sizeof(str) / sizeof(str[0]) << endl;
    
11.     }
    
12. }
    
13. int main()
    
14. {
    
15.     int aa[10] = { 1,2,3,4,5,6,7,8,9,10 };
    
16.     cout <<"sizeof(aa)是多少呢？=" <<sizeof(aa) << endl;
    
17.     int a = aa[0];
    
18.     int b = aa[0];
    
19.     maxmin(aa, &a, &b);
    
20.     system("pause");
    
21. return 0;
    
22. }

复制代码

要解决问题，把你那些垃圾代码删除，然后重点测试自己的疑惑。

LEEzeal

1. #include <ctime>

复制代码

1、这个先忽略吧！本来想写一个绑定时间因子，随机生成一个数组的。怕你看迷糊，还是手打了个数组出来。
2、教科书上多是i++。我写个i--的给你拓展下思维。

yzhkkxx

求各位大佬帮助

yzhkkxx

LEEzeal 发表于 2020-9-1 03:41
本来是过来打卡的，看到新手提问，顺便装个B。（吐个糙，问问题就只要标记核心代码，你贴这么多垃圾代码， ...

首先感谢你的解答。
但是，我想要问的主要问题是指针传递后，我的sizeof（数组）结果很起奇怪，我理解不了我的sizeof（a）/sizeof（a[0]）=1.....

sjn

第一次来，希望得到才来哦啊/谢谢

sjn

第一次来，希望得到才来哦啊/谢谢

he_minghao007

yzhkkxx 发表于 2020-9-1 09:01
首先感谢你的解答。
但是，我想要问的主要问题是指针传递后，我的sizeof（数组）结果很起奇怪，我理解不 ...

把数组首地址作为参数传递，就会退化成指针，sizeof(a)/sizeof(a[0]) 等价于sizeof (int* a) / sizeof (int * (a+0))，两个都是指针，大小都是4，4/4当然等于1啦。还有sizeof是在编译期计算出数组或对象的大小的，它不是函数，不能动态的计算传递的数组的大小，而函数是可以动态调用了，你可以传递10个元素大小的数组，也可以传递20个元素大小的数组，那么，编译期如何能计算出你传的是多少个元素的数组呢？显然这是无法做到的。所以传递给函数的数组都是以指针的形式传递的。指针的大小是固定的。32位大小为4，64位为8

wq123

void maxmin(int str[],int *maxx,int *minx)
/*这里传过来的数组并不是一个数组，而是一个指针。sizeof是用来计算变量或者对象、类型所占字节的多少。sizeof（指针）得到的只是一个4字节的大小，这个大小是指针变量的所占字节的大小。在32位系统上，不管指针p指向的是整型数据，还是字符型数据，short型数据，long型数据等，指针p本身所占的内存字节数均为4。也就是要使用4个字节的大小来存储变量p的值。
*/


如果还解释不清楚你就直接搜sizeof()与strlen的区别网上有解释。

wq123

sizeof（）得到的是所占空间大小。