C语言小白问题

[whyseu]

char * s[3]={"1","2","3"};
char * a;
a=*s;
int i;
for(i=0;i<4;i++){
printf("%s\n",*((&a)+i));
printf("%d\n",((&a)+i));
}
为何打印出来的是1,1,2,3？

[Votangroom]

楼上正解，顶

[自信男孩]

printf("%s\n",*((&a)+i));

这句打印出来的是1,2,3；最后一个越界访问了。

printf("%d\n",((&a)+i));

这句打印的是地址值，地址值一般用%p或%x打印

[自信男孩]

引用 4 楼 zangfong 的回复:

不是什么野指针，是没有搞清楚变量在物理内存中的实际位置。按照你的代码，实际上指针变量a以及,s[0],s[1],s[2],s[3]是相邻存放的，一般来说（至少在我的电脑上是这样），先定义的变量存放于高地址，后定义的变量存放于低地址。然后你又有一个a=*s;操作，于是a指针与s[0]指针所指向的地址相等。于是这4个变量在内存中的物理位置，以及对应指针所指向的地址和字符串关系如下图：
然后你的for循环中，当i = 0时，取的实际上是a的地址，自然在我电脑中显示的就是“6356732”，读取的内容，当然指向的就是字符串“1”，后面的理解就简单了：
i=1；根据上图也可以发现，实际上(&a)+i所取出的地址是“6356736”，读取的内容，就是s[0]指向的字符串“1”；
i=2；根据上图也可以发现，实际上(&a)+i所取出的地址是“6356740”，读取的内容，就是s[0]指向的字符串“2”；
i=3；根据上图也可以发现，实际上(&a)+i所取出的地址是“6356744”，读取的内容，就是s[0]指向的字符串“3”；
所以才显示结果为1,1,2,3
参考程序如下

#include<stdio.h>

int main()
{

    char * s[3]= {"1","2","3"};
    char * a;
    a=*s;
    int i=0;
    printf("常量字符串\"1\"的地址：%d\n",&"1");
    printf("常量字符串\"2\"的地址：%d\n",&"2");
    printf("常量字符串\"3\"的地址：%d\n",&"3");
    printf("指针a   的物理地址:%d, 指向的内存地址:%d\n",&a,a);
    printf("指针s[0]的物理地址:%d, 指向的内存地址:%d\n",s,*s);
    printf("指针s[1]的物理地址:%d, 指向的内存地址:%d\n",s+1,*(s+1));
    printf("指针s[2]的物理地址:%d, 指向的内存地址:%d\n",s+2,*(s+2));
    for(i=0; i<4; i++)
    {
        printf("%s\n",*((&a)+i));
        printf("%d\n",((&a)+i));
    }

    return 0;
}

结果如下图：


再者，如果你的代码中将char *s[3]和char *a的定义的先后顺序换一下（像下面这样），你可以自己试一下，这样就挂了，真的是野指针了。

    char * a;
    char * s[3]= {"1","2","3"};

越界了可以确定，但不是野指针。

[zangfong]

恩，你说得对，的确是越界的，应该也是野指针了，只不过恰好访问到了S，没出错而已。是我想错了，不好意思，呵呵

引用 8 楼 cfjtaishan 的回复:

[quote=引用 4 楼 zangfong 的回复:]
不是什么野指针，是没有搞清楚变量在物理内存中的实际位置。按照你的代码，实际上指针变量a以及,s[0],s[1],s[2],s[3]是相邻存放的，一般来说（至少在我的电脑上是这样），先定义的变量存放于高地址，后定义的变量存放于低地址。然后你又有一个a=*s;操作，于是a指针与s[0]指针所指向的地址相等。于是这4个变量在内存中的物理位置，以及对应指针所指向的地址和字符串关系如下图：
然后你的for循环中，当i = 0时，取的实际上是a的地址，自然在我电脑中显示的就是“6356732”，读取的内容，当然指向的就是字符串“1”，后面的理解就简单了：
i=1；根据上图也可以发现，实际上(&a)+i所取出的地址是“6356736”，读取的内容，就是s[0]指向的字符串“1”；
i=2；根据上图也可以发现，实际上(&a)+i所取出的地址是“6356740”，读取的内容，就是s[0]指向的字符串“2”；
i=3；根据上图也可以发现，实际上(&a)+i所取出的地址是“6356744”，读取的内容，就是s[0]指向的字符串“3”；
所以才显示结果为1,1,2,3
参考程序如下

#include<stdio.h>

int main()
{

    char * s[3]= {"1","2","3"};
    char * a;
    a=*s;
    int i=0;
    printf("常量字符串\"1\"的地址：%d\n",&"1");
    printf("常量字符串\"2\"的地址：%d\n",&"2");
    printf("常量字符串\"3\"的地址：%d\n",&"3");
    printf("指针a   的物理地址:%d, 指向的内存地址:%d\n",&a,a);
    printf("指针s[0]的物理地址:%d, 指向的内存地址:%d\n",s,*s);
    printf("指针s[1]的物理地址:%d, 指向的内存地址:%d\n",s+1,*(s+1));
    printf("指针s[2]的物理地址:%d, 指向的内存地址:%d\n",s+2,*(s+2));
    for(i=0; i<4; i++)
    {
        printf("%s\n",*((&a)+i));
        printf("%d\n",((&a)+i));
    }

    return 0;
}

结果如下图：


再者，如果你的代码中将char *s[3]和char *a的定义的先后顺序换一下（像下面这样），你可以自己试一下，这样就挂了，真的是野指针了。

    char * a;
    char * s[3]= {"1","2","3"};

越界了可以确定，但不是野指针。[/quote]

引用 8 楼 cfjtaishan 的回复:

[quote=引用 4 楼 zangfong 的回复:]
不是什么野指针，是没有搞清楚变量在物理内存中的实际位置。按照你的代码，实际上指针变量a以及,s[0],s[1],s[2],s[3]是相邻存放的，一般来说（至少在我的电脑上是这样），先定义的变量存放于高地址，后定义的变量存放于低地址。然后你又有一个a=*s;操作，于是a指针与s[0]指针所指向的地址相等。于是这4个变量在内存中的物理位置，以及对应指针所指向的地址和字符串关系如下图：
然后你的for循环中，当i = 0时，取的实际上是a的地址，自然在我电脑中显示的就是“6356732”，读取的内容，当然指向的就是字符串“1”，后面的理解就简单了：
i=1；根据上图也可以发现，实际上(&a)+i所取出的地址是“6356736”，读取的内容，就是s[0]指向的字符串“1”；
i=2；根据上图也可以发现，实际上(&a)+i所取出的地址是“6356740”，读取的内容，就是s[0]指向的字符串“2”；
i=3；根据上图也可以发现，实际上(&a)+i所取出的地址是“6356744”，读取的内容，就是s[0]指向的字符串“3”；
所以才显示结果为1,1,2,3
参考程序如下

#include<stdio.h>

int main()
{

    char * s[3]= {"1","2","3"};
    char * a;
    a=*s;
    int i=0;
    printf("常量字符串\"1\"的地址：%d\n",&"1");
    printf("常量字符串\"2\"的地址：%d\n",&"2");
    printf("常量字符串\"3\"的地址：%d\n",&"3");
    printf("指针a   的物理地址:%d, 指向的内存地址:%d\n",&a,a);
    printf("指针s[0]的物理地址:%d, 指向的内存地址:%d\n",s,*s);
    printf("指针s[1]的物理地址:%d, 指向的内存地址:%d\n",s+1,*(s+1));
    printf("指针s[2]的物理地址:%d, 指向的内存地址:%d\n",s+2,*(s+2));
    for(i=0; i<4; i++)
    {
        printf("%s\n",*((&a)+i));
        printf("%d\n",((&a)+i));
    }

    return 0;
}

结果如下图：


再者，如果你的代码中将char *s[3]和char *a的定义的先后顺序换一下（像下面这样），你可以自己试一下，这样就挂了，真的是野指针了。

    char * a;
    char * s[3]= {"1","2","3"};

越界了可以确定，但不是野指针。[/quote]

[自信男孩]

所谓”野指针“，即不确定的地址，即定义了一个指针，但是没有让这个指针指向一个确定的内存位置，此时该指针里存放的是一个随机值（随机地址），所以叫做野指针。

[636f6c696e]

申明三个数
非要打四数
闲得蛋疼

楼主的语法一窍不通，建议不要钻牛角尖了

[NexTor]

打印出1,1,2,3其实是巧合，(&a)+1这个用法取到的不是s[3]数组中的值，这么用会越界，而刚好越界后访问的地址正是s[3]的地址，所以第一个1是正确的，后面的1,2,3其实是(&a)+1后越界操作到s，所以打印出来的，你在char * s[3]={"1","2","3"};后面不要跟char* a;
char * s[3]={"1a","2b","3c"};
char * c = "ddd";
char * a;
肯定打印出来的有ddd
如果加上int b[] = {1,2,3}，肯定崩了。

[zhongchengli]

越界了，野指针

[zangfong]

不是什么野指针，是没有搞清楚变量在物理内存中的实际位置。按照你的代码，实际上指针变量a以及,s[0],s[1],s[2],s[3]是相邻存放的，一般来说（至少在我的电脑上是这样），先定义的变量存放于高地址，后定义的变量存放于低地址。然后你又有一个a=*s;操作，于是a指针与s[0]指针所指向的地址相等。于是这4个变量在内存中的物理位置，以及对应指针所指向的地址和字符串关系如下图：
然后你的for循环中，当i = 0时，取的实际上是a的地址，自然在我电脑中显示的就是“6356732”，读取的内容，当然指向的就是字符串“1”，后面的理解就简单了：
i=1；根据上图也可以发现，实际上(&a)+i所取出的地址是“6356736”，读取的内容，就是s[0]指向的字符串“1”；
i=2；根据上图也可以发现，实际上(&a)+i所取出的地址是“6356740”，读取的内容，就是s[0]指向的字符串“2”；
i=3；根据上图也可以发现，实际上(&a)+i所取出的地址是“6356744”，读取的内容，就是s[0]指向的字符串“3”；
所以才显示结果为1,1,2,3
参考程序如下

#include<stdio.h>

int main()
{

    char * s[3]= {"1","2","3"};
    char * a;
    a=*s;
    int i=0;
    printf("常量字符串\"1\"的地址：%d\n",&"1");
    printf("常量字符串\"2\"的地址：%d\n",&"2");
    printf("常量字符串\"3\"的地址：%d\n",&"3");
    printf("指针a   的物理地址:%d, 指向的内存地址:%d\n",&a,a);
    printf("指针s[0]的物理地址:%d, 指向的内存地址:%d\n",s,*s);
    printf("指针s[1]的物理地址:%d, 指向的内存地址:%d\n",s+1,*(s+1));
    printf("指针s[2]的物理地址:%d, 指向的内存地址:%d\n",s+2,*(s+2));
    for(i=0; i<4; i++)
    {
        printf("%s\n",*((&a)+i));
        printf("%d\n",((&a)+i));
    }

    return 0;
}

结果如下图：


再者，如果你的代码中将char *s[3]和char *a的定义的先后顺序换一下（像下面这样），你可以自己试一下，这样就挂了，真的是野指针了。

    char * a;
    char * s[3]= {"1","2","3"};

[zangfong]

不好意思，复制粘贴了一下，这里对应的应该是s[0],s[1],s[2]
然后你的for循环中，当i = 0时，取的实际上是a的地址，自然在我电脑中显示的就是“6356732”，读取的内容，当然指向的就是字符串“1”，后面的理解就简单了：
i=1；根据上图也可以发现，实际上(&a)+i所取出的地址是“6356736”，读取的内容，就是s[0]指向的字符串“1”；
i=2；根据上图也可以发现，实际上(&a)+i所取出的地址是“6356740”，读取的内容，就是s[1]指向的字符串“2”；
i=3；根据上图也可以发现，实际上(&a)+i所取出的地址是“6356744”，读取的内容，就是s[2]指向的字符串“3”；

引用 4 楼 zangfong 的回复:

[棉猴]

1、数组s有3个元素，所以在for循环时应改为

for(i=0;i<3;i++){
}

2、程序的目的是输出数组s的三个元素，以及3个元素的内容。可以考虑修改为

printf("%s\n", ((a) + i*sizeof(char*)));
		printf("%p\n", ((a)+i * sizeof(char*)));

其中，a表示数组s的第一个元素即字符串“1”的地址；而s的第二个元素的地址并不是a+1，而是a+sizeof(char*)，因为一个地址的大小是4个字节。
3、使用printf()函数输出地址时，使用参数%p
4、VS2015调试通过，输出如下

可以看出，每个字符的地址相差4个字节

[赵4老师]

理解和讨论之前请先学会如何观察！

计算机组成原理→DOS命令→汇编语言→C语言（不包括C++）、代码书写规范→数据结构、编译原理、操作系统→计算机网络、数据库原理、正则表达式→其它语言（包括C++）、架构……

对学习编程者的忠告：
多用小脑和手，少用大脑、眼睛和嘴，会更快地学会编程！
眼过千遍不如手过一遍！
书看千行不如手敲一行！
手敲千行不如单步一行！
单步源代码千行不如单步Debug版对应汇编一行！
单步Debug版对应汇编千行不如单步Release版对应汇编一行！
不会单步Release版对应汇编？在你想单步Release版C/C++代码片断的前面临时加一句DebugBreak();重建所有，然后在IDE中运行。（一般人我不告诉他！）

VC调试时按Alt+8、Alt+7、Alt+6和Alt+5,打开汇编窗口、堆栈窗口、内存窗口和寄存器窗口看每句C对应的汇编、单步执行并观察相应堆栈、内存和寄存器变化，这样过一遍不就啥都明白了吗。
对VC来说，所谓‘调试时’就是编译连接通过以后，按F10或F11键单步执行一步以后的时候，或者在某行按F9设了断点后按F5执行停在该断点处的时候。
（Turbo C或Borland C用Turbo Debugger调试,Linux或Unix下用GDB调试时,看每句C对应的汇编并单步执行观察相应内存和寄存器变化。）

想要从本质上理解C指针，必须学习汇编以及C和汇编的对应关系。
从汇编的角度理解和学习C语言的指针，原本看似复杂的东西就会变得非常简单！
指针即地址。“地址又是啥？”“只能从汇编语言和计算机组成原理的角度去解释了。”
但我又不得不承认：
有那么些人喜欢或者适合用“先具体再抽象”的方法学习和理解复杂事物；
而另一些人喜欢或者适合用“先抽象再具体”的方法学习和理解复杂事物。
而我本人属前者。

不要企图依赖输出指针相关表达式...的值【比如printf("%p\n",...);或者cout<<...】来理解指针的本质，
而要依赖调试时的反汇编窗口中的C/C++代码【比如void *p=(void *)(...);】及其对应汇编指令以及内存窗口中的内存地址和内存值来理解指针的本质。

这辈子不看内存地址和内存值；只画链表、指针示意图，画堆栈示意图，画各种示意图，甚至自己没画过而只看过书上的图……能从本质上理解指针、理解函数参数传递吗？本人深表怀疑！
这辈子不种麦不收麦不将麦粒拿去磨面；只吃馒头、吃面条、吃面包、……甚至从没看过别人怎么蒸馒头，压面条，烤面包，……能从本质上理解面粉、理解面食吗？本人深表怀疑！！

提醒：
“学习用汇编语言写程序”
和
“VC调试(TC或BC用TD调试)时按Alt+8、Alt+7、Alt+6和Alt+5,打开汇编窗口、堆栈窗口、内存窗口和寄存器窗口看每句C对应的汇编、单步执行并观察相应堆栈、内存和寄存器变化，这样过一遍不就啥都明白了吗。
（Linux或Unix下可以在用GDB调试时,看每句C对应的汇编并单步执行观察相应内存和寄存器变化。）
想要从本质上理解C指针，必须学习C和汇编的对应关系。”
不是一回事！

不要迷信书、考题、老师、回帖；
要迷信CPU、编译器、调试器、运行结果。
并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。
任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！

有人说一套做一套，你相信他说的还是相信他做的？
其实严格来说这个世界上古往今来所有人都是说一套做一套，不是吗？

不要写连自己也预测不了结果的代码！

电脑内存或文件内容或传输内容只是一个一维二进制字节数组及其对应的二进制地址；
人脑才将电脑内存或文件内容或传输内容中的这个一维二进制字节数组及其对应的二进制地址的某些部分看成是整数、有符号数/无符号数、浮点数、复数、英文字母、阿拉伯数字、中文/韩文/法文……字符/字符串、汇编指令、函数、函数参数、堆、栈、数组、指针、数组指针、指针数组、数组的数组、指针的指针、二维数组、字符点阵、字符笔画的坐标、黑白二值图片、灰度图片、彩色图片、录音、视频、指纹信息、身份证信息……

十字链表交换任意两个节点C源代码（C指针应用终极挑战）http://download.csdn.net/detail/zhao4zhong1/5532495

http://edu.csdn.net/course/detail/2344 C语言指针与汇编内存地址-一.代码要素

[林多]

首选，换顺序是不会挂的（g++5.4)，某些编译器会根据字节对齐等等概念，做优化的：
char * a;
char * s[3]= {"1","2","3"};

比较简单易懂的解释，一句话指针不等于数组首地址。

看下面的程序
char* arrayInt[3] = {xxxxx};
char* ptr = NULL;
ptr = *arrayInt;
// 这里就是不一样的了。
printf("%d", sizeof(prt)); // 8 (64位机器）
printf("%d", sizeof(arrayInt)); // 24 (64位机器）

// 仅仅是指针+1，偏移的地址为（当前指针的地址+ （类型size*1））
// 注意：是指针的地址，不是指针指向内容的地址。
ptr+1;

// 数组首地址+1，相当于从移动到 arrayInt[1]的地址。 这两者的概念，是不一样的！
arrayInt + 1

// 所以，当把数组首地址赋给一个指针后，不要认为两者的概念是一样的。
---------------------------------------------分割线
所以上述程序输出 1 1 2 3 ，
1，就是 指针指向的内容。
1， 就是指针地址+1，指向的内容。
之后，同理。
给出一个例子，方便理解。程序输出：1 5 1 2 3，因为该程序申请的内存（就是5个Char*），另外字节对齐的概念，请自行补齐。
char* a;
char * s[3]={"1","2","3"};
char* c = "5";
a = *s;

for(int i=0;i <= 4;i++){
printf("%s\n",*((&a)+i));
}
-------------------------------分割线
总结：
1. 数组首地址赋给指针后，两者的概念不要混淆。用单一的指针，做数组首地址来用，非常危险，因为很容易访问未知的内存地址，且不越界就不崩溃。
2. 字节对齐，这个概念很重要，同时，有些编译器也会做一些优化。

[ponymavericks]

好晕

[李财日记]

看了半天头都晕了，还是看懂了，涨知识了。建议二级指针问题交给二级指针来做，比较好理解一些，这东西真的晕。

[wisdriygl]

看到这代码也是“晕”了