《计算机程序设计基础》指针程序练习

指针程序练习1.c #include ∥预编译命令 void maino ∥主函数 ∥函数体开始 int i char s[="abcdef; ∥/S为字符数组 char*t="abcdef t为指向字符数组的指针变量 char*p={ abcdef;"ghjk","mnop"," gust};/为指针数组变量,p数组元素依次指向 ∥字符串" abcdef";" ghijk","mnop";" grstuv' char*q卩={p,p+2p+3,p+1};∥q为指针数组变量,q数组元素依次指向指针数组元素p[O],p2],p[3],p[ char* *r-g ∥r为3级指针变量,是指向指针数组q的指针,而q又是指向指针数组p的指针 printf( %sⅦn";p) printf("Q1:下述等式成立吗?p0]=*(p+0)=pinn);∥测试p[O*(p+0),p三者是否相同 f(p[0]==*(p+0)&&('p=p[oD) printf("It成立!n") ∥成立 printf("输出'为%sn",p);∥输出 abcdef printf(输出*(p+0)为%sⅦn",`(p+0);∥输出 abcdef printf(输出p[]为%sⅦn",p[0);∥输出 abcdef printf输出s为%sⅦn"sS); ∥输出 abcdef

指针程序练习1.c #include //预编译命令 void main() //主函数 { //函数体开始 int i; char s[] = "abcdef"; //s{]为字符数组 char* t = "abcdef"; //t为指向字符数组的指针变量 char* p[]={"abcdef","ghijk","lmnop","qrstuv"}; //p为指针数组变量，p数组元素依次指向 //字符串"abcdef","qhijk","lmnop","qrstuv" char** q[]={p,p+2,p+3,p+1}; // q 为指针数组变量，q数组元素依次指向指针数组元素 p[0] , p[2] , p[3] , p[1] char** *r=q; // r 为 3 级指针变量，是指向指针数组q 的指针，而q 又是指向指针数组p 的指针 /////////////////////////////////////////////////////////////// printf("----------------------%s\n",*p); printf(“Q1:下述等式成立吗？p[0]= *(p+0) = *p\n\n”); //测试 p[0],*(p+0),*p 三者是否相同 if( p[0] == *(p+0)) && (*p=p[0]) ) printf(“\t成立!\n"); //成立 printf(" 输出 *p 为%s\n",*p); //输出abcdef printf(" 输出*(p+0)为%s\n",*(p+0)); //输出abcdef printf(" 输出 p[0] 为%s\n",p[0]); //输出abcdef printf(" 输出 s 为%s\n",s); //输出abcdef }

指针程序练习2c void maino ∥主函数 ∥数体开始 int i: char sl="abcdef S为字符数组 t为指向字符数组的指针变量 char*pl= fabcdef";" ghijk","mnop"," qustus"};为指针数组变量,p数组元素依次指向 ∥}字符串" abcdef";" ghijk","mnop"; grstuv char*q卩={pp+2p+3p+1};∥q为指针数组变量,q数组元素依次指向指针数组元素p[O],p[2],p3]p[1 char** *r=q ∥r为3级指针变量,是指向指针数组q的指针, printf"Q2:下述等式成立吗?q[2}*(q+2)=&(p3])=p+3nn");W测试q[2]*(q+2),&p[3]p+3四者是否相同 if(q|2]==(q+2)&& q[2]==&(p{3&& [2]==p+3) printf("nlt成立!n") ∥/成立 prnt输出q[2]为%Xn",q[2D;∥输出p[3]的地址 printi输出*(q+2)为%Xn";(q+2);∥输出p[3]的地址 printf"输出&p[3]为%Xn",&p[3);!输出p3]的地址 prnt输出p+3为%Xn",p+3);∥输出p3]的地址

指针程序练习2.c void main() //主函数 { //函数体开始 int i; char s[] = "abcdef"; //s{]为字符数组 char* t = "abcdef"; //t为指向字符数组的指针变量 char* p[]={"abcdef","ghijk","lmnop","qrstuv"}; //p为指针数组变量，p数组元素依次指向 //字符串"abcdef","qhijk","lmnop","qrstuv" char** q[]={p,p+2,p+3,p+1}; // q 为指针数组变量，q 数组元素依次指向指针数组元素 p[0], p[2], p[3], p[1] char** *r = q ; // r 为 3 级指针变量，是指向指针数组 q 的指针， printf("Q2: 下述等式成立吗？q[2]= *(q+2)=&(p[3])= p+3\n\n"); //测试q[2],*(q+2),&p[3],p+3四者是否相同 if (q[2] == *(q+2) && q[2] == &(p[3]) && q[2] == p+3 ) printf("\n\t成立!\n"); // 成立 printf(" 输出 q[2] 为%X\n",q[2]); //输出p[3]的地址 printf(" 输出*(q+2) 为%X\n",*(q+2)); //输出p[3]的地址 printf(" 输出 &p[3] 为%X\n",&p[3]); //输出p[3]的地址 printf(" 输出 p+3 为%X\n",p+3); //输出p[3]的地址 }

指针程序练习3 void main( ∥主函数 ∥数体开始 nt i char sl="abcdef ∥/S为字符数组 char*t= abcdef 为指向字符数组的指针变量 char*pp={ fabcdef;"ghk"mnop;" qrst"};/为指针数组变量,p数组元素依次指向 ∥字符串" abcdef";" ghijk","mnop"; gust" char*q={p,p+2p+3,p+1};∥q为指针数组变量,q数组元素依次指向指针数组元素p0],p[2],p3],p1 charT = q ∥r为3级指针变量,是指向指针数组q的指针 printf("o3:下述等式成立吗?「[oJ[o]=sn);∥测试roI0]与s是否相同 pintfc"nroj[o]=qoo]=p[0o]=p[0]=s=Vabcde"Ⅶn"); if(r[oJo]==s pint(nt成立!nn";∥成立

指针程序练习3.c void main( ) //主函数 { //函数体开始 int i; char s[] = "abcdef"; //s{]为字符数组 char* t = "abcdef"; //t为指向字符数组的指针变量 char* p[]={"abcdef","ghijk","lmnop","qrstuv"}; //p为指针数组变量，p数组元素依次指向 //字符串"abcdef","qhijk","lmnop","qrstuv" char** q[]={p,p+2,p+3,p+1}; // q 为指针数组变量，q 数组元素依次指向指针数组元素 p[0] , p[2] , p[3] , p[1] char** *r = q ; // r 为 3 级指针变量，是指向指针数组q 的指针， printf(“Q3: 下述等式成立吗？r[0][0] = s \n”); // 测试 r[0][0] 与 s 是否相同 printf("\nr[0][0] = q[0][0] = p[0][0] = p[0] = s = \"abcdef\" \n"); if (r[0][0] == s) printf("\n\t成立!\n\n"); // 成立 }

指针程序练习4c void maino ∥主函数 ∥数体开始 char sl="abcdef ∥/s为字符数组 为指向字符数组的指针变量 char*p={" abcdef","ghjk","mnop"," qrst"};/为指针数组变量,p数组元素依次指向 ∥字符串" abcdef;"qhjk"mnop"," gustav" char*q=pp+2p+3,p+1};∥q为指针数组变量,q数组元素依次指向指针数组元素po],p[2],p3],p1 char** *r =q ∥r为3级指针变量,是指向指针数组q的指针 printf(G4:下述等式成立吗?rojo]=*([o+0)=*([oD=*(*(r+0)=*(r=*rn"); ∥测试ro[o](o+0),*(r[O])*((+O),*(')*六者是否相同 if(roo]='([0y+0)&& 「[0J[o]==([])&& [oJo]==*(*(r+0)&& 「oJo]==*T)&& 「[oJ[o]==*) printf("It成立!n ∥)立 print(“输出『oJ[O]为%sⅥn",r[oj[o);∥输出*的值,字符串 printf(“输出([o]+0)为%sⅦn,*([O]+0);/输出p[3的内容,字符串 printf("输出’(ro为%sⅦn",*(r[oD); ∥输出*r的值,字符串 printi输出*(*(r+0)为%sn";*(〔r+o);∥输出*r的值,字符串 printf(输出*(')为%sⅥn”,*(') 输出*('n)的值,字符串 printi(c输出*r为%sⅦn",*r); ∥输出*r的值,字符串

指针程序练习4.c void main() //主函数 { //函数体开始 int i; char s[] = "abcdef"; //s{]为字符数组 char* t = "abcdef"; //t为指向字符数组的指针变量 char* p[]={"abcdef","ghijk","lmnop","qrstuv"}; //p为指针数组变量，p数组元素依次指向 //字符串"abcdef","qhijk","lmnop","qrstuv" char** q[] = {p,p+2,p+3,p+1}; // q 为指针数组变量，q数组元素依次指向指针数组元素p[0] , p[2] , p[3] , p[1] char** *r = q ; // r 为 3 级指针变量，是指向指针数组q 的指针， printf("Q4: 下述等式成立吗？r[0][0]=*(r[0]+0)=*(r[0])=*(*(r+0))=*(*r)=**r\n"); ///测试r[0][0],*(r[0]+0),*(r[0]),*(*(r+0)),*(*r),**r六者是否相同 if (r[0][0] == *(r[0]+0) && r[0][0] == *(r[0]) && r[0][0] == *(*(r+0)) && r[0][0] == *(*r) && r[0][0] == **r) printf(“\t成立!\n"); //成立 printf(“ 输出 r[0][0] 为%s\n”,r[0][0]); //输出**r的值，字符串 printf(“ 输出 *(r[0]+0) 为%s\n”,*(r[0]+0)); //输出p[3]的内容，字符串 printf(" 输出 *(r[0]) 为 %s \n",*(r[0])); //输出**r的值，字符串 printf(" 输出 *(*(r+0)) 为 %s \n",*(*(r+0))); //输出**r的值，字符串 printf(“ 输出 *(*r) 为 %s\n”,*(*r)); //输出*(*r)的值，字符串 printf(“ 输出 **r 为 %s\n”, **r); //输出**r的值，字符串 }

指针程序练习5c #include ∥预编译命令 void maino ∥主函数 ∥函数体开始 int i char sl="abcdef ∥/S为字符数组 chart= abcdef 为指向字符数组的指针变量 char*p= fabcdef"; ghijk","mnop"," gostun"};为指针数组变量,p数组元素依次指向 ∥字符串" abcdef";"qhjk"," Inop"; qrst" char*q={p,p+2p+3,p+1};∥q为指针数组变量,q数组元素依次指向指针数组元素p0],p[2],p3],p1 char r=g ∥r为3级指针变量,是指向指针数组q的指针 ∥而q又是指向指针数组p的指针 printf("Q5:请观察下列结果n");∥观察&r,r,t,『],*r(%X,*0],*r(%s),忄0]的结果 printf("r变量本身的地址&radd1:%Xn",&r);∥输出r变量本身的地址 printf("r变量指向的地址radd1:%Xn",r);∥输出r变量指向的地址 printf(°·r指向的地址*add1:%Xvn",η;∥输出指向的地址 printffrO]指向的地址radd1:%Xn",ro);∥输出「o]指向的地址 printf*r指向的地址radd1:%Xvn",*η;∥输出*指向的地址 printf("·to指向的地址radd1:%Xn",o);∥输出↑0]指向的地址 prnt*r指向的内容radd1:%sⅦn",*η);∥输出*指向的内容 }(To指向的内容radd1:%sn",↑0;∥输出*0]指向的内容

指针程序练习5.c #include //预编译命令 void main() //主函数 { //函数体开始 int i; char s[] = "abcdef"; //s{]为字符数组 char* t = "abcdef"; //t为指向字符数组的指针变量 char* p[]={"abcdef","ghijk","lmnop","qrstuv"}; //p为指针数组变量，p数组元素依次指向 //字符串"abcdef","qhijk","lmnop","qrstuv" char** q[]={p,p+2,p+3,p+1}; // q 为指针数组变量，q 数组元素依次指向指针数组元素 p[0] , p[2] , p[3] , p[1] char** *r=q; // r 为 3 级指针变量，是指向指针数组q 的指针， // 而 q 又是指向指针数组p 的指针 printf("Q5: 请观察下列结果\n"); ///观察 &r, r, *r, r[0], **r(%x), *r[0], **r(%s), *r[0] 的结果 printf("r 变量本身的地址&r add1: %X\n", &r); // 输出 r 变量本身的地址 printf("r 变量指向的地址r add1: %X\n", r); // 输出 r 变量指向的地址 printf("*r 指向的地址 *r add1: %X\n", *r); // 输出 *r 指向的地址 printf("r[0] 指向的地址 r add1: %X\n", r[0]); // 输出 r[0] 指向的地址 printf("**r 指向的地址 r add1: %X\n", **r); // 输出 **r 指向的地址 printf("*r[0] 指向的地址r add1: %X\n", *r[0]); // 输出 *r[0] 指向的地址 printf("**r 指向的内容 r add1: %s\n", **r); // 输出 **r 指向的内容 printf("*r[0] 指向的内容r add1: %s\n", *r[0]); // 输出 *r[0] 指向的内容 }

指针程序练习6c #include ∥预编译命令 void maino ∥主函数 ∥数体开始 int i. char s[="abcdef ∥/S为字符数组 char*t="abcdef 优为指向字符数组的指针变量 char*p= fabcdef"; ghijk"mnop"," qrst"};p为指针数组变量,p数组元素依次指向 ∥字符串" abcdef";"qhjk","mnop" grstuv" char*q={pp+2,p+3p+1},∥q为指针数组变量,q数组元素依次指向指针数组元素p[],p[2],p3],p[1 char**=q;∥r为3级指针变量,是指向指针数组q的指针,而q又是指向指针数组p的指针 printf"Q6:请观察下列结果Ⅶ");∥观察&,r,*,r1,*r(%X),*1,*r(%S),1]的结果 printer变量本身的地址&radd1:%Xn",&r);∥输出r变量本身的地址 printf("r变量指向的地址rad1:%Xn",n);∥输出r变量指向的地址 printf("r指向的地址'radd1:%XⅦn",n;∥输出晳指向的地址 printf("t1指向的地址radd1:%Xn",r1;∥输出1指向的地址 printf*r指向的地址radd1:%Xvn",*η;∥输出*r指向的地址 pint·t指向的地址radd1:%Xn",[1);∥输出气1指向的地址 printf("**r指向的内容radd1:%sⅦn",*η);∥输出*指向的内容 printf"·t]指向的内容radd1:%sⅦn",1);∥输出气们指向的内容

指针程序练习6.c #include //预编译命令 void main() //主函数 { //函数体开始 int i; char s[] = "abcdef"; //s{]为字符数组 char* t = "abcdef"; //t为指向字符数组的指针变量 char* p[]={"abcdef","ghijk","lmnop","qrstuv"}; //p为指针数组变量，p数组元素依次指向 //字符串"abcdef","qhijk","lmnop","qrstuv" char** q[]={p,p+2,p+3,p+1}; // q 为指针数组变量，q 数组元素依次指向指针数组元素 p[0] , p[2] , p[3] , p[1] char** *r=q; // r 为 3 级指针变量，是指向指针数组q 的指针，而q 又是指向指针数组p 的指针 printf("Q6: 请观察下列结果\n"); // 观察 &r, r, *r, r[1], **r(%x), *r[1], **r(%s), *r[1] 的结果 printf("r 变量本身的地址&r add1: %X\n", &r); // 输出 r 变量本身的地址 printf("r 变量指向的地址r add1: %X\n", r); // 输出 r 变量指向的地址 printf("*r 指向的地址 *r add1: %X\n", *r); // 输出 *r 指向的地址 printf("r[1] 指向的地址 r add1: %X\n", r[1]); // 输出 r[1] 指向的地址 printf("**r 指向的地址 r add1: %X\n", **r); // 输出 **r 指向的地址 printf("*r[1] 指向的地址r add1: %X\n", *r[1]); // 输出 *r[1] 指向的地址 printf("**r 指向的内容 r add1: %s\n", **r); // 输出 **r 指向的内容 printf("*r[1] 指向的内容r add1: %s\n", *r[1]); // 输出 *r[1] 指向的内容 }

指针程序练习7 #include J预编译命令 void maino ∥主函数 ∥函数体开始 char sl ="abcdef /s为字符数组 char t="abcdef t为指向字符数组的指针变量 char*p{" abcdef,"ghjk","'mnop"" gustav》;伽为指针数组变量,p数组元素依次指向 ∥字符串" abcdef,"qhjk","mnop";qrst char** q{pp+2p+3,p+1}№为指针数组变量,q数组元素依次指向指针数组元素p[O],p2],p3],p[1 char*'r=q;∥r为3级指针变量,是指向指针数组q的指针,而q又是指向指针数组p的指针 ∥注意:'(0]俘等价于on,等价于(r) ∥再注意:气们等价于([1),等价于*(r+1),等价于*(r+1) ∥注意:f指向的地址是q[]本身的地址,r+1应该是q1的地址 ∥注意:(r+1)等价于q1],*(r+1)等价于*q[1,而q]等价于p2] ∥注意:因此'1等价于*(r+1),等价于q[1],等价于p[2 printf("Q7:请观察下列结果mn"); printf("t1的地址:%XⅦn",1;∥输出气1所代表的地址值 rintfr[0]+2: %XIn, r[0F+2) ∥输出0J+2所代表的地址值 printf(+2]:%XMn",「2D ∥输出四2所代表的地址值 printf("r变量本身的地址:%Xln",&r);∥输出r变量本身的地址 printf("r变量指向的地址:%Xvn",r);∥输出r变量指向的地址 printi("r指向的地址:%Xn",T);∥输出气指向的地址 intr"2]指向的地址:%Xn",2;∥输出(2]指向的地址 printf(*r指向的地址:%Xmn”,*t);∥输出*r指向的地址 intr"12]指向的地址:%Xmn",'2;∥输出气2]指向的地址 printf(*r指向的内容:%sⅦn",*);∥输出*r指向的内容 printf("t2]指向的内容:%sn,2D;∥输出'[2]指向的内容

指针程序练习7.c #include //预编译命令 void main() //主函数 { //函数体开始 int i; char s[] = "abcdef"; //s{]为字符数组 char* t = "abcdef"; //t为指向字符数组的指针变量 char* p[]={"abcdef","ghijk","lmnop","qrstuv"}; //p为指针数组变量，p数组元素依次指向 //字符串"abcdef","qhijk","lmnop","qrstuv" char** q[]={p,p+2,p+3,p+1}; //q为指针数组变量，q数组元素依次指向指针数组元素 p[0] , p[2] , p[3] , p[1] char** *r=q; // r 为 3 级指针变量，是指向指针数组 q 的指针，而 q 又是指向指针数组 p 的指针 // 注意：*r[0]等价于*(r[0])，等价于*(*r) // 再注意：*r[1]等价于*(r[1])，等价于*(*(r+1))，等价于**(r+1) // 注意：r指向的地址是q[0]本身的地址，r+1应该是q[1]的地址 // 注意：*(r+1)等价于q[1]，**(r+1)等价于*q[1]，而*q[1]等价于p[2] // 注意：因此*r[1]等价于**(r+1)，等价于 *q[1]，等价于p[2] printf("Q7: 请观察下列结果\n"); printf("*r[1]的地址: %X\n", *r[1]); // 输出 *r[1]所代表的地址值 printf("r[0]+2: %X\n", r[0]+2); // 输出 r[0]+2所代表的地址值 printf("r[2]: %X\n", r[2]); // 输出 r[2]所代表的地址值 printf("r 变量本身的地址: %X\n", &r); // 输出 r 变量本身的地址 printf("r 变量指向的地址: %X\n", r); // 输出 r 变量指向的地址 printf("*r 指向的地址: %X\n", *r); // 输出 *r 指向的地址 printf("r[2] 指向的地址: %X\n", r[2]); // 输出 r[2] 指向的地址 printf("**r 指向的地址: %X\n", **r); // 输出 **r 指向的地址 printf("*r[2] 指向的地址: %X\n", *r[2]); // 输出 *r[2] 指向的地址 printf("**r 指向的内容: %s\n", **r); // 输出 **r 指向的内容 printf("*r[2] 指向的内容: %s\n", *r[2]); // 输出 *r[2] 指向的内容 }

指针程序练习8c #include ∥预编译命令 void maino ∥主函数 ∥数体开始 char s[="abcdef' ∥/S为字符数组 chart=abcdef 为指向字符串的指针变量 char*p= fabcdef;ghjk;mnop," qrst"};仰为指针数组变量,p数组元素依次指向字符串 abcdef, "ghijk,"lmnop", " grstuv' char*q={pp+2p+3,p+1};∥q为指针数组变量,q数组元素依次指向指针数组元素p[O]p[2]p3p[1 char**r=q;∥r为3级指针变量,r是指向指针数组q的指针,而q又是指向指针数组p的指针 printf("Q8:请观察输出结果Ⅶnn";∥观察输出结果 printf("输出『3J[2]所指向的字符串%sn",「3]2);∥输出「3]2]所指向的字符串 printf"输出r+3所指向的地址:%Xn",(r+3);∥输出r+3所指向的地址 printf("输出「+3地址中的值所指向的地址:%Xn",*(r+3);∥输出「+3地址中的值所指向的地址 printf("输出r+3地址中所指向的地址加上偏移量2后的地址:%Xn",〔+3)+2) printf("输出**(r+3)+2)所指向的地址:%Xnn",*('(r+3)+2); J输出r+3地址中的值所指向的地址加上偏移量2后的地址中的地址 prnt"输出32所指向的地址r3j[2]:%Xn",r3I2〕);∥输出『3]I2]J所指向的地址 printi°输出’([3]+2)所指向的地址*(r3}+2):%Xn",*([3]+2);∥输出*(『[3]+2)所指向的地址 printf("输出(r+3)+2)所指向的地址**(r+3)+2):%Xn",+3)+2);∥输出'([3]+2)所指向的地址 printf("输出(r+3)+2)所指向的字符串**(r+3)+2):%sin",*(*(r+3)+2);∥输出’(3]+2)所指向的字符串

指针程序练习8.c #include //预编译命令 void main() //主函数 { //函数体开始 int i; char s[] = "abcdef"; //s[]为字符数组 char* t = "abcdef"; //t为指向字符串的指针变量 char* p[]={“abcdef”,“ghijk”,“lmnop”,“qrstuv”}; //p为指针数组变量，p数组元素依次指向字符串 "abcdef","qhijk","lmnop","qrstuv" char** q[]={p,p+2,p+3,p+1}; // q 为指针数组变量，q 数组元素依次指向指针数组元素 p[0],p[2],p[3],p[1] char** *r=q; // r 为 3 级指针变量，r 是指向指针数组q 的指针, 而 q 又是指向指针数组p 的指针 printf("Q8: 请观察输出结果\n\n"); //观察输出结果 printf("输出r[3][2]所指向的字符串%s\n", r[3][2]); //输出r[3][2]所指向的字符串 printf("输出 r+3 所指向的地址: %X\n", (r+3)); // 输出 r+3 所指向的地址 printf("输出 r+3 地址中的值所指向的地址: %X\n", *(r+3)); // 输出 r+3 地址中的值所指向的地址 printf("输出 r+3 地址中所指向的地址加上偏移量2后的地址: %X\n", *(r+3)+2); printf("输出 *(*(r+3)+2)所指向的地址: %X\n\n", *(*(r+3)+2)); //输出 r+3 地址中的值所指向的地址加上偏移量2后的地址中的地址 printf("输出r[3][2]所指向的地址r[3][2]: %X\n", r[3][2]); //输出r[3][2]所指向的地址 printf("输出*(r[3]+2)所指向的地址*(r[3]+2): %X\n", *(r[3]+2)); //输出*(r[3]+2)所指向的地址 printf("输出*(*(r+3)+2)所指向的地址*(*(r+3)+2): %X\n", *(*(r+3)+2)); // 输出*(r[3]+2)所指向的地址 printf("输出*(*(r+3)+2)所指向的字符串*(*(r+3)+2): %s\n", *(*(r+3)+2)); // 输出*(r[3]+2)所指向的字符串 }