欢迎加入我们，一同切磋技术。 &
用户名： &&&
密　码： &
共有 261 人关注过本帖
标题：返回一个指针的问题
等　级：论坛游侠
帖　子：101
专家分：156
结帖率：100%
&&已结贴√
&&问题点数：20&&回复次数：16&&&
返回一个指针的问题
#include &stdio.h&
#include &math.h&
#define DEG_TO_RED ((4 * atan(1)) / 180)
typedef struct polar_v {
} Polar_V;
typedef struct rect_v {
Rect_V polar_to_rect(Polar_V pv);
int main(void)
&&& Polar_V
&&& Rect_V
&&& puts(&Enter enter q to quit:&);
&&& while (scanf(&%lf%lf&, &input.magnitude, &input.angle) == 2)
&&&&&&&&result = polar_to_rect(input);
&&&&&&&&printf(&x = %.2f, y = %.2f\n&, result.x, result.y);
&&&&&&&&puts(&Next input (q to quit):&);
&&& puts(&Bye.&);
&&& return 0;
Rect_V polar_to_rect(Polar_V pv)
&&& Rect_V
&&& rv.x = pv.magnitude * cos(pv.angle * DEG_TO_RED);
&&& rv.y = pv.magnitude * sin(pv.angle * DEG_TO_RED);
请问怎么改写成返回指向该结构的指针
附件: 您没有浏览附件的权限，请
等　级：贵宾
威　望：48
帖　子：1322
专家分：5512
&&得分:10&
Rect_V *rv = malloc(sizeof(Rect_V));
&rv-&x = pv.magnitude * cos(pv.angle * DEG_TO_RED);
&rv-&y = pv.magnitude * sin(pv.angle * DEG_TO_RED);
等　级：论坛游侠
帖　子：101
专家分：156
回复 2楼 grmmylbs
也就是说必须给返回的结构体指针开辟一个地址空间&&是不是最后得释放掉？
等　级：贵宾
威　望：48
帖　子：1322
专家分：5512
等　级：论坛游侠
帖　子：101
专家分：156
我在主函数加入 free(rv); 编译说没定义，我又去主函数定义Rect_V *rv；这个指针应该不是在局部函数开辟的空间地址指针，所以说free的也不是malloc开辟的地址，请问怎么才能free刚刚malloc的空间呢？谢谢
等　级：贵宾
威　望：129
帖　子：5474
专家分：23250
&&得分:10&
用结构地址做输入输出参数不可以吗？
等　级：论坛游侠
帖　子：101
专家分：156
回复 6楼 吹水佬
你写一下你的想发这一部分代码&&我看看&&&也就几行
等　级：贵宾
威　望：48
帖　子：1322
专家分：5512
Rect_V *result = polar_to_rect(input);
free(result );
Rect_V *polar_to_rect(Polar_V pv)
等　级：贵宾
威　望：129
帖　子：5474
专家分：23250
以下是引用li384022在 16:43:17的发言：
你写一下你的想发这一部分代码&&我看看&&&也就几行
#include &stdio.h&
#include &math.h&
#define DEG_TO_RED ((4 * atan(1)) / 180)
typedef struct polar_v {
} Polar_V;
typedef struct rect_v {
Rect_V *polar_to_rect(Polar_V *pv, Rect_V *rv);
int main(void)
&&& Polar_V
&&& Rect_V
&&& puts(&Enter enter q to quit:&);
&&& while (scanf(&%lf%lf&, &input.magnitude, &input.angle) == 2)
&&&&&&&&polar_to_rect(&input, &result);
&&&&&&&&printf(&x = %.2lf, y = %.2lf\n&, result.x, result.y);
&&&&&&&&puts(&Next input (q to quit):&);
&&& puts(&Bye.&);
&&& return 0;
Rect_V *polar_to_rect(Polar_V *pv, Rect_V *rv)
&&& rv-&x = pv-&magnitude * cos(pv-&angle * DEG_TO_RED);
&&& rv-&y = pv-&magnitude * sin(pv-&angle * DEG_TO_RED);
[此贴子已经被作者于 16:54编辑过]
等　级：论坛游侠
帖　子：101
专家分：156
回复 8楼 grmmylbs
哦哦&&学习了 领教了&&可是我把malloc函数删了也编译成功运行成功&&证明它不是必须的啊&&&。。。。&&
版权所有，并保留所有权利。
Powered by , Processed in 0.053381 second(s), 8 queries.
Copyright&, BCCN.NET, All Rights ReservedC语言指针简单习题（刚学的指针，程序别太复杂）_百度知道
C语言指针简单习题（刚学的指针，程序别太复杂）
利用指针和函数完成以下字符串的操作。1.求字符串从第m个字符起，长度为k的字串。其中m、k从键盘输入。2.两个字符串比较大小，返回值为一个整数。
我有更好的答案
第一题#include &stdio.h&void fun1(char* str, int m, int k){ char* p = &str[m - 1]; while (p - str & m + k - 1) {
printf(&%c&, *p);
p++; }}int main(){ char str[100]; int m, scanf(&%s%d%d&, str, &m, &k); fun1(str, m, k); return 0;}第二题 #include &stdio.h&void fun2(char* str1, char* str2){ char* p = str1; char* q = str2; while (*p && *q) {
if (*p & *q)
else if (*p & *q)
return -1;
} } if (*p) {
return 1; } return -1;}int main(){ char str1[100], str2[100]; scanf(&%s%s&, str1, str2); fun2(str1, str2); return 0;}
采纳率：67%
ajwdioajdoiawjiddawdwadawdwad
为您推荐：
其他类似问题
您可能关注的内容
c语言的相关知识
换一换
回答问题，赢新手礼包
个人、企业类
违法有害信息,请在下方选择后提交
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。嵌入式linux之C语言高级专题指针详解1
1.1指针变量和普通变量的区别
指针的实质就是一个变量，其完整的名称是指针变量，与普通的变量没什么区别。指针存储的是地址，而普通变量存储的是数值。
1.2指针使用三部曲：定义指针变量、关联指针变量、解引用
1.2.1定义指针变量：类型名 * 指针变量
定义指针时的星号的位置不一样从而有三种定义：（1）int * a； （2）int* a；（3）int *a；
我编写了一下代码来验证以上的三种情况：
int main(void)
printf(&*p1 = %d\n&,*p1);
printf(&*p2 = %d\n&,*p2);
printf(&*p3 = %d\n&,*p3);
在linux中利用terminal中的gcc交叉编译工具来编译和运行c代码，运行结果如下图所示：
结论：三种定义的运行结果一样，故三种定义等价
1.2.2关联指针变量
关联指针变量的两种方法：（1）在定义指针时，初始化指针变量（2）指针变量= &变量
通过以上的两种方法，可以将指针指向应该访问的地方，如果没对指针进行关联，就访问指针指向地址中的变量，会导致系统出现不可预料的严重后果。
1.2.3解引用
星号在用于指针相关功能的时候有2种用法：第一种是指针定义时，*结合前面的类型用于表明要定义的指针的类型；第二种功能是指针解引用，解引用时*p表示p指向的变量本身
1.3指针中的一些符号的理解
1.3.1星号*
(1)C语言中*可以表示乘号，也可以表示指针符号。这两个用法是毫无关联的，只是恰好用了同一个符号而已。
(2)星号在用于指针相关功能的时候有2种用法：第一种是指针定义时，*结合前面的类型用于表明要定义的指针的类型；第二种功能是指针解引用，解引用时*p表示p指向的变量本身
1.3.2取地址符
取地址符使用时直接加在一个变量的前面，然后取地址符和变量加起来构成一个新的符号，这个符号表示这个变量的地址。
1.3.3 NULL是什么？
NULL在C/C++中定义为：
#ifdef _cplusplus
// 定义这个符号就表示当前是C++环境
#define NULL 0
// 在C++中NULL就是0
#define NULL (void *)0
// 在C中NULL是强制类型转换为void *的0
1.4左值与右值
(1)放在赋值运算符左边的就叫左值，右边的就叫右值。所以赋值操作其实就是：左值= 右值;
(2)当一个变量做左值时，编译器认为这个变量符号的真实含义是这个变量所对应的那个内存空间；当一个变量做右值时，编译器认为这个变量符号的真实含义是这个变量的值，也就是这个变量所对应的内存空间中存储的那个数。
(3)左值与右值的区别，就好象现实生活中&家&这个字的含义。譬如&我回家了&，这里面的家指的是你家的房子（类似于左值）；但是说&家比事业重要&，这时候的家指的是家人（家人就是住在家所对应的那个房子里面的人，类似于右值）
1.5野指针问题
1.5.1野指针的相关概念
(1)因为指针变量在定义时如果未初始化，值也是随机的。指针变量的值其实就是别的变量（指针所指向的那个变量）的地址，所以意味着这个指针指向了一个地址是不确定的变量，这时候去解引用就是去访问这个地址不确定的变量，所以结果是不可知的。
(2)因为野指针指向地址是不可预知的，所以有3种情况：
第一种是指向不可访问（操作系统不允许访问的敏感地址，譬如内核空间）的地址，结果是触发段错误，这种算是最好的情况了；
第二种是指向一个可用的、而且没什么特别意义的空间（譬如我们曾经使用过但是已经不用的栈空间或堆空间），这时候程序运行不会出错，也不会对当前程序造成损害，这种情况下会掩盖你的程序错误，让你以为程序没问题，其实是有问题的；
第三种情况就是指向了一个可用的空间，而且这个空间其实在程序中正在被使用（譬如说是程序的一个变量x），那么野指针的解引用就会刚好修改这个变量x的值，导致这个变量莫名其妙的被改变，程序出现离奇的错误。一般最终都会导致程序崩溃，或者数据被损害。这种危害是最大的。
1.5.2避免野指针的技巧（很有价值的方法）
(1)野指针的错误来源就是指针定义了以后没有初始化，也没有赋值（总之就是指针没有明确的指向一个可用的内存空间），然后去解引用。故在指针的解引用之前，一定确保指针指向一个绝对可用的空间。
(2)常规的做法是：
第一点：定义指针时，同时初始化为NULL
第二点：在指针使用之前，将其赋值绑定给一个可用地址空间
第三点：在指针解引用之前，先去判断这个指针是不是NULL
第四点：指针使用完之后，将其赋值为NULL
int main(void)
int *p = NULL;//第一点：定义指针时，同时初始化为NULL
//第二点：在指针使用之前，将其赋值绑定给一个可用地址空间
if(NULL！=p)//第三点：在指针解引用之前，先去判断这个指针是不是NULL
p = NULL; //第四点：指针使用完之后，将其赋值为NULL
1.5.3 const关键字与指针
1. const修饰指针的4种形式
第一种：const int *p;
第二种：int const *p;
第三种：int *
第四种：const int *
指针变量涉及到2个变量：第一个是指针变量p本身，第二个是p指向的那个变量(*p)。一个const关键字只能修饰一个变量，所以弄清楚这4个表达式的关键就是搞清楚const放在某个位置是修饰谁的。
（1）const int *p 或者int const *p
p指向的变量是const常量
（2）int * const p 或者 const int * const p
p本身是const常量，p指向的变量也是const常量
1.6深入学习一下数组
1.6.1从内存角度来理解数组
(1)从内存角度讲，数组变量就是一次分配多个变量，而且这多个变量在内存中的存储单元是依次相连接的。
(2)我们分开定义多个变量（譬如int a, b, c,）和一次定义一个数组（int a[4]）；这两种定义方法相同点是都定义了4个int型变量，而且这4个变量都是独立的单个使用的；不同点是单独定义时a、b、c、d在内存中的地址不一定相连，但是定义成数组后，数组中的4个元素地址肯定是依次相连的。
(3)数组中多个变量虽然必须单独访问，但是因为他们的地址彼此相连，因此很适合用指针来操作，因此数组和指针天生就叫纠结在一起。
1.6.2数组中几个关键符号（a a[0] &a &a[0]）的理解
(1)a就是数组名。
la做左值时表示整个数组的所有空间，又因为C语言规定数组操作时要独立单个操作，不能整体操作数组，所以a不能做左值；
la做右值表示数组首元素（数组的第0个元素，也就是a[0]）的首地址（首地址就是起始地址，就是最开始第一个字节的地址）。a做右值等同于&a[0];
(2)a[0]表示数组的首元素，也就是数组的第0个元素。
la[0]做左值时表示数组第0个元素对应的内存空间（连续4字节）；
la[0]做右值时表示数组第0个元素的值（也就是数组第0个元素对应的内存空间中存储的那个数）
(3)&a就是数组名a取地址，字面意思来看就应该是数组的地址。
l&a不能做左值（&a实质是一个常量，不是变量因此不能赋值，所以自然不能做左值。）；
l&a做右值时表示整个数组的首地址。
(4)&a[0]字面意思就是数组第0个元素的首地址（搞清楚[]和&的优先级，[]的优先级要高于&，所以a先和[]结合再取地址）。
l做左值时表示数组首元素对应的内存空间，做右值时表示数组首元素的值（也就是数组首元素对应的内存空间中存储的那个数值）。
l做右值时&a[0]等同于a。
1：&a和a做右值时的区别：&a是整个数组的首地址，而a是数组首元素的首地址。这两个在数字上是相等的，但是意义不相同。意义不相同会导致他们在参与运算的时候有不同的表现。
2：a和&a[0]做右值时意义和数值完全相同，完全可以互相替代。
3：&a是常量，不能做左值。
4：a做左值代表整个数组所有空间，所以a不能做左值。
1.6.3为什么数组的地址是常量？
因为数组是编译器在内存中自动分配的。当我们每次执行程序时，运行时都会帮我们分配一块内存给这个数组，只要完成了分配，这个数组的地址就定好了，本次程序运行直到终止都无法再改了。那么我们在程序中只能通过&a来获取这个分配的地址，却不能去用赋值运算符修改它。
1.6.4指针与数组的天生姻缘
1.以指针方式来访问数组元素
(1)数组元素使用时不能整体访问，只能单个访问。访问方式有2种：数组形式和指针形式:
l数组格式访问数组元素是：数组名[下标]; (注意下标从0开始)
l指针格式访问数组元素是：*(指针+偏移量);
注：如果指针是数组首元素地址（a或者&a[0]），那么偏移量就是下标；指针也可以不是首元素地址而是其他哪个元素的地址，这时候偏移量就要考虑叠加了。
数组下标方式和指针方式均可以访问数组元素，两者的实质其实是一样的。在编译器内部都是用指针方式来访问数组元素的，数组下标方式只是编译器提供给者一种壳（语法糖）而已。所以用指针方式来访问数组才是本质的做法。
1.6.5指针和数组类型的匹配问题
int *p; int a[5];p =//类型匹配
int *p; int a[5];p = &a;//类型不匹配。p是int *，&a是整个数组的指针，也就是一个数组指针类型，不是int指针类型，所以不匹配
总结：&a、a、&a[0]从数值上来看是完全相等的，但是意义来看就不同了。
l从意义来看，a和&a[0]是数组首元素首地址，而&a是整个数组的首地址
l从类型来看，a和&a[0]是元素的指针，也就是int *类型；而&a是数组指针，是int (*)[常量]类型。
1.6.6指针类型决定了指针如何参与运算
(1)指针参与运算时，因为指针变量本身存储的数值是表示地址的，所以运算也是地址的运算。
(2)指针参与运算的特点是，指针变量+1，并不是真的加1，而是加1*sizeof(指针类型)；如果是int *指针，则+1就实际表示地址+4，如果是char *指针，则+1就表示地址+1；如果是double *指针，则+1就表示地址+8.
1.7指针与强制类型转换
1.7.1变量的数据类型的含义
(1)所有的类型的数据存储在内存中，都是按照二进制格式存储的,即内存中只保存0和1。但是他们的存储方式（数转换成二进制往内存中放的方式）不一定相同。
(2)int、char、short等属于整形，他们的存储方式是相同的，只是占用的内存大小不同（所以这几种整形就彼此叫二进制兼容格式）；而float和double的存储方式彼此不同，和整形更不同。
(3)当编译代码int a = 5;时，编译器给a分配4字节空间，并且将5按照int类型的存储方式转成二进制存到a所对应的内存空间中去（a此时做左值）；我们printf去打印a的时候（a此时做右值），采用%d或者%f的方式解析内存中二进制数值时，如果解析方式与存储的方式相同，则能输出正确的数值，如下面的代码运行结果所示：
int main(void)
int a = 5;
printf(&a = %d\n&,a);
printf(&a = %f\n&,a);
运行结果如下图所示：
分析几个题目：
* 按照int类型存却按照float类型取一定会出错
* 按照int类型存却按照char类型取有可能出错也有可能不出错
* 按照short类型存却按照int类型取有可能出错也有可能不出错
* 按照float类型存却按照double取一定会出错
int和char类型都是整形，类型兼容的。int和char的不同在于char只有1个字节而int有4个字节，所以int的范围比char大。在char所表示的范围之内int和char是可以互转的不会出错；但是超过了char的范围后char转成int不会错（向大方向转就不会错，就好比拿小瓶子的水往大瓶子倒不会漏掉不会丢掉），而从int到char转就会出错（就好象拿大瓶子水往小瓶子倒一样）。
1.7.2指针的数据类型的含义
(1)指针的本质是：变量，指针就是指针变量
(2)一个指针涉及2个变量：一个是指针变量自己本身，一个是指针变量指向的那个变量
(3)int *p;定义指针变量时，p（指针变量本身）是int *类型，*p（指针指向的那个变量）是int类型的。
(4)int *类型说白了就是指针类型，只要是指针类型就都是占4字节，解析方式都是按照地址的方式来解析（意思是里面存的32个二进制加起来表示一个内存地址）的。结论就是：所有的指针类型（不管是int * 还是char *还是double *）的解析方式是相同的，都是地址。
(5)指针所指向的那个变量的类型（它所对应的内存空间的解析方法）要取决于指针类型。譬如指针是int *的，那么指针所指向的变量就是int类型的。
----------------文章未完，待后续更新----------------有关C/C++指针的经典面试题 - c语言程序开发技术文章
作者：用户
& C语言为何如此长寿并实用?C++为什么有那么多精彩?指针可以说是C/C++中的灵魂所在，虽然早期中pascal也有指针，但是和C/C++比起来不是一个级别的.今天为...
C语言为何如此长寿并实用?C++为什么有那么多精彩?指针可以说是C/C++中的灵魂所在，虽然早期中pascal也有指针，但是和C/C++比起来不是一个级别的.今天为大家深入浅出的解析一下指针的有关笔试，面试题.所有题目来源网络，分析是我写的...
0.预备知识，最基础的指针
其实最基础的指针也就应该如下面代码:
int* p=&a;
也就是说，声明了一个int变量a，然后声明一个int 的指针，*p指向a的地址，&也就是取地址符号，而*是指针中取内容的符号，仅仅在声明的时候标记这个变量是指针.可能有点绕口，但是看代码来的容易的多...
1.与const在一起的时候
常常声明的时候会让人一头雾水，比如下面的声明，均是声明一个char* p的指针:
char *// 指针不可改，也就说指针只能指向一个地址，不能更改为其他地址
char const *// 所指内容不可改，也就是说*p是常量字符串
char const * // 内容和指针都不能改
const char * // 同上...内容和指针不能改
额...别晕，别晕....其实方法很简单...你别真死记硬背...其实可以以*为分界符，在*左边有const就说明内容不能改，在*右边就说明指针不能改，而左边的char和const顺序是不要紧的...呵呵...你也可以理解成const是修饰后面的，正常顺序应该这样:const char * 是不是看起来简单了?
2.忽悠人的陷阱，str[]和*str的区别
先告诉你哦，下面的题目可是陷阱啊....说说程序结果...
char str1[] = &abc&;
char str2[] = &abc&;
const char str3[] = &abc&;
const char str4[] = &abc&;
const char *str5 = &abc&;
const char *str6 = &abc&;
char *str7 = &abc&;
char *str8 = &abc&;
cout && ( str1 == str2) &&
cout && ( str3 == str4 ) &&
cout && ( str5 == str6 ) &&
cout && ( str7 == str8 ) &&
怎么样?都输出true?那显然你中标了...而且cout输出bool值的时候，就算全是真也应该都输出1啊...4个1?那也不对...答案是0011，不信你试试...为什么呢?
其实都说了这题是个大陷阱，因为这题根本不是比较字符串内容!而是比较字符串的地址.哦...恍然大悟...那为什么前两个是假呢?因为这可是说是一个深拷贝/浅拷贝的问题.当字符串是数组形式声明并初始化，编译器认为是新数组，分配新空间，但不是深拷贝，因为根本就不算拷贝.而如果是相同的字符串，用指针声明，那就是比较如果有一样的字符串，就直接把新指针指过去，这是正宗的浅拷贝.哇哈...你就中计了...
3.str[]用sizeof判断会出错么?
应该说我们常常用指针有很多时候是解决字符串的问题，一般我们用strlen，这当然没有问题，但是要你编一个呢?看看下面这个MyStrlen有问题么?
int MyStrlen(char str[])
return(int)(sizeof(str)-1);
呵呵...咱们上当过一次..这个当然也是不对的...不错...这个函数是错的...为什么呢?
首先，可以告诉你，无论何时，返回的总是3...额...是不是很奇怪，为什么不是数组长度呢?str不是char数组指针么?不错...确实是数组的指针，但是，当用函数传递的数组指针的时候就自动退化为指针了，而指针的长度是4，你减去1了自然就是3了.但是如果按照下面代码就可以得到正常的值.
char str[]=&hello world&;
int len=sizeof(str)-1;//记得减1哦，最后有'\0'结尾
这样输出的是正常值，也就是你所希望的11;
4.注意数组指针和指针
继续上面的话题，刚刚提到了数组指针和指针，现在看看下面这端程序代码:
int a[5]={1，2，3，4，5};
int *ptr=(int *)(&a+1);
cout&&*(a+1)&&*(ptr-1);
呵呵...BaihowFF总是给陷阱..肯定不是想当然的说就是21...确实...答案是25...额...奇怪吧..为什么呢?
首先，a是一个数组，所以编译器解释&a就是a的全部长度，就是说(&a+1)也就是说移动了一个数组，指向了并不存在的a[5]，所以ptr-1才会指向a数组的最后一个元素a[4]，而a+1和a[1]是一样的...所以答案是25，如果你去掉了(&a+1)的括号，那么答案就是想当然的21了...呵呵...很微妙吧....
5.注意指针要分配给足够的空间
新手在刚刚接触指针的时候经常会忘记给指针分配空间，直接用肯定是有问题的，那么下面的程序呢?
char *str=&a;
strcpy(str，&hello&);
BaihowFF是坏蛋..总会下套...呵呵..确实是圈套...这段程序能够输出hello，但是输出后就崩溃了...原因就在你分配str指针的时候仅仅给了1字节的空间，但是你拷贝了6字节过去(不要忘记了最后的'\0'结束).运行输出后程序因为访问了没有分配的呵呵空间，当然崩溃了.如果你只strcpy(str，&&);那程序是可以正常运行的.
6.小心编译器的指针字符串初始化
经常我们想自己处理字符串，但是像下面的初始化是很危险的!!!
char* s=&AAA&;
s[0]='B';
你可以拿这段程序去编译...没错!编译器报告正常!...这是最要命的...其实程序不能运行的...输出AAA后就崩溃了..为什么?因为当你在第一句初始化的时候，编译器就认为这是个字符串常量了...再做数组操作的时候肯定错了罗...最好的习惯是声明一个指针，用new分配空间，然后用库函数操作，比如strcpy，strcat等等...
7.让人一眼看上去迷糊的函数指针
看看这句代表什么意思?
int (*s[10])(int);
咦...这是什么?其实这是一个函数指针数组，指向了一组int fun(int)的函数，第一眼确实让人有点迷糊...但是请习惯这样...
8.注意函数传递指针的时候是副本
副本?又下副本?...汗...老兄...不是这个意思...别沉浸在WOW里了啊...看看下面程序的问题:
void GetMemory(char *p)
p=new char[100];
strcpy(p，&hello world&);
void main(void)
char *str=NULL;
GetMemory(str);
当然了..喜欢下套的BaihowFF又给了错程序....错在哪呢?看上去是对的，而且编译器编译也正确啊..怎么就是不能通过呢?而且还崩溃了...好费解吧...
其实原因很简单...GetMemory这个函数出问题了!函数参数是不能传递分配空间的...因为传递过去实际上是一个副本p...不能返回的...而且你在delete那就是件很危险的事情..因为压根没有内容...那我实在想这样用函数分配怎么办呢?像下面这样改一下就ok了:
void GetMemory(char **p)// 改成晦涩难懂的指针的指针
*p=new char[100];//给*p的分配地址
strcpy(*p，&hello world&);// 拷贝内容到*p
void main(void)
char *str=NULL;
GetMemory(&str);//这地方取地址
这样就能正常工作了，但是看起来好别扭啊...嗯..确实...但是还可以用其他方法哦....你想想...肯定有办法的...
9.请时刻记住要初始化字符串
嗯...这点大家都知道...那你猜猜下面的程序结果是多少?
char a[10];
答案应该让你以外...竟然是15...没道理吧?!其实strlen函数的结果和是否初始化有关的...虽然你分配了空间..但是没有初始化..库函数会出错的..sizeof不受影响...切忌初始化哦....
10.小括号，大区别
看看这两端声明，有什么不同?我直接在注释里告诉你答案吧...这样好看点...
char (*str)[20];//str是一个数组指针，即指向数组的指针．
char *str[20];//str是一个指针数组，其元素为指针型数据．
千万别小看括号哦...区别大了吧....
c语言面试题__指针篇
1.　char *
　　char const * p
　　const char *p
　　上述三个有什么区别。
　　char * //常量指针，p的值不可以修改
　　char const * p；//指向常量的指针，指向的常量值不可以改
　　const char *p；//和char const *p
------------------------------------------------------
2.　char str1[] = &abc&;
　　char str2[] = &abc&;
　　const char str3[] = &abc&;
　　const char str4[] = &abc&;
　　const char *str5 = &abc&;
　　const char *str6 = &abc&;
　　char *str7 = &abc&;
　　char *str8 = &abc&;
　　cout && ( str1 == str2 ) &&
　　cout && ( str3 == str4 ) &&
　　cout && ( str5 == str6 ) &&
　　cout && ( str7 == str8 ) &&
打印结果是什么。
解答：结果是：0 0 1 1
str1，str2，str3，str4是数组变量，它们有各自的内存空间；而str5，str6，str7，str8是指针，它们指向相同的常量区域
-----------------------------------------------
3.以下代码中的两个sizeof用法有问题吗。
　　void UpperCase( char str[] ) //将str中的小写字母转换成大写字母
　　for( size_t i=0; i 　if( 'a'&=str[i] && str[i]&='z' )
str[i] -= ('a'-'A' );
　　char str[] = &aBcDe&;
　　cout && &str字符长度为: & && sizeof(str)/sizeof(str[0]) &&
　　UpperCase( str );
　　cout && str &&
答：函数内的sizeof有问题。
根据语法，sizeof如用于数组，只能测出静态数组的大小，无法检测动态分配的或外部数组大小。
函数外的str是一个静态定义的数组，因此其大小为6，
函数内的str实际只是一个指向字符串的指针，没有任何额外的与数组相关的信息，因此sizeof作用于上只将其当指针看，一个指针为4个字节，因此返回4。
-------------------------------------------------
4.　main()
　　　int a[5]={1，2，3，4，5};
　　　int *ptr=(int *)(&a+1);
　　　printf(&%d，%d&，*(a+1)，*(ptr-1));
输出结果是什么。
　　答案：输出：2，5
　　*(a+1）就是a[1]，*(ptr-1)就是a[4]，执行结果是2，5
　　&a+1不是首地址+1，系统会认为加一个a数组的偏移，是偏移了一个数组的大小（本例是5个int）
　　int *ptr=(int *)(&a+1);
　　则ptr实际是&(a[5])，也就是a+5
　　原因如下：
　　&a是数组指针，其类型为int (*)[5];
　　而指针加1要根据指针类型加上一定的值，不同类型的指针+1之后增加的大小不同。
　　a是长度为5的int数组指针，所以要加5*sizeof(int)
　　所以ptr实际是a[5]
　　但是prt与(&a+1)类型是不一样的(这点很重要)
　　所以prt-1只会减去sizeof(int*)
　　a，&a的地址是一样的，但意思不一样
a是数组首地址，也就是a[0]的地址，&a是对象（数组）首地址，
a+1是数组下一元素的地址，即a[1]，&a+1是下一个对象的地址，即a[5].
--------------------------------------------
5.　请问以下代码有什么问题：
　　int main()
　　　char *str=&a;
　　　strcpy(str，&hello&);
　　　printf(str);
　　　return 0;
　　答案：没有为str分配内存空间，将会发生异常。问题出在将一个字符串复制进一个字符变量指针所指地址。虽然可以正确输出结果，但因为越界进行内在读写而导致程序崩溃。
---------------------------------------------
6. char* s=&AAA&;
　　printf(&%s&，s);
　　s[0]='B';
　　printf(&%s&，s);
　　有什么错。
　　答案：
&AAA&是字符串常量。s是指针，指向这个字符串常量，所以声明s的时候就有问题。
cosnt char* s=&AAA&;
然后又因为是常量，所以对是s[0]的赋值操作是不合法的。
---------------------------------------------
7. int (*s[10])(int)表示的是什么。
　　答案：int (*s[10])(int)函数指针数组，每个指针指向一个int func(int param)的函数。
---------------------------------------------
8.　有以下表达式：
　　int a=248; b=4;
　　int const c=21;
　　const int *d=&a;
　　int *const e=&b;
　　int const *f const =&a;
　　请问下列表达式哪些会被编译器禁止。为什么。
　　*c=32;d=&b;*d=43;e=34;e=&a;f=0x321f;
　　答案：
*c这是个什么东东，禁止
　　*d说了是const， 禁止
　　e = &a说了是const禁止
　　const *f const =&a;禁止
------------------------------------------
9.　#include
　　#include
　　void getmemory(char *p)
　　　p=(char *) malloc(100);
　　　strcpy(p，&hello world&);
　　int main( )
　　　char *str=NULL;
　　　getmemory(str);
　　　printf(&%s/n&，str);
　　　free(str);
　　　return 0;
分析一下这段代码
　　答案：程序崩溃，getmemory中的malloc不能返回动态内存，free（）对str操作很危险
-----------------------------------------
10.　char szstr[10];
　　strcpy(szstr，&&);
　　产生什么结果。为什么。
　　答案：长度不一样，会造成非法的OS
------------------------------------------
11.要对绝对地址0x100000赋值，我们可以用(unsigned int*)0x100000 = 1234;
那么要是想让程序跳转到绝对地址是0x100000去执行，应该怎么做。
　　答案：*((void (*)( ))0x100000 ) ( );
　　首先要将0x100000强制转换成函数指针，即:
　　(void (*)())0x100000
　　然后再调用它:
　　*((void (*)())0x100000)();
　　用typedef可以看得更直观些:
　　typedef void(*)() voidFuncP
　　*((voidFuncPtr)0x100000)();
------------------------------------------
12.分析下面的程序：
　　void GetMemory(char **p，int num)
　　　*p=(char *)malloc(num);
　　int main()
char *str=NULL;
　　　GetMemory(&str，100);
　　　strcpy(str，&hello&);
　　　free(str);
　　if(str!=NULL)
　　strcpy(str，&world&);
printf(&\n str is %s&，str);软件开发网www.mscto.com
　getchar();
　　问输出结果是什么。
　　答案：输出str is world。
　　free只是释放的str指向的内存空间，它本身的值还是存在的.所以free之后，有一个好的习惯就是将str=NULL.
此时str指向空间的内存已被回收，如果输出语句之前还存在分配空间的操作的话，这段存储空间是可能被重新分配给其他变量的，
尽管这段程序确实是存在大大的问题（上面各位已经说得很清楚了），但是通常会打印出world来。
这是因为，进程中的内存管理一般不是由操作系统完成的，而是由库函数自己完成的。
　 　当你malloc一块内存的时候，管理库向操作系统申请一块空间（可能会比你申请的大一些），然后在这块空间中记录一些管理信息（一般是在你申请的内存 前面一点），并将可用内存的地址返回。但是释放内存的时候，管理库通常都不会将内存还给操作系统，因此你是可以继续访问这块地址的。
-------------------------------------------
13.char a[10]；
strlen(a)为什么等于15。
　　#include &stdio.h&
　　#include &string.h&
　　void main()
　　　char aa[10];
　　　printf(&%d&，strlen(aa));
　　答案：sizeof()和初不初始化，没有关系；
　　strlen()和初始化有关。
--------------------------------------------
14.char (*str)[20];/*str是一个数组指针，即指向数组的指针．*/
　　char *str[20];/*str是一个指针数组，其元素为指针型数据．*/
---------------------------------------------
　　#include
　　#include
　　#include
　　#include
　　#include
　　#include
　　typedef struct AA
　int b1:5;
　int b2:2;
　　void main()
　　　char cc[100];
　　　strcpy(cc，&abcdefghijklmnopqrstuvwxyz&);
　　　memcpy(&aa，cc，sizeof(AA));
　　　cout && aa.b1 & 　　　cout && aa.b2 & 　　}
输出结果是多少。
　　答案：-16和１
　 　首先sizeof(AA)的大小为4，b1和b2分别占5bit和2bit.经过strcpy和memcpy后，aa的4个字节所存放的值是: 0，1，2，3的ASC码，即110011所以，最后一步：显示的是这４个字节的前５位，和 之后的２位分别为：10000，和01，因为int是有正负之分
-----------------------------------------------
以上是互联网用户为您的的内容，在阿里云内部有更多的关于有关C/C++指针的经典面试题 - c语言程序开发技术文章的内容，欢迎继续使用右上角搜索按钮进行搜索指针、经典、以便于您获取更多的相关信息。
本文内容由互联网用户自发贡献自行上传，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任。如果您发现本社区中有涉嫌抄袭的内容，欢迎发送邮件至：zixun-group@service.aliyun.com 进行举报，并提供相关证据，工作人员会在5个工作日内联系你，一经查实，本站将立刻删除涉嫌侵权内容。
若您要投稿，删除文章请联系邮箱：zixun-group@service.aliyun.com
工作人员会在5个工作日内回复
C教程栏目为您免费提供
相关信息，包括
的信息 ，所有
相关内容均不代表阿里云的意见！投稿、删除文章请联系邮箱：zixun-group@service.aliyun.com，工作人员5个工作日内回复。