C语言题，求解释

int aaa(char *s)
{char *t=s;
while(*t++);
t--;
return(t-s);
}
为什么是求字符串s的长度呢？
1.这个你可以分析出来穿来的可定是字符串。然后while（*t++）赋空语句；表示循环到*t=\n位置；然后t--；移到前面的位置，就是abcd的d位置那d和第一个字符a来做比较大小。t与s两个指针只能做一个字符的指向然后通过++或者--来往后一个字母或是前一个字母这题主要目的他是把第一个字母和最后个字母来做比较

2.若有定义语句：int a[2][3],*p[3];则为什么p[0]=&a[1][2];
2.首先&a[1][2]这个是地址吧，那你意思就是p【0】为什么是地址对吧。*p[3]是个二维指针。也可以转换为二维数组表现方法有很多。p[0]是0行0列的首地址，写全应该是p[0]+0,p[0]+1.。。。这样

3.#include
void fun(int *a,int n)/*fun函数的功能是将a所指数组元素从大到小排序*/
{int t,i,j;
for(i=0;ifor(j=i+1;jif ((a[i]main()
{int c[10]={1,2,3,4,5,6,7,8,9,0},i;
fun(c+4,6);
for (i=0;i<10;i++) printf("%d,",c);
printf("\n");
}

结果是：1,2,3,4,9,8,7,6,5,0,
3.这个答案是对的呀，fun(c+4,6);这个1，2，3，4，5，6，7，8，9，0的a[4]地址转到形参去void fun(int *a,int n)那int *a指向是a[4]=5的地址上for(i=0;ifor(j=i+1;jn也是传上去的6.就看做是i<6-1;j<6;从5，6，7，8，9，0一共是6个数字没什么不对。然后for(i=0;i5，6，7，8，9，0进行处理后应该是9，8，7，6，5，0吧。9最大0最小依次下来
。返回到main方法。中加上前面的4个值1，2，3，4并且加上处理过的9，8，7，6，5，0那就变成1，2，3，4，9，8，7，6，5，0吧。

4.
#include
int fun(char s[])
{int n=0;
while(*s<=’9’&&*s>=’0’) {n=10*n+*s-’0’;s++;}
return(n);
}
main()
{char s[10]={’6’,’1’,’*’,’4’,’*’,’9’,’*’,’0’,’*’};
printf("%d\n",fun(s));
}

为什么是61？
4.这个就是说遇到了不是数字就跳出while循环6，1，*所以跳出来用return返回他只读到61
while(*s<=’9’&&*s>=’0’) {n=10*n+*s-’0’;s++;}第一个6符合条件。然后10*0+6指向下个。然后是1进去符合条件。n此时已经等于6了10*6+1=61吧。然后*进去不符合条件。立即将61用return返回！

5.
有以下程序：
#include
void fun(char *t,char *s)
{
while(*t!=0)t++;
while((*t++=*s++)!=0);
}
main()
{
char ss[10]=”acc”,aa[10]=”bbxxyy”;
fun(ss,aa);
printf(“%s,%s\n”,ss,aa);
}
程序运行结果是accbbxxyy,bbxxyy

5.
有以下程序：
#include
void fun(char *t,char *s)
{
while(*t!=0)t++;
while((*t++=*s++)!=0);
}
main()
{
char ss[10]=”acc”,aa[10]=”bbxxyy”;
fun(ss,aa);
printf(“%s,%s\n”,ss,aa);
}
程序运行结果是accbbxxyy,bbxxyy
5.while((*t++=*s++)!=0);这个其实是赋值语句呀。ss=“acc”，aa=“bbxxyy”先while(*t!=0)t++;循环到acc\0最后字符的时候*t++=*s++然后这样*t=*s然后++一直到*s==0的时候，*t不是等于acc连接了*s里面的字符“bbxxyy”然后返回来给ss，aa没变呀输出的是accbbxxyy，bbxxyy

6.#include
#include
void fun(char s[][10],int n)
{
char t;int i,j;
for(i=0;ifor(j=i+1,j/*比较字符串的首字符大小，并交换字符串的首字符 */
if(s[0])>s[j][0]{t=s[0];s[0]=s[j][0];s[j][0]=t;}
}
main()
{
char ss[5][10]={“bcc”,”bbcc”,”xy”,”aaaacc””aabcc”}
fun(ss,5); printf(“%s,%s\n”,ss[0],ss[4]);
}

为什么是aaaacc,xy
6.这题他注释已经告诉你为什么答案是这个了。首先我们不看其他函数，没有预处理文件，我们按规程办事，看main（）方法一直到fun(ss,5)这里将5个字符串和5附到fun形参里并已经开始调用了，然后看fun函数接受过来以后for(i=0;is[j][0]{t=s[0];s[0]=s[j][0];s[j][0]=t;}如果前面的比后面的大，相互互换，那前面肯定到最后是最小咯。那后面我也不看了。你就看他最小的字符串是多少。按ASKII来比，又都是小写的，较头字母a最小吧。那只有aaaacc和aabcc吧。那第三个字母一个是a一个事b哪个最小不是出来了吗。在看最大的。x头字母没有比他大的了，所肯定是x带头的字符串是最大的。所以要求输出a[0]最小是aaaacc,a[4]是最上标也就是最大不就是xy吗？

7.有以下程序
#include
int a=1;
int f(int c)
{static int a=2;
c=c+1;
return (a++)+c;}
main()
{ int i,k=0;
for(i=0;i<2;i++){int a=3;k+=f(a);}
k+=a;
printf(“%d\n”,k);
}
程序运行结果是14
7.这题有点陷阱了，先是3到f函数定义了个static int a=2；就是说第一次调用好以后a=a++吗，返回的是3+1+2=6第二次调用的时候a！=2了而是3返回的是3+1+3=7然后k=6+7=13然后k+a=13+3=16. 这题目有点不对。首先在main（）函数里面没有定义过a，而你在for循环a=3就会出现异常。即使定义了，最后结果也不是14.

8.有以下程序
#include
void fun(int n,int *p)
{ int f1,f2;
if(n==1||n==2) *p=1;
else
{ fun(n-1,&f1); fun(n-2,&f2);
*p=f1+f2;
}
}
main()
{ int s;
fun(3,&s); printf("%d\n",s);
}
程序的运行结果是2
8.首先是将3和没有值的s地址赋给fun函数里的形参3！=1！=2所以执行else语句里面有递归fun（n-1，&f1）先再调用此，可是第一次调用还没有结束，先挂在这边都结束了再来。
n-1=3-1=2就符合if语句了*p=1=f1.也就是说f1=1然后后面的调用结束，在来看没有完成的第一调用的地方。结束了一个递归，又来了，第二波不要被他吓到，（一波未平一波又起，但是最后还是死在沙滩上）进去第二次循环此时n=3不是n=2因为n=2是第二次的循环，还这里还是3.所以3-2=1和f2的地址再调用同样符合条件*p=1=f2 f2也等于1 ，最后*p=1+1=2返回给最初的调用s的地址上所有s=2

9.有以下程序
#include
struct tt
{int x;struct tt *y;} *p;
struct tt a[4]={20,a+1,15,a+2,30,a+3,17,a};
main()
{ int i;
p=a;
for(i=1;i<=2;i++) {printf("%d,",p->x); p=p->y;}
}
程序的运行结果是20，15
9.struct tt {int x;struct tt *y;} *p; /*定义结构体吧。成员变量为int x 和 tt *y类型的指针相当于*next为了指向下一个的*/
struct tt a[4]={20,a+1,15,a+2,30,a+3,17,a};在函数体外，就是全局变量咯
p=a; /*p指向a也就是说p是头指针*/
for(i=1;i<=2;i++) {printf("%d,",p->x); p=p->y;}/*循环2次，都输出p.y也即是p的下一个指向*/
我画个图应该可以理解了

|---------| |---------| |---------| |---------| |---------|
| p | ====== | a[0] | -----> | a[1] | -----> | a[2] | ----> | a[3] |
|---------| |---------| |---------| |---------| |---------|
这就是这个图形p和a[0]是一个地址其他4个a[0]-a[3]都是有int x;struct tt *y;的struct tt *y表示图上的----》指向下个位置x为里面的值第一次循环p.x也就是a[0].x是首地址吧20然后p=p->y;y就是a+1就是----》知道a[1]了然后第二次循环输出a[1].x=15吧。
所以最后答案就是20，15

10.有以下程序
#include
#include
typedef struct{ char name[9];char sex; float score[2]; } STU;
STU f(STU a)
{ STU b={"Zhao",'m',85.0,90.0}; int i;
strcpy(a.name,b.name);
a. sex=b.sex;
for(i=0;i<2;i++) a.score=b.score;
return a;
}
main()
{STU c={"Qian",'f',95.0,92.0},d;
d=f(c); printf("%s,%c,%2.0f,%2.0f\n",d.name,d.sex,d.score[0],d.score[1]);
}
程序的运行结果是Zhao,m,85,90
10.这个就是简单利用拷贝关系，先定义了结构体STU类型,然后在main函数里定义了STU c={"Qian",'f',95.0,92.0},d;变量并赋值了，这个我们叫初始化。然后放到f（）函数里的形参去也就是STU a然f（）方法里面也定义了STU b={"Zhao",'m',85.0,90.0};变量并赋值
strcpy(a.name,b.name);这个事字符串里的拷贝把b里面的name全部覆盖掉a里面的name并拷贝。a.name这时候是zhao和b是一样的了。a.sex=b.sex将b的性别赋给a的性别，也就是改掉原来的值了。a和b现在一样了，最后循环两次，a.score=b.score;一样将成绩也改成b的了。所以现在a不是原来的a了，而是b的数据了。

11。
有以下程序
#include
main()
{ int a=1,b=2,c=3,x;
x=(a^b)&c; printf("%d\n",x);
}
程序的运行结果是3
11.这个是位于运算符,^和&异或然后与得运算先将1，2，3转换成2进制1=00000001，2=00000010，3=00000011异或是有一个1（真）就是1（真），00000001^00000010=00000011而00000011&00000011是与运算遇到都是1（真）才是真否则都是0（假）那么那个都是一样的地方有1所以答案还是原来的00000011再转换成10进制1+2的1次方=3

12有以下程序
#include
main()
{FILE *fp; int a[10]={1,2,3,0,0},i;
fp=fopen("d2.dat,"wb");
fwrite(a,sizeof(int),5,fp);
fwrite(a,sizeof(int),5,fp);
fclose(fp);
fp=fopen("d2.dat","rb");
fread(a,sizeof(int),10,fp);
fclose(fp);
for(i=0;i<10;i++) printf("%d",a);
}
为什么是：1,2,3,0,0,1,2,3,0,0,
12.这题是关系到文件fwrite（a，size（int），5，fp）函数是将a里面的数据1，2，3，0，0写到fp指向的d2。dat中去然后又出现了一遍fwrite（a，size(int),5,fp）照前面在执行此，就是在12300后面再写一遍12300所以最后，用fread（a,sizeof(int),5,fp）将fp的东西放到a里面去也就是是拷贝了。所以1230012300

啊这个都是基础的问题。不过很烦，希望你努力分析，不管什么，考试还好，还是分析程序还好，看有没有预处理的。就先看预处理的。然后看有没有全局变量或者结构体的，没有就看main（）函数，这个就是不变的步骤，没有其他的变数。

确实你的问题不少啊，第一，二题，楼上那位已经解决了

第三题：if (a(a[i]明白了a[0]=5解决这个问题就应该不难了

第四题：
第一次执行while循环时，*s='6',执行n=10*n+*s-’0’;s++;后n=6，s指向数组的下一位即*s='1'，再次执行while循环，n就等于61啦，*s指向'*',不能满足while循环的条件，结束

第五题：
fun（）里的第一个while循环结束时t指向数组的尾部（b的后一位）；*t++=*s++的意思可分解为*t=*s(赋值)，t++，s++，这条语句使得s数组全体连接到t数组的后面（s数组仍在）

第六题：
if（s[0])>s[j][0]是什么意思

第七题：
注意全局变量，局部变量和static变量的区别
for（）第一次循环后k=6；第二次循环时注意f（a）的返回值是7，因为f（）函数里的a是static变量，它的值是三了（因为在第一次循环里执行了a++），最后执行k+=a（a是全局变量等于1），所以k=6+7+1

第八题：
注意递归调用
先n=3，执行fun(n-1,&f1)（递归调用fun（）），使得f1=1;再执行 fun(n-2,&f2)，使得f2=1;

第九题：
注意结构体的内部定义
a[4]是4个结构体元素的数组，a[0]={20，a+1}，a[1]={15，a+2}，以此类推
先输出p->x是20，再p=p->y=a+1使得p指向a[1],再输出p->x时自然是15

第十题：
函数STU f(STU a)的作用是使得啊等于b，所以d等于b

第十一题：
^是按位或运算符，&是按位与运算符，a^b是0000000000000001^0000000000000010结果是0000000000000011再与c进行&运算结果还是0000000000000011，即十进制3

第十二题：
fwrite(a,sizeof(int),5,fp);是从a数组里取出5个int型的数据写入fp中，两次写入之后，fp中的数据是1，2，3，0，0，1，2，3，0，0；fread(a,sizeof(int),10,fp);是从fp中读10个int型数据写入a中，所以最后的输出是那样的

哎，你问的问题也太多了，先给你解两个吧：
第一个：
字符串末尾都有“\0”
while(*t++);执行这一句，如果指针t未指向末尾则继续向后移动，因为后面直接写了一个“;” 所以t不到字符串末尾，执行空语句，而不是执行：t--。
当t到末尾时，退出循环，执行 t--，因为最后的“\0”不计入字符串的长度，所以其值要再减1！
首地址末地址之差就是实际长度。

第二个：
int a[2][3],*p[3];则为什么p[0]=&a[1][2];
p为指针数组，即其里面的元素p[0],p[1]等都代表的是地址，所以对于数组a中的元素a[1][2]要取地址。

关于 用 指针，指针数组，数组指针 访问 一维数组 二维数组 的程序，看下面的几个程序吧：

用指针，指针数组，数组指针 访问一维数组和二维数组，指针的初始化和数组元素的输出容易混淆。分析一下几个小例子：

/*
#include
using namespace std;
int main()
{
int a[3] ={0,1,2};
int *p;//int 型指针访问一维数组
p = a;
int i;
for(i=0;i<3;i++)
cout<<*(p)++<}
*/

/*
#include
using namespace std;
int main()
{
int a[3] ={0,1,2};
int (*p)[3];//用数组指针访问一维数组
p = &a;
int i;
for(i=0;i<3;i++)
cout<<*(*(p)+i)<}
*/

#include
int main()
{
int a[3]={0,1,2};
int *p[1];//用指针数组访问一维数组
p[0] = a;
int i;
for(i=0;i<3;i++)
printf("%d\n",*(*p+i));//或者printf("%d\n",*((*p)++));
}

/*
#include
using namespace std;
int main()
{
int a[2][3]={0,1,2,3,4,5};
int *p;//int 指针访问二维数组
for(p =a[0];p cout<<*p++<}
*/

/*
#include
using namespace std;
int main()
{
int a[2][3] ={0,1,2,3,4,5};
int (*p)[3];// 数组指针访问二维数组
p = a;
int i,j;
for(i=0;i<2;i++)
for(j=0;j<3;j++)
cout<<*(*(p+i)+j)<}
*/
/*#include
using namespace std;
int main()
{
int a[2][3]={0,1,2,3,4,5};
int i,j,*p[2];//指针数组访问二维数组
p[0] = a[0];p[1]=a[1];//*p[2] = {a[0],a[1]};
for(i=0;i<2;i++)
for(j=0;j<3;j++)
cout<<*(*(p+i)+j)<}*/

其他的自己慢慢分析吧，就那几行，想必不是很困难，学着调试，看看每执行一步各个变量的变化情况~，仔细分析出来，比问别人而学会更好。

愉快~

蚝油难度