为什么说指针是 C 语言的精髓？ - 知乎<strong class="NumberBoard-itemValue" title="被浏览<strong class="NumberBoard-itemValue" title="1,350分享邀请回答47127 条评论分享收藏感谢收起55488 条评论分享收藏感谢收起C语言通过指针使数组倒置
/* 用指针控制数组倒置 */#include &stdio.h&void dz(int x[]){ int i,j; int *p1,*p2,*p; for(i=0;i&5;i++)
*p1=&x[i];
*p2=&x[j];
}void main(){ int s[10];
for(i=0;i&10;i++) {
printf(&请输入10个数字:&);
scanf(&%d&,&s[i]); } dz(s[10]); for(i=0;i&10;i++)
printf(&%d&,s[i]);}大家帮忙看一下有什么问题啊,指针我有点头晕
09-12-18 &
这个程序意思就是让数组前后位置互换，有哪里不清楚的吗？
请登录后再发表评论!
　　指针与数组是C语言中很重要的两个概念，它们之间有着密切的关系，利用这种关系，可以增强处理数组的灵活性，加快运行速度，本文着重讨论指针与数组之间的联系及在编程中的应用。　　1．指针与数组的关系　　当一个指针变量被初始化成数组名时，就说该指针变量指向了数组。如：　　char str[20], ＊　　ptr=　　ptr被置为数组str的第一个元素的地址，因为数组名就是该数组的首地址，也是数组第一个元素的地址。此时可以认为指针ptr就是数组str（反之不成立），这样原来对数组的处理都可以用指针来实现。如对数组元素的访问，既可以用下标变量访问，也可以用指针访问。　　2．指向数组元素的指针　　若有如下定义：　　int a[10], ＊　　pa=a;　　则p=&a[0]是将数组第1个元素的地址赋给了指针变量p。　　实际上，C语言中数组名就是数组的首地址，所以第一个元素的地址可以用两种方法获得：p=&a[0]或p=a。　　这两种方法在形式上相像，其区别在于：pa是指针变量，a是数组名。值得注意的是：pa是一个可以变化的指针变量，而a是一个常数。因为数组一经被说明，数组的地址也就是固定的，因此a是不能变化的，不允许使用a＋＋、＋＋a或语句a＋=10，而pa＋＋、＋＋pa、pa＋=10则是正确的。由此可见，此时指针与数组融为一体。　　3．指针与一维数组　　理解指针与一维数组的关系，首先要了解在编译系统中，一维数组的存储组织形式和对数组元素的访问方法。　　一维数组是一个线形表，它被存放在一片连续的内存单元中。C语言对数组的访问是通过数组名（数组的起始地址）加上相对于起始地址的相对量（由下标变量给出），得到要访问的数组元素的单元地址，然后再对计算出的单元地址的内容进行访问。通常把数据类型所占单元的字节个数称为扩大因子。　　实际上编译系统将数组元素的形式a[i]转换成＊(a＋i)，然后才进行运算。对于一般数组元素的形式：&数组名&[&下标表达式&]，编译程序将其转换成：＊(&数组名&＋&下标表达式&)，其中下标表达式为：下标表达式＊扩大因子。整个式子计算结果是一个内存地址，最后的结果为：＊&地址&=&地址所对应单元的地址的内容&。由此可见，C语言对数组的处理，实际上是转换成指针地址的运算。　　数组与指针暗中结合在一起。因此，任何能由下标完成的操作，都可以用指针来实现，一个不带下标的数组名就是一个指向该数组的指针。　　4．指针与多维数组　　用指针变量可以指向一维数组，也可以指向多维数组。但在概念上和使用上，多维数组的指针比一维数组的指针要复杂一些。　　例如，在一个三维数组中，引用元素c[i][j][k]的地址计算最终将换成：＊(＊(＊(c＋i)＋j)＋k)。了解了多维数组的存储形式和访问多维数组元素的内部转换公式后，再看当一个指针变量指向多维数组及其元素的情况。　　1 指向数组元素的指针变量　　若有如下说明：　　int a[3][4];　　int ＊p;　　p=a;　　p是指向整型变量的指针；p=a使p指向整型二维数组a的首地址。　　＊(＊(p＋1)＋2)表示取a[1][2]的内容；＊p表示取a[0][1]的内容，因为p是指向整型变量的指针；p＋＋表示p的内容加1，即p中存放的地址增加一个整型量的字节数2，从而使p指向下一个整型量a[0][1]。　　2 指向由j个整数组成的一维数组的指针变量　　当指针变量p不是指向整型变量，而是指向一个包含j个元素的一维数组。如果p=a[0]，则p＋＋不是指向a[0][1]，而是指向a[1]。这时p的增值以一维数组的长度为单位。　　5．指针与字符数组　　C语言中许多字符串操作都是由指向字符数组的指针及指针的运算来实现的。因为对于字符串来说，一般都是严格的顺序存取方式，使用指针可以打破这种存取方式，更为灵活地处理字符串。　　另外由于字符串以′\0′作为结束符，而′\0′的ASCII码是0，它正好是C语言的逻辑假值，所以可以直接用它作为判断字符串结束的条件，而不需要用字符串的长度来判断。C语言中类似的字符串处理函数都是用指针来完成，使程序运行速度更快、效率更高，而且更易于理解。
请登录后再发表评论!
问题很严重。void dz(int x[]){int i,j;int *p1,*p2,*p;for(i=0;i&5;i++){j=9-i;*p1=&x[i];*p2=&x[j];*p=*p1;*p1=*p2;*p2=*p; }这个函数定义的有问题。第一次循环的时候确实把x[0]和x[9]互换了（如果你用p1,p2输出），但注意你只是把他们的地址给了p1,p2,但他们的地址还是没有变！！！！我觉得这个函数应改成如下形式：void dz(int x[]){int i,j;int *p1,*p2,*p;for(i=0;i&5;i++){j=9-i;*p1=&x[i];*p2=&x[j];*p=*p1;*p1=*p2;*p2=*p; &x[i]=*p1;&x[j]=*p2;}加上了“&x[i]=*p1; &#160; &#160; &#160; &#160; &#160; &#160; &x[j]=*p2;”你可以试试。如果还有什么问题可以通过电子邮件联系我。我的邮箱；
请登录后再发表评论!
　　指针与数组是C语言中很重要的两个概念，它们之间有着密切的关系，利用这种关系，可以增强处理数组的灵活性，加快运行速度，本文着重讨论指针与数组之间的联系及在编程中的应用。　　1．指针与数组的关系　　当一个指针变量被初始化成数组名时，就说该指针变量指向了数组。如：　　char str[20], ＊　　ptr=　　ptr被置为数组str的第一个元素的地址，因为数组名就是该数组的首地址，也是数组第一个元素的地址。此时可以认为指针ptr就是数组str（反之不成立），这样原来对数组的处理都可以用指针来实现。如对数组元素的访问，既可以用下标变量访问，也可以用指针访问。　　2．指向数组元素的指针　　若有如下定义：　　int a[10], ＊　　pa=a;　　则p=&a[0]是将数组第1个元素的地址赋给了指针变量p。　　实际上，C语言中数组名就是数组的首地址，所以第一个元素的地址可以用两种方法获得：p=&a[0]或p=a。　　这两种方法在形式上相像，其区别在于：pa是指针变量，a是数组名。值得注意的是：pa是一个可以变化的指针变量，而a是一个常数。因为数组一经被说明，数组的地址也就是固定的，因此a是不能变化的，不允许使用a＋＋、＋＋a或语句a＋=10，而pa＋＋、＋＋pa、pa＋=10则是正确的。由此可见，此时指针与数组融为一体。　　3．指针与一维数组　　理解指针与一维数组的关系，首先要了解在编译系统中，一维数组的存储组织形式和对数组元素的访问方法。　　一维数组是一个线形表，它被存放在一片连续的内存单元中。C语言对数组的访问是通过数组名（数组的起始地址）加上相对于起始地址的相对量（由下标变量给出），得到要访问的数组元素的单元地址，然后再对计算出的单元地址的内容进行访问。通常把数据类型所占单元的字节个数称为扩大因子。　　实际上编译系统将数组元素的形式a[i]转换成＊(a＋i)，然后才进行运算。对于一般数组元素的形式：&数组名&[&下标表达式&]，编译程序将其转换成：＊(&数组名&＋&下标表达式&)，其中下标表达式为：下标表达式＊扩大因子。整个式子计算结果是一个内存地址，最后的结果为：＊&地址&=&地址所对应单元的地址的内容&。由此可见，C语言对数组的处理，实际上是转换成指针地址的运算。　　数组与指针暗中结合在一起。因此，任何能由下标完成的操作，都可以用指针来实现，一个不带下标的数组名就是一个指向该数组的指针。　　4．指针与多维数组　　用指针变量可以指向一维数组，也可以指向多维数组。但在概念上和使用上，多维数组的指针比一维数组的指针要复杂一些。　　例如，在一个三维数组中，引用元素c[i][j][k]的地址计算最终将换成：＊(＊(＊(c＋i)＋j)＋k)。了解了多维数组的存储形式和访问多维数组元素的内部转换公式后，再看当一个指针变量指向多维数组及其元素的情况。　　1 指向数组元素的指针变量　　若有如下说明：　　int a[3][4];　　int ＊p;　　p=a;　　p是指向整型变量的指针；p=a使p指向整型二维数组a的首地址。　　＊(＊(p＋1)＋2)表示取a[1][2]的内容；＊p表示取a[0][1]的内容，因为p是指向整型变量的指针；p＋＋表示p的内容加1，即p中存放的地址增加一个整型量的字节数2，从而使p指向下一个整型量a[0][1]。　　2 指向由j个整数组成的一维数组的指针变量　　当指针变量p不是指向整型变量，而是指向一个包含j个元素的一维数组。如果p=a[0]，则p＋＋不是指向a[0][1]，而是指向a[1]。这时p的增值以一维数组的长度为单位。　　5．指针与字符数组　　C语言中许多字符串操作都是由指向字符数组的指针及指针的运算来实现的。因为对于字符串来说，一般都是严格的顺序存取方式，使用指针可以打破这种存取方式，更为灵活地处理字符串。　　另外由于字符串以′\0′作为结束符，而′\0′的ASCII码是0，它正好是C语言的逻辑假值，所以可以直接用它作为判断字符串结束的条件，而不需要用字符串的长度来判断。C语言中类似的字符串处理函数都是用指针来完成，使程序运行速度更快、效率更高，而且更易于理解。
请登录后再发表评论!
char * [2] a=....a[0]=&a[1]
请登录后再发表评论!
一、malloc()和free()的基本概念以及基本用法： 1、函数原型及说明： void *malloc(long NumBytes)：该函数分配了NumBytes个字节，并返回了指向这块内存的指针。如果分配失败，则返回一个空指针（NULL）。 关于分配失败的原因，应该有多种，比如说空间不足就是一种。 void free(void *FirstByte)： 该函数是将之前用malloc分配的空间还给程序或者是操作系统，也就是释放了这块内存，让它重新得到自由。 2、函数的用法： 其实这两个函数用起来倒不是很难，也就是malloc()之后觉得用够了就甩了它把它给free()了，举个简单例子： 程序代码： // Code... char *Ptr = NULL; Ptr = (char *)malloc(100 * sizeof(char)); if (NULL == Ptr) { exit (1); } gets(Ptr); // code... free(Ptr); Ptr = NULL; // code... 就是这样！当然，具体情况要具体分析以及具体解决。比如说，你定义了一个指针，在一个函数里申请了一块内存然后通过函数返回传递给这个指针，那么也许释放这块内存这项工作就应该留给其他函数了。 3、关于函数使用需要注意的一些地方： A、申请了内存空间后，必须检查是否分配成功。 B、当不需要再使用申请的内存时，记得释放；释放后应该把指向这块内存的指针指向NULL，防止程序后面不小心使用了它。 C、这两个函数应该是配对。如果申请后不释放就是内存泄露；如果无故释放那就是什么也没有做。释放只能一次，如果释放两次及两次以上会 出现错误（释放空指针例外，释放空指针其实也等于啥也没做，所以释放空指针释放多少次都没有问题）。 D、虽然malloc()函数的类型是(void *),任何类型的指针都可以转换成(void *),但是最好还是在前面进行强制类型转换，因为这样可以躲过一 些编译器的检查。 好了！最基础的东西大概这么说！现在进入第二部分： 二、malloc()到底从哪里得来了内存空间： 1、malloc()到底从哪里得到了内存空间？答案是从堆里面获得空间。也就是说函数返回的指针是指向堆里面的一块内存。操作系统中有一个记录空闲内存地址的链表。当操作系统收到程序的申请时，就会遍历该链表，然后就寻找第一个空间大于所申请空间的堆结点，然后就将该结点从空闲结点链表中删除，并将该结点的空间分配给程序。就是这样！ 说到这里，不得不另外插入一个小话题，相信大家也知道是什么话题了。什么是堆？说到堆，又忍不住说到了栈！什么是栈？下面就另外开个小部分专门而又简单地说一下这个题外话： 2、什么是堆：堆是大家共有的空间，分全局堆和局部堆。全局堆就是所有没有分配的空间，局部堆就是用户分配的空间。堆在操作系统对进程 初始化的时候分配，运行过程中也可以向系统要额外的堆，但是记得用完了要还给操作系统，要不然就是内存泄漏。 什么是栈：栈是线程独有的，保存其运行状态和局部自动变量的。栈在线程开始的时候初始化，每个线程的栈互相独立。每个函数都有自己的栈，栈被用来在函数之间传递参数。操作系统在切换线程的时候会自动的切换栈，就是切换SS/ESP寄存器。栈空间不需要在高级语言里面显式的分配和释放。 以上的概念描述是标准的描述，不过有个别语句被我删除，不知道因为这样而变得不标准了^_^. 通过上面对概念的描述，可以知道： 栈是由编译器自动分配释放，存放函数的参数值、局部变量的值等。操作方式类似于数据结构中的栈。 堆一般由程序员分配释放，若不释放，程序结束时可能由OS回收。注意这里说是可能，并非一定。所以我想再强调一次，记得要释放！
请登录后再发表评论!字符串与字符指针的问题：为什么用数组定义的字符串可以修改，而用指针定义的不能修改？_百度知道
字符串与字符指针的问题：为什么用数组定义的字符串可以修改，而用指针定义的不能修改？
char *p=&abcde&；的时候，字符串是不可以修改的！
而char p[]=&abcde&;的时候，字符串是可以修改的！
但是我怎么觉得这两种定义方式等价的啊！什么情况？？
还有一点就是为什么同一个字符串，用指针定义的时候在常量区，而用数组定义的时候在栈中...
我有更好的答案
char *p=&abcde&;这种方式是定义了一个字符型指针，指向常量字符串&abcde& char p[]=&abcde&;这种方式是定义了一个字符数组，其长度自动设置其等于&abcde&， 所以第一种指向了常量区，无法修改；第二种定义了普通的数组变量，放在栈中，可以修改
采纳率：60%
&I love you China, do you love me?&在存放在.rodata段,该段是只读的,当你强行做修改的时候,当然要报错喽。而定义为数组的形式之后：就把这个字符串拷贝进数组了,对于数组中的内容,可以随便修改呀. 原来的字符串还是不变的。。。具体回答，参考我的博客：
因为再定义字符指针时默认的在前面有一个const就是无法修改它的值。
为您推荐：
其他类似问题
字符串的相关知识
&#xe675;换一换
回答问题，赢新手礼包&#xe6b9;
个人、企业类
违法有害信息,请在下方选择后提交
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。中，为什么字符串可以赋值给字符指针变量
双引号做了3件事：&&1.申请了空间(在常量区)，存放了字符串&2. 在字符串尾加上了'/0'&&&&3.返回地址你这里就是 返回的地址& 赋值给了& p&&&&&&&&&&&&&&&&&&&&&&
char *p = “hello”;
上边的表达式为什么可以，而把p换成数组，然后再赋值就不行了
字符串常量"hello"出现在一个表达式中时，"hello"表达式使用的值就是这些字符所存储的地址（在常量区），而不是这些字符本身。
所以，可以把字符串赋值给指向字符的指针p，而不能把字符串赋值给一个字符数组。&
char a[10] = “hello”; //这样可以，这种情况是c语言初始化所支持的
如果写成char a[10]
然后 a = “hello” 这样就错误了。&&
同样是a数组，char a[10] = “hello”;这种是数组的初始化，和a[0] = ‘h’ a[1] = ‘e’…是一个道理
但是换成char a [10]
然后a = “hello”就不行了 “hello”赋值的值是一个地址，而a虽然也有地址，但是这与指针是不一样的，指针的值是地址，而数组的值虽然也是地址，但是却是一个常量，所以不能给常量赋值。
#include &stdio.h&&
int main()
&&&&&& char *p = "hello";
&&&&&& printf("%s",p);
&&&&&& char a[10];
&&&&&& a = "hello";
&&&&&& return 0;
error C2440: '=' : cannot convert from 'char [6]' to 'char [10]'
&&&&&&& There is no context in which this conversion is possible
看到这样的错误提示，你是否会想到把char a[10]改成char a[6]呢
error C2106: '=' : left operand must be l-value
运算符的左边应该是一个“左值”。所谓“左值”就是指在程序中占用内存空间、可以被修改的量,比如各种变量。&
继续扩展问题：
在使用指针的时候，指针可以自增，而数组不能自增
编译器给数组分配了空间，数组a的地址就是一个常量了，让常量自增这肯定是不行的。&
继续扩展：
&&&&&&在指针自增的时候，编译器会自动识别类型，比如指针是指向int型的，想获取下一个的地址时，指针直接p++就行了，不要多此一举的p+4了
&&&&&&特别需要注意的是，在void指针使用的时候，不能使用指针运算，应为void型编译器不能识别类型的长度（即指针所指对象的体积），p++这样就是不合法的，即不能进行数学运算，也不能使用*取值操作，想使用必须转换为其它的类型.
1.以字符串形式出现的，编译器都会为该字符串自动添加一个0作为结束符，如在代码中写& "abc",那么编译器帮你存储的是"abc\0"
2."abc"是常量吗？答案是有时是，有时不是。
&&不是常量的情况："abc"作为字符数组初始值的时候就不是，如&&&&&&&&&&&&&&&&& char str[] = "abc";&&& 因为定义的是一个字符数组，所以就相当于定义了一些空间来存放"abc"，而又因为&&& 字符数组就是把字符一个一个地存放的，所以编译器把这个语句解析为&&& char str[3] = {'a','b','c'};&&&&&&&&&&&&&&&&& 又根据上面的总结1，所以char str[] = "abc";的最终结果是&&& char str[4] = {'a','b','c','\0'};&&& 做一下扩展，如果char str[] = "abc";是在函数内部写的话，那么这里&&& 的"abc\0"因为不是常量，所以应该被放在栈上。&&&&是常量的情况：& 把"abc"赋给一个字符指针变量时，如&&&&&&&&&&&&&&&&& char* ptr = "abc";&&& 因为定义的是一个普通字符指针，并没有定义空间来存放"abc"，所以编译器得帮我们&&& 找地方来放"abc"，显然，把这里的"abc"当成常量并把它放到程序的常量区是编译器&&& 最合适的选择。所以尽管ptr的类型不是const char*，并且ptr[0] = 'x';也能编译&&& 通过，但是执行ptr[0] = 'x';就会发生运行时异常，因为这个语句试图去修改程序&&& 常量区中的东西。&&& 记得哪本书中曾经说过char* ptr = "abc";这种写法原来在c++标准中是不允许的，&&& 但是因为这种写法在c中实在是太多了，为了兼容c，不允许也得允许。虽然允许，&&& 但是建议的写法应该是const char* ptr = "abc";这样如果后面写ptr[0] = 'x'的&&& 话编译器就不会让它编译通过，也就避免了上面说的运行时异常。&&& 又扩展一下，如果char* ptr = "abc";写在函数体内，那么虽然这里的"abc\0"被&&& 放在常量区中，但是ptr本身只是一个普通的指针变量，所以ptr是被放在栈上的，&&& 只不过是它所指向的东西被放在常量区罢了。
3.数组的类型是由该数组所存放的东西的类型以及数组本身的大小决定的。& 如char s1[3]和char s2[4]，s1的类型就是char[3]，s2的类型就是char[4]，& 也就是说尽管s1和s2都是字符数组，但两者的类型却是不同的。
4.字符串常量的类型可以理解为相应字符常量数组的类型，& 如"abcdef"的类型就可以看成是const char[7]
5.sizeof是用来求类型的字节数的。如那么无论sizeof(int)或者是sizeof(a)都& 是等于4，因为sizeof(a)其实就是sizeof(type of a)
6.对于函数参数列表中的以数组类型书写的形式参数，编译器把其解释为普通& 的指针类型，如对于void func(char sa[100],int ia[20],char *p)& 则sa的类型为char*，ia的类型为int*，p的类型为char*
7.根据上面的总结，来实战一下：& 对于char str[] = "abcdef";就有sizeof(str) == 7,因为str的类型是char[7]，& 也有sizeof("abcdef") == 7，因为"abcdef"的类型是const char[7]。& 对于char *ptr = "abcdef";就有sizeof(ptr) == 4，因为ptr的类型是char*。& 对于char str2[10] = "abcdef";就有sizeof(str2) == 10，因为str2的类型是char[10]。& 对于void func(char sa[100],int ia[20],char *p);& 就有sizeof(sa) == sizeof(ia) == sizeof(p) == 4，& 因为sa的类型是char*， ia的类型是int*，p的类型是char*。
这几天搞Unix上的C程序，里面用到了很多字符数组和字符串指针，我记得在学完C语言后相当一段时间里，对指针这个东西还是模模糊糊，后来工作也没怎么用到过C,虽然网上这类的文章也有很多，还是决定自己在这做个小总结，也算加深下自己的印象，写了下面的测试程序：#include &stdio.h&
int main(int argc, char *argv[]){
& char day[15] = "abcdefghijklmn";& char* strTmp = "opqrstuvwxyz";
& printf("&day is %x\n",&day);& printf("&day[0] is %x\n",&day[0]);& printf("day is %x\n",day);&&& printf("\n&strTmp is %x\n",&strTmp);& printf("&strTmp[0] is %x\n",&strTmp[0]);& printf("strTmp is %x\n",strTmp);&&& getchar();&& return 0;}运行后屏幕上得到如下结果：其实看到结果估计很多东西就好明白了，
&&& 先看看前三个输出也就是关于变量day的，在 char day[15] = "abcdefghijklmn"; 这个语句执行的时候，系统就分配了一段长15的内存，并把这段内存起名为day,里面的值为"abcdefghijklmn"，如下图所示：&&&&&&& 再看程序，第一个输出，&day，&号是地址运算符，也就是day这个变量的内存地址，很明显，在最前面，也就是a字符所在字节的地址；&&&&&&&&对于第二个输出也就好理解了，&day[0],就是day数组中第一个变量（也就是a）的地址，因此他们两个是一样的；&&&&&&& 第三个输出是day，对于数组变量，可以使用变量名来索引变量中的内容，其实这里的day可以理解成数组变量退化的指针，并且指向数组的开头，既然把它理解成指针，那么它的值肯定是地址了，所以他的值和上面两个也一样。&&& 再看看后面三个输出，关于字符串指针strTmp，在执行char* strTmp = "opqrstuvwxyz";后，内存的图示如下：如图所示，内存分配了两段内存，一个名为strTmp，类型是一个字符指针，另外一段是一个字符串常量，且strTmp里面存放着字符常量的首地址，注意这里无法通过strTmp修改这段字符串，因为是常量；于是程序中的后面三个输出就好理解了；&&&&& &strTmp：strTmp这个字符指针的地址& &strTmp[0]：strTmp所指字符常量第一个字符的地址& strTmp：strTmp这个字符指针的值，即字符常量的首地址因此，最后两个的值是一样的。&&&&& 指针可以这样理解，指针这种类型，和int,char,double等等是一样的，只是它用来保存地址值的，而int变量保存整数，char变量保存字符，仅此而已，就char型指针或者int指针，本质是一样的，都是存放的地址，只不过那个地址所里面的变量类型不同而已，还有一种void型指针，就是可以放任何类型变量的地址。
五、个人代码以及注释,纯属个人理解，定有不妥之处，望批评指正：
#include &stdio.h&
int main(int argc, char *argv[]){&char* strTmp = "abcd";&printf("strTmp is %s\n",strTmp);//将字符串常量"abcd"的地址所隐含的内容转换成“string类型”&printf("strTmp is %d\n",strTmp);//将字符串常量"abcd"的地址转换成int类型,这里不同的机子不同的时间的运行结果可能会不一样，因为地址可能会发生变化&printf("strTmp is %c\n",strTmp);//将字符串常量"abcd"的地址转换成字符型,这里不同的机子不同的时间的运行结果可能会不一样，因为地址可能会发生变化&printf("*strTmp is %c\n",*strTmp);//将字符串常量"abcd"的地址所隐含的内容转换成字符型，由下面注释的这句会抛出异常可知，这里并无截取字符串，*strTmp长度本身就是1&//printf("*strTmp is %s\n",*strTmp);//不能将字符转换成字符串型&getchar();&&return 0;}
&六、后来又有看到下面这样的说法可供读者参考：
1. C语言中没有字符串类型，只有用字符数组来表示。这和c++中string是有区别的，C++中string是可以直接赋值如s="Hello world";但是C语言中的字符数组却不能这样。所以，这里的strTmp可以理解为字符数组的首地址，也可以用它代表整个字符数组，所以能输出所有字符数组中的内容。
&2.字符串就是字符数组或者是指针。 内存实现都一样的。 数组名字就是一个指针。
char ch[100] ;char *p;p =
3.定义的字符串方式举例：
字符串定义其实很简单在c/c++语言中定义一个字符串可以使用如下的语法：
char&*s1=“string1”；//定义字符串常量，指针形式
char&s2[]=“string2”；//定义字符串常量，数组形式
char&*s3=new&char[10]；//定义字符串变量并分配内存&指针形式
strcpy(s3,"string3");//为s3赋值
char&s4[10]；//定义字符串变量，数组形式
strcpy(s4,"string4");//为s4赋值
以上四种方法都能定义一个字符串，同时通过字符串在内存中的分布可以清楚地知道是什么情况
4. C语言中字符串赋值方法strcpy(char*d,char*s)其中s代表是源字符串，d代表目标字符串，也就是你要赋值的字符串。
5.c语言中的字符串跟或c++中的字符串不同。如char *p；其中p是一个指针，p中存储一个内存缓冲区的首地址。所谓的内存缓冲区就是一段连续的内存地址，里面存放了一系列的字符。那系统又是如何判断在哪里结束呢。那就是根据符号‘\0’。这个字符占一个字节，8位，每位的值都是0。
阅读(...) 评论()