本文我们来讲讲C语言中的易混淆的指针数组与数组指针✒
文章目录
首先我想问你一个问题：指针数组是一个指针还是一个数组呢？
数组，而不是指针int arr1[5]; //整型数组 - 存放整数的数组
char arr2[5]; //字符数组 - 存放字符的数组
int* arr3[5]; //指针数组 - 存放指针的数组
arr1，他是一个整型数组，它里面存放的都是整数；arr2，他是一个字符数组，它里面存放的都是字符；arr3，他是一个指针数组，它里面存放的都是指针；下面两个模块我将带你来回顾一下数组中的相关知识
arr[0]来访问太累了，不妨我们将数组的首元素地址给到一个指针变量，让它保存下这个地址，然后让它逐步地向后移动。如果对指针还不是很了解的看看这篇文章——> 底层之美，莫过于C【1024，从0开始】先去了解一下什么是指针int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
int* p = &arr[0];
p指针第一个元素所在的地址，那么p + 1便是指向2所在元素的地址，那要访问到这个地址上所在的内容，那就要使用到*这个符号，对这块地址进行解引用*(p + 1)，此时就可以访问到2这个元素了。那找3，找4也是一样的，只需要让这个指针向后偏移即可，所以我们可以通过循环去找，访问第i个元素便是*(p + i)for (int i = 0; i < 10; ++i)
{
printf("%p == %p\n", p + i, &arr[i]);
}
printf("\n");
p + i还是&arr[i]，它们每次所访问的地址都是一样的，这其实也就意味着指针变量p在偏移的过程中相当于在代替数组首元素地址向后偏移有了这些知识作为铺垫，我们就可以去尝试访问数组中的所有内容了
因为一维数组是一块连续的存储空间，所以我们只要得到这个数组的首元素地址。就可以通过p + i这样的方式找到它之后所有元素的地址，并且把他们地址进行解引用便能访问到数组中的所有元素
int main(void)
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
int* p = &arr[0];
for (int i = 0; i < 10; ++i)
{
printf("%d ", *(p + i));
}
printf("\n");
return 0;
}
p + i，而当我们要去访问这个地址的内容时，直接对其进行解引用即可*(p + i)，然后便可以看到数组中的十个元素都被打印出来了int* p = &arr[0]便可以写成int* p = arr，Ctrl + F5让代码走起来可以看到结果也是一样的
arr和p也就是一回事，那也可以说【arr <==> p】，所以我们在使用到arr的地方可以换成p，使用到p的地方可以换成arr
arr[i]，那此时是不是可以将arr[i]和*(arr + i)做一个联系呢？当然是可以的😄[]是一个数组访问的操作符，那既然是操作符的话就会有操作数，操作数是谁呢？就是【arr】和【i】，那此时当我将arr[i]转换成*(arr + i)的时候，()里面的也就是这两个操作数，根据加法的交换律就可以将【arr】和【i】进行一个交换，那也就变成了*(i + arr)。*(arr +i)可以写成arr[i] <—— ⭐*(i + arr)是否可以写成i[arr]呢 <——⭐此时我们通过代码来尝试一下，将推测转化为实际
arr和p其实是一回事，那可以写【arr[i]】，是不是也可以写成【p[i]】呢？答案是：当然可以！
看完上面的这些，相信你已经晕了(((φ(◎ロ◎;)φ)))，不过没有关系，将知识点做个总结就可以很清晰了
arr[i] == *(arr + i) == *(p + i) == p[i]
回顾了数组的相关知识后，再来看【指针数组】相关内容，就变得易如反掌✋
[指针接受地址]这个概念int main(void)
{
int a = 1;
int b = 2;
int c = 3;
int d = 4;
int e = 5;
int* arr[5] = { &a, &b, &c, &d, &e };
for (int i = 0; i < 5; ++i)
{
printf("%d ", *(arr[i]));
}
printf("\n");
return 0;
}
[解引用]这个知识点，我说到指针其实就是地址，那对地址进行一个解引用其实可以将[*]和[&]进行一个抵消，这也就取到了五个变量的地址，通过下标i控制就遍历到了这五个变量
数组名即为首元素地址，所以这是合法的int arr1[5] = { 1, 1, 1, 1, 1 };
int arr2[5] = { 2, 2, 2, 2, 2 };
int arr3[5] = { 3, 3, 3, 3, 3 };
int* parr[3] = { arr1, arr2, arr3 };
for (int i = 0; i < 3; ++i)
{
for (int j = 0; j < 5; ++j)
{
printf("%d ", *(parr[i] + j));
}
printf("\n");
}
parr[i] + j也就是位于每个数组的首地址向后偏移j个位置，所以访问到的就是下标为j这个位置的地址，但是我们要访问值的话就要加上一个解引用的操作。当然，通过【*】和【()】的规则我们也可以将*(parr[i] + j)转换为*(*(parr + i) + j)或者是parr[i][j]
在学习了【指针数组】后，来辨析一下三个数组吧
int* arr1[10];
char* arr2[4];
char** arr3[5];
int*的整型指针char*的字符指针cahr**的二级字符指针讲完指针数组后，我们就来讲讲它的双胞胎兄弟 —— 【数组指针】
💬首先还是这个问题，数组指针是指针？还是数组？
int a = 10;
char ch = 'x';
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
int* pa = &a; —— 整型指针 - 存放整型地址的指针
char* pc = &ch; —— 字符指针 - 存放字符地址的指针
int(*parr)[10] = &arr; —— 数组指针 - 存放数组地址的指针
pa，它是一个整型指针，里面存放的是一个整型的地址pc，它是一个字符型指针，里面存放的是一个字符的地址parr，它是一个数组指针，里面存放的是一个数组的地址然后就来仔细介绍一下数组指针
int类型。那现在我要将这个数组的地址存起来，那肯定需要一个指针来接收，那既然是一个指针的话我们肯定会想要用*做修饰，不过这还不够，因为接收的是一个数组的地址，所以我们还会想要再加上[10]，而且这个10还不能像我们定义数组的可以省略调用，一定要加上[]的优先级是最高的，所以这个【pa】会首先和[]结合，而不是先和*，那么它就是一个数组，而不是指针了！int arr[5] = { 1,2,3,4,5 };
int* pa[10] = &arr;
*先结合的话，在它们的外面加上一个()即可，如下所示👇int (*pa)[10] = &arr;
这才是一个完整又正确的【数组指针】
对于数组名是首元素地址这个说法我们已经是耳熟于心了，不过上面看到了一个新的写法
&数组名，这和数组名存在着什么关联呢？本模块我们就来探讨一下这个
int arr[5] = { 1,2,3,4,5 };
printf("%p\n", arr);
printf("%p\n", &arr[0]);
printf("%p\n", &arr);
但是从运行结果可以看到它们都是一样的，这是为什么呢？
&数组名值得是取出整个数组的地址，而&arr[0]则是数组首元素的地址。不过从下图可以看，它们的位置是一样的，所以打印出来的地址就是一样的
💬那有同学说：难道它们就完全相同吗，那&数组名还有什么意义呢？
printf("%p\n", arr);
printf("%p\n", arr + 1);
puts("---------------");
printf("%p\n", &arr[0]);
printf("%p\n", &arr[0] + 1);
puts("---------------");
printf("%p\n", &arr);
printf("%p\n", &arr + 1);
puts("---------------");
可以看到，最后一个&数组名和上面两个的结果不同
arr和&arr[0]都一样，取到的是首元素的地址，这是一个整型数组，首元素是一个int类型的数据，那么其地址就是int*类型，那在【指针初阶部分】我有讲到过一个int*的指针一次可以访问4个字节的大小，那在这数组中每个元素都占4个字节，所以 + 1就会跳过一个元素也就是4个字节&arr来说，取出的是整个数组的大小，虽然它的位置和首元素地址是一样的，但是它 + 1跳过的确是整个数组的大小，上面说到过一个数组的地址给到【数组指针】来接收int (*parr)[5] = &arr;，此时去掉它的变量名后这个指针的类型就是int(*)[10]，上面我们也有讲过一个指针一次可以访问的字节取决于它的类型具体可以看看这张图👇
💬在知晓了这一点后许多同学就明白了这个地址的偏移为何是这样，但是仔细一算好像也不对呀，整个数组所占的字节数不是20吗，这里是14呀？
讲了这么多后，这个数组指针到底有什么用呢？
1.数组指针在一维数组的使用场景
void print1(int arr[], int n)
{
int i = 0;
for (i = 0; i < n; ++i)
{
printf("%d ", arr[i]);
}
printf("\n");
}
void print2(int* arr, int n)
{
int i = 0;
for (i = 0; i < n; ++i)
{
printf("%d ", arr[i]);
}
printf("\n");
}
print1(a, sz);
print2(a, sz);
void print3(int (*p)[5], int n)
{
int i = 0;
for (i = 0; i < n; ++i)
{
printf("%d ", (*p)[i]); //a[i]
}
}
*p也就取到了这个一维数组的数组名，那我们平常用数组名来访问数组中的每个元素时，都是用的arr[i]这样的形式，那么用解引用后的数组指针来访问就可以写成(*p)[i]print3(&a, sz);
💬但这样不是很别扭吗？传进来数组的地址，然后再解引用获取到数组名，还不如直接传递数组名呢🤨
2.数组指针在二维数组的使用场景
void print4(int arr[3][5], int row, int col)
{
int i = 0;
for (i = 0; i < row; i++)
{
int j = 0;
for (j = 0; j < col; j++)
{
printf("%d ", arr[i][j]);
}
printf("\n");
}
}
int a[3][5] = { {1,2,3,4,5}, {2,3,4,5,6}, {3,4,5,6,7} };
print4(a, 3, 5);
void print5(int (*p)[5], int row, int col)
{
int i = 0;
for (i = 0; i < row; i++)
{
int j = 0;
for (j = 0; j < col; j++)
{
printf("%d ", *(*(p + i) + j));
}
printf("\n");
}
}
p接收到的即为第一行的地址。对于二维数组把每一行看做是一个元素，那么对于这个数组来说三行就有三个元素，那么要如何访问到每一行呢？那就是使用p + i，随着【i】的不断变化就可以取到每一行的地址*(p + i)也就拿到了当前的这一行的数组名，假设现在要访问第一行，那它的数组名那就是a[0]，或者是*(a + 0)，以此类推后面的几行数组名就是a[1]、a[2]。那数组名我们知道，意味着首元素地址，现在先访问第一行中的每个元素，那么首先拿到的就是【1】的地址，那要访问到后面的每一个元素首先要对地址进行一个偏移，*(p + i) + j就可以拿到每个元素的地址，那此时就简单了，再解引用*(*(p + i) + j)也就取到了当前行中的每个元素，根据数组名和指针的转换规则，即为p[i][j]
来看一下运行结果
在学习了【指针数组】和【数组指针】后，来看一下这四个指针 or 数组？
int arr[5];
int *parr1[10];
int (*parr2)[10];
int (*parr3[10])[5];
[]结合，表明它是是一个数组，数组有五个元素，每个元素都是int类型的，说明这是一个一维数组[]结合，表明它是一个数组，数组的每个元素都是一个int类型的指针，说明这是一个指针数组*结合，表明它是一个指针，然后往后一看，它指向一个数组，该数组有10个元素，每个元素都是int类型，说明这是一个数组指针[]结合，表明它是一个数组，数组有十个元素，把parr3[10]去掉后就可以看出它的类型，是int(*)[5]，说明数组中存放着的都是数组指针，每个数组指针都指向一个存有5个元素，每个元素都是int类型的数组。最后我们判定其为数组指针数组第四个的图示如下：
相信有很多同学对于数组传参、指针传参都是搞的稀里糊涂的
代码：
/*一维数组传参*/
void test(int arr[]) //ok?
{}
void test(int arr[10]) //ok?
{}
void test(int* arr) //ok?
{}
int main()
{
int arr[10] = { 0 };
test(arr);
}
解析：
arr[]接收这是我们最常见的，没有问题✔[]里加上了一个10，不过我们知道对于一维数组里面的数组大小声明是可以省略的，所以没有关系*arr的方式进行接收，那传递进来的arr为数组名，数组名是首元素地址，那给到一个指针作为接收也没什么问题代码：
void test2(int* arr[20]) //ok?
{}
void test2(int** arr) //ok?
{}
int main()
{
int* arr2[20] = { 0 };
test2(arr2);
}
解析：
* arr[20]合情合理 ✔** arr是都可以呢？这点我们可以通过画图来分析，因为arr2是一个指针数组，而且里面存放的每个元素都是int类型的， 那我们传递【指针数组】的数组名过去的话，那其实就是首元素地址，即这个一级指针int*的地址，那么形参部分使用二级指针来接收也是正确的 ✔
总结：
最后总结一下一维数组传参形参可以是哪些内容
代码：
/*二维数组传参*/
void test(int arr[3][5])//ok？
{}
void test(int arr[][])//ok？
{}
void test(int arr[][5])//ok？
{}
int main()
{
int arr[3][5] = { 0 };
test(arr);
}
解析：
[]的数组，但是指明了列的个数，就没有关系 ✔代码：
void test2(int* arr)//ok？
{}
void test2(int* arr[5])//ok？
{}
void test2(int(*arr)[5])//ok？
{}
void test2(int** arr)//ok？
{}
int main()
{
int arr[3][5] = { 0 };
test2(arr);
}
解析：
int* arr[5]可以吗？首先你要分析看它是个什么，我们传递过来的是一个地址，那地址就要使用指针来进行接收，但是可以看到这很明显是一个指针数组，因为arr和[]先结合了，所以也是错误的❌总结：
最后总结一下二维数组传参形参可以是哪些内容
代码：
void print(int* p, int sz)
{
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%d\n", *(p + i));
}
}
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9 };
int* p = arr;
int sz = sizeof(arr) / sizeof(arr[0]);
//一级指针p，传给函数
print(p, sz);
return 0;
}
解析：
思考：
当一个函数的参数部分为一级指针的时候，函数能接收什么参数？
代码：
void test(int** ptr)
{
printf("num = %d\n", **ptr);
}
int main()
{
int n = 10;
int* p = &n;
int** pp = &p;
test(pp);
test(&p);
return 0;
}
解析：
思考：
当一个函数的参数部分为二级指针的时候，函数能接收什么参数？
最后来总结一下本文呢指针数组与数组指针
int* arr[10]int (*p)[10]
我有多个ActiveRecord子类Item的实例数组，我需要根据最早的事件循环打印。在这种情况下，我需要打印付款和维护日期，如下所示:ItemAmaintenancerequiredin5daysItemBpaymentrequiredin6daysItemApaymentrequiredin7daysItemBmaintenancerequiredin8days我目前有两个查询，用于查找maintenance和payment项目(非排他性查询)，并输出如下内容:paymentrequiredin...maintenancerequiredin...有什么方法可以改善上述(丑陋的)代
我的代码目前看起来像这样numbers=[1,2,3,4,5]defpop_threepop=[]3.times{pop有没有办法在一行中完成pop_three方法中的内容？我基本上想做类似numbers.slice(0,3)的事情，但要删除切片中的数组项。嗯...嗯，我想我刚刚意识到我可以试试slice! 最佳答案 是numbers.pop(3)或者numbers.shift(3)如果你想要另一边。 关于ruby-多次弹出/移动ruby数组，我们在StackOverflow上找到一
我需要读入一个包含数字列表的文件。此代码读取文件并将其放入二维数组中。现在我需要获取数组中所有数字的平均值，但我需要将数组的内容更改为int。有什么想法可以将to_i方法放在哪里吗？ClassTerraindefinitializefile_name@input=IO.readlines(file_name)#readinfile@size=@input[0].to_i@land=[@size]x=1whilex 最佳答案 只需将数组映射为整数:@land边注如果你想得到一条线的平均值，你可以这样做:values=@input[x]
我正在使用puppet为ruby程序提供一组常量。我需要提供一组主机名，我的程序将对其进行迭代。在我之前使用的bash脚本中，我只是将它作为一个puppet变量hosts=>"host1,host2"我将其提供给bash脚本作为HOSTS=显然这对ruby不太适用——我需要它的格式hosts=["host1","host2"]自从phosts和putsmy_array.inspect提供输出["host1","host2"]我希望使用其中之一。不幸的是，我终其一生都无法弄清楚如何让它发挥作用。我尝试了以下各项:我发现某处他们指出我需要在函数调用前放置“function_”……这
这个问题在这里已经有了答案:Checktoseeifanarrayisalreadysorted?(8个答案)关闭9年前。我只是想知道是否有办法检查数组是否在增加？这是我的解决方案，但我正在寻找更漂亮的方法:n=-1@arr.flatten.each{|e|returnfalseife
我有一个这样的哈希数组:[{:foo=>2,:date=>Sat,01Sep2014},{:foo2=>2,:date=>Sat,02Sep2014},{:foo3=>3,:date=>Sat,01Sep2014},{:foo4=>4,:date=>Sat,03Sep2014},{:foo5=>5,:date=>Sat,02Sep2014}]如果:date相同，我想合并哈希值。我对上面数组的期望是:[{:foo=>2,:foo3=>3,:date=>Sat,01Sep2014},{:foo2=>2,:foo5=>5:date=>Sat,02Sep2014},{:foo4=>4,:dat
我正在尝试在Ruby中制作一个cli应用程序，它接受一个给定的数组，然后将其显示为一个列表，我可以使用箭头键浏览它。我觉得我已经在Ruby中看到一个库已经这样做了，但我记不起它的名字了。我正在尝试对soundcloud2000中的代码进行逆向工程做类似的事情，但他的代码与SoundcloudAPI的使用紧密耦合。我知道cursesgem，我正在考虑更抽象的东西。广告有没有人见过可以做到这一点的库或一些概念证明的Ruby代码可以做到这一点？ 最佳答案 我不知道这是否是您正在寻找的，但也许您可以使用我的想法。由于我没有关于您要完成的工作
我使用Ember作为我的前端和GrapeAPI来为我的API提供服务。前端发送类似:{"service"=>{"name"=>"Name","duration"=>"30","user"=>nil,"organization"=>"org","category"=>nil,"description"=>"description","disabled"=>true,"color"=>nil,"availabilities"=>[{"day"=>"Saturday","enabled"=>false,"timeSlots"=>[{"startAt"=>"09:00AM","endAt"=>
我正在尝试按0-9和a-z的顺序创建数字和字母列表。我有一组值value_array=['0','1','2','3','4','5','6','7','8','9','a','b'，'光盘'，'e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','','u','v','w','x','y','z']和一个组合列表的数组，按顺序，这些数字可以产生x个字符，比方说三个list_array=[]和一个当前字母和数字组合的数组(在将它插入列表数组之前我会把它变成一个字符串，]current_combo['0','0','0']
查看我的Ruby代码:h=Hash.new([])h[0]=:word1h[1]=h[1]输出是:Hash={0=>:word1,1=>[:word2,:word3],2=>[:word2,:word3]}我希望有Hash={0=>:word1,1=>[:word2],2=>[:word3]}为什么要附加第二个哈希元素(数组)？如何将新数组元素附加到第三个哈希元素？ 最佳答案 如果您提供单个值作为Hash.new的参数(例如Hash.new([])，完全相同的对象将用作每个缺失键的默认值。这就是您所拥有的，那是你不想要的。您可以改用