指针习题

指针练习题

(一)选择题

1．若有以下定义，则对a数组元素的正确引用是_________.

int a[5],*p=a;

a)*&a[5] b)a+2 c)*(p+5) d)*(a+2)

2．若有定义：int a[2][3],则对a数组的第i行j列元素地址的正确引用为______.

a)*(a[i]+j) b)(a+i) c)*(a+j) d)a[i]+j

3．若有以下定义，则p+5表示_______.

int a[10],*p=a;

a)元素a[5]的地址b)元素a[5]的值

c)元素a[6]的地址d)元素a[6]的值

4．下面程序段的运行结果是_________.

char *s="abcde";

s+=2;printf("%d",s);

a)cde b)字符'c' c)字符'c'的地址d)无确定的输出结果

5．设p1和p2是指向同一个字符串的指针变量，c为字符变量，则以下不能正确执行的赋值语句是__b______.

a)c=*p1+*p2; b)p2=c（c为变量）c)p1=p2 d)c=*p1*(*p2);

6．以下正确的程序段是_________.

a)char str[20]; b)char *p;

scanf("%s",&str); scanf("%s",p);

c)char str[20]; d)char str[20],*p=str;

scanf("%s",&str[2]); scanf("%s",p[2]);

7．若有说明语句

char a[]="It is mine";

char *p="It is mine";

则以下不正确的叙述是________.

a)a+1表示的是字符t的地址

b)p指向另外的字符串时，字符串的长度不受限制

c)p变量中存放的地址值可以改变

d)a中只能存放10个字符

8．下面程序的运行结果是_______.

#include

#include

main()

{

char *s1="AbDeG";

char *s2="AbdEg";

s1+=2;s2+=2;

printf("%d\n",strcmp(s1,s2));

}

a)正数b)负数c)零d)不确定的值

9．下面程序的运行结果是_______.

#include

#include

fun(char *w,int n)

{char t,*s1,*s2;

s1=w;s2=w+n-1;

while(s1

}

main()

{char *p;

p="1234567";

fun(p,strlen(p));

puts(p);

}

a)7654321 b)1714171 c)1711717 d)7177171

10．变量的指针，其含义是指该变量的b_________.

a)值b)地址

c)名d)一个标志

11．若有语句int *point,a=4;和point=&a;下面均代表地址的一组选项是__d___.

a)a,point,*&a b)&*a,&a,*point

c)*&point,*point,&a d)&a,&*point ,point

12．若有说明;int *p,m=5,n;以下正确的程序段的是_____d___.

a)p=&n; b)p=&n;

scanf("%d",&p); scanf("%d",*p);

c)scanf("%d",&n); d)p=&n;

*p=n; （*p没有定义）*p=m;

(二)填空题

1．以下程序的功能是：通过指针操作，找出三个整数中的最小值并输出。

请填空。

#include "stdlib.h"

main()

{int *a,*b,*c,num,x,y,z;

a=&x;b=&y;c=&z;

printf("输入3个整数：");

scanf("%d%d%d",a,b,c);

printf("%d,%d,%d\n",*a,*b,*c);

num=*a;

if(*a>*b)______;

if(num>*c)______;

printf("输出最小整数:%d\n",num);

}

2．下面程序段的运行结果是________.

char s[80],*sp="HELLO!";

sp=strcpy(s,sp);

s[0]='h';

puts(sp);

3．下面程序段的运行结果是________.

char str[]="abc\0def\0ghi",*p=str;

printf("%s",p+5);

4．下面程序的功能是将两个字符串s1和s2连接起来。请填空。

#include

main()

{char s1[80],s2[80];

gets(s1); gets(s2);

conj(s1,s2);

puts(s1);

}

conj(char *p1,char *p2)

{char *p=p1;

while(*p1)______;

while(*p2){*p1=______;p1++;p2++;}

*p1='\0';

__________;

}

5．若有定义:int a[]={2,4,6,8,10,12},*p=a;则*(p+1)的值是______. *(a+5)的值是_________.

6．若有以下定义:int a[2][3]={2,4,6,8,10,12};则a[1][0]的值是_____. *(*(a+1)+0))的值是________.

7．以下程序将数组a中的数据按逆序存放，请填空。

#define M 8

main()

{int a[M],i,j,t;

for(i=0;i

i=0;j=M-1;

while(i

{

t=*(a+i);________;*(_______)=t;

i++;j--;

}

for(i=0;i

}

8．若有定义：int a[3][5],i,j;(且0<=i<3,0<=j<5),则a数组中任一元素可用

五种形式引用。它们是：

(1)a[i][j]

(2)*(a[i]+j)

(3)*(*______);

(4)(*(a+i))[j]

(5)*(____+5*i+j)

9．下面程序的运行结果是_________.

main()

{char *a[]={"Pascal","C language","dBase","Coble"};

char (**p)[];

int j;

p=a+3;

for(j=3;j>=0;j--)printf("%s\n",*(p--));

}

(三)程序设计题(要求用指针的方法完成)

1．编写程序，交换数组a和数组b中的对应元素。

2．有10个数围成一圈，求出相邻三个数之和的最小值。

3．产生动态数组。输入数组大小后，通过动态分配内存函数malloc产生数组。4．编写程序，将一个字符串反向存放。

5．输入一串英文文字，统计其中字母(不区分大小写)的数目。

C语言指针实验报告

C语言程序设计实验报告 1实验目的 （1）掌握指针的概念，会定义和使用指针变量； （2）能正确使用变量的指针和指向变量的指针变量； （3）能正确使用数组的指针和指向数组的指针变量； （4）能正确使用字符串的指针和指向字符串的指针变量； 2实验内容 将一个任意整数插入到已排序的整形数组中，插入后，数组中的数仍然保持有序；要求： （1）整形数组直接由赋值的方式初始化，要插入的整数有scanf()函数数入；（2）算法实现过程采用指针进行处理； （3）输入原始数据以及插入整数后的数据，并加以说明；

3算法描述流程图

4源程序 #include main() { int a[100],m,i,*p,n,w; printf("请输入要输入的数组的元素个数：\n"); scanf("%d",&n); printf("请输入已排好序的数组：\n"); for(i=0;i=w;i--) { a[i+1]=a[i]; } a[i+1]=m; for(i=0;i<=n;i++) { printf("%-4d",a[i]); } printf("\n"); } 5测试数据 “1,3,5,7,9,11,13,15,17,19······10” 6运行结果 7出现问题及解决方法 在编写过程中，

for(i=n-1;a[i]>=w;i--) { a[i+1]=a[i]; } a[i+1]=m; 这一步没有注意a[i++]=m和a[i+1]=m中i++和i+1不同，a[i++]=m是先将的值赋给a[i]，然后在执行自增；而在实验过程中忽略了这一点，造成了不必要的麻烦； 8实验心得 通过这次指针实验掌握了指针的概念，会定义和使用指针变量，并且能利用指针来简单化一些问题，给以后的编程带来了很大的便利；

关于堆栈和指针(指针例子解释很好)

关于堆栈和指针 堆栈是一种执行“后进先出”算法的数据结构。 设想有一个直径不大、一端开口一端封闭的竹筒。有若干个写有编号的小球，小球的直径比竹筒的直径略小。现在把不同编号的小球放到竹筒里面，可以发现一种规律：先放进去的小球只能后拿出来，反之，后放进去的小球能够先拿出来。所以“先进后出”就是这种结构的特点。 堆栈就是这样一种数据结构。它是在内存中开辟一个存储区域，数据一个一个顺序地存入（也就是“压入——push”）这个区域之中。有一个地址指针总指向最后一个压入堆栈的数据所在的数据单元，存放这个地址指针的寄存器就叫做堆栈指示器。开始放入数据的单元叫做“栈底”。数据一个一个地存入，这个过程叫做“压栈”。在压栈的过程中，每有一个数据压入堆栈，就放在和前一个单元相连的后面一个单元中，堆栈指示器中的地址自动加1。读取这些数据时，按照堆栈指示器中的地址读取数据，堆栈指示器中的地址数自动减1。这个过程叫做“弹出pop”。如此就实现了后进先出的原则。 堆栈是计算机中最常用的一种数据结构，比如函数的调用在计算机中是用堆栈实现的。 堆栈可以用数组存储，也可以用以后会介绍的链表存储。 下面是一个堆栈的结构体定义，包括一个栈顶指针，一个数据项数组。栈顶指针最开始指向-1,然后存入数据时，栈顶指针加1，取出数据后，栈顶指针减1。 #define MAX_SIZE 100 typedef int DATA_TYPE; struct stack { DATA_TYPE data[MAX_SIZE]; int top; }; 堆栈是系统使用是临时存储区域。它是后进先出的数据结构。 C++主要将堆栈用于函数调用。当函数调用时，各种数据被推入堆栈顶部；函数终止后的返回地址、传递给函数的参数、函数返回的结果以及函数中声明的局部变量等等。因此当函数A调用函数B调用函数C，堆栈是增长了，但调用完成后，堆栈又缩小了。 堆是一种长期的存储区域。程序用C++的new操作符分配堆。对new的调用分配所需的内存并返回指向内存的指针。与堆栈不同，你必须通过调用new明确的分配堆内存。你也必须通过调用C++的delete 操作符明确的释放内存，堆不会自动释放内存。 如果C++中的一个类是定义在堆栈上的，就使用"."开访问它的成员。如果是定义在堆上的，就使用"->"指针来开访问。但在，"->"操作符也可以用在堆栈上的类。 什么是指针？ 和其它变量一样，指针是基本的变量，所不同的是指针包含一个实际的数据，该数据代表一个可以找到实

《C++指针》习题参考答案

《C++指针》习题 学号姓名 一、选择题 1、有定义如下：int a[5], *p; 则下列描述错误的是B A．表达式p=p+1是合法的B．表达式a=a+1是合法的 C．表达式p-a是合法的D．表达式a+2是合法的 2、函数定义为Fun(int &i),变量定义n=100,则下面调用该函数正确的 是C A．Fun(20) B．Fun(20+n) C．Fun(n) D．Fun(&n) 3、若有说明int I,j=2,*p=&i;则能完成i=j赋值功能的语句是B A．i=*p; B．*p=*&j; C．i=&j; D．i=**p; 4、设已有定义char *st = "how are you";下列程序中正确的是A A．char a[11],*p;strcpy(p=a+1,&st[4]); B．char a[11];strcpy(++a,st); C. char a[11];strcpy(a,st); D. char a[],*p;strcpy(p=a[1],st+2); 5、设有数组int array[3][4]，下列引用数组元素的方法中错误的是D A．array[i][j] B．*(*(array+i)+j) C. *(array[i]+j) D. *(array+i*4+j) 6、有定义int s[4][5],(*ps)[5];ps=s;则对数组s中元素引用的正确 的是C A．ps+1 B．*(ps+3) C. ps[0][2] D. *(ps+1)+3 7、设有说明int b[4][4]，以下不能等价表示元素b[3][3]的是:B A．*&b[3][3] B．(*(*(b+3))+3) C．*(b[3]+3) D．*(*(b+3)+3) 8、若有说明"char *s[]={"234","5678","9012","3456","7890"};",则表达 式*s[1]> *s[3]比较的是B A．"1234"和"9012" B．'5'和'3' C．'l'和'9' D．"5678"和"3456" 9、设语句"char *s[]={"Student","Teacher","Father","Mother"},*ps=s[2];",执行语句"cout<<*s[1]<<','<

指针实验

实验名称：指针使用 实验目的：熟悉指针的正确用法。 相关知识：1.指针的定义；2.指针的引用； 实验内容： (1) 调试下面程序，指出错误原因。 main ( ) { int x=10,y=5,*px,*py; px=py; px=&x; py=&y; printf(“*px=%d,*py=%d”,*px,*py); } （2）调试下面程序。 #include main ( ) { float a; float *pa; scanf(“%f”,&a); printf(“1.%f\n”,a); pa=&a; scanf(“%f”,pa); printf(“2.%f\n”,a); } 在上述程序中，添加如下语句。 printf(“%x”,&a); printf(“%x”,pa); printf(“%x”,pa+1); ①记录这3条语句的输出值。其中“%x”表明输出的数值用十六进制数表示。 ②计算float类型所占空间的大小。 ③运算符sizeof可以计算出某一类型或变量所占存储空间的大小。请在上述程序中加入语句：printf(“%ld”,sizeof(float));将该语句的输出结果与步骤②的结果比较，观察是否一致。

（3）调试下面程序。 #include main ( ) ｛ float a,b; float *pa=&a,*pb=&b; printf(“%x\n”,pa+pb); printf(“%x\n”,pa-pb); printf(“%x\n”,pa+5); printf(“%x\n”,pa-5); ｝ 记录出错信息，分析出错原因。总结指针可以进行哪些运算。 下面的程序能获得上述运行结果吗？ main( ) { char *s=”COMPUTER”; char c; printf(“which style you want to \n”); printf(“capital (c) or uncapital (u);”); c=getchar(); if (c=’c’) puts(s); else { s=”computer”; puts(s); } }

C语言中指针、数组和引用例子实例

一、指针：内容是指示一个内存地址的变量；类型是指示编译器怎么解释指针内容指向地址中的内容，以及该内存区域有多大； 例子： [cpp] int i = 0; int * pi = &i; printf(“pi = %x \n”, pi); // 打印pi的内容: 0x2000 printf(“*pi= %d \n” , *pi); // 打印pi指向地址中的值: 5 printf(“&pi= %x \n”, &pi); // 打印pi的地址: 0x100 从汇编的角度来看，指针是这样的： int i = 0; 010E139E mov dword ptr [i],0 int * pi = &i; 010E13A5 lea eax,[i] 010E13A8 mov dword ptr [pi],eax 二、数组：是一个单一数据类型对象的集合。其中单个对象没有被命名，通过索引访问。 数组名和指针的区别：数组名的内涵在于其指代实体是一种数据结构，这种数据结构就是数组。数组名的外延在于其可以转换为指向其指代实体的指针，而且是一个指针常量。指向数组的指针则是另外一种变量类型，仅仅意味着数组的存放地址 注意：虽然数组名可以转换为指向其指代实体的指针，但是它只能被看作一个指针常量，不能被修改，如下：天骄无双：https://www.doczj.com/doc/bc4775470.html, [cpp] int intArray[10]; intArray++; // 错误 “指针和数组等价”说的是什么？索引操作相同，例如：p[2]; a[2]; 三、引用（reference）是一个对象的别名。用对象初始化引用后，对象的名字和引用都指向该对象； 引用是如何实现的？从汇编语言的角度来看，指针和引用是一样的： [cpp] int i = 0; 00E9139E mov dword ptr [i],0 int & ref = i; 00E913A5 lea eax,[i] 00E913A8 mov dword ptr [ref],eax int * pi = &i; 00E913AB lea eax,[i] 00E913AE mov dword ptr [pi],eax 指针和引用的区别（从C++使用角度来看）： 不存在空引用 引用要初始化 引用初始化后，不能指向另一个对象 这是由编译阶段保证的。 备注：一个指向非常量的引用不能用字面值或者临时值初始化；但是一个指向常量的引用可以。天骄无双：https://www.doczj.com/doc/bc4775470.html,

教材课后题答案-第6章_指针习题答案

习题解答 一、单项选择题 1.若定义了int n=2, *p=&n, *q=p;则下面【】的赋值是非法的。 A.p=q B. *p=*q C. n=*q D. p=n 【答案】D 2.若定义了double *p, a;则能通过scanf函数给输入项读入数据的程序段是【】。 A.p=&a; scanf(“%1e”,p); B. *p=&a; scanf(“%1f”,p); C. p=&a; scanf(“%f”,p); D. p=&a; scanf(“%1f”,a); 【答案】C 3.若定义了int a[10], i=3, *p; p=&a[5];下面不能表示为a数组元素的是【】。 A.p[-5] B. a[i+5] C. *p++ D. a[i-5] 【答案】D 4.若有如下定义： int n[5]={1,2,3,4,5},*p=n; 则值为５的表达式是【】。 A.*+5 B. *（p+5） C. *p+=4 D. p+4 【答案】C 5.设变量b的地址已赋给指针变量ps，下面为“真”的表达式是【】。 A.b==&ps B. b==ps C. b==*ps D. &b==&ps 【答案】C 6.设有以下定义和语句： int a[3][2]={1,2,3,4,5,6},*p[3]; p[0]=a[1]; 则*(p[0]+1)所代表的数组元素是【】。 A.a[0][1] B. a[1][0] C. a[1][1] D. a[1][2] 【答案】C 7.若定义了char *str=”Hello!”;下面程序段中正确的是【】。 A.char c[ ], *p=c; strcpy(p,str); B.char c[5], *p; strcpy(p=&c[1],&str[3]); C.char c[5]; strcpy(c,str); D.char c[5]; strcpy(p=c+2,str+3); 【答案】B 8.若有下面的程序段，则不正确的fxy函数的首部是【】。 main() { int a[20], n; … fxy(n, &a[10]); … } A.void fxy(int i, int j) B. void fxy(int x, int *y) C. void fxy(int m, int n[]) D. void fxy(int p, int q[10]) 【答案】A 9.不合法的带参数main函数的首部形式是【】。

C语言指针实验报告

C语言程序设计实验报告 1实验目得 （1）掌握指针得概念,会定义与使用指针变量; （2）能正确使用变量得指针与指向变量得指针变量; （3）能正确使用数组得指针与指向数组得指针变量; （4）能正确使用字符串得指针与指向字符串得指针变量; 2实验内容 将一个任意整数插入到已排序得整形数组中,插入后,数组中得数仍然保持有序; 要求: （1）整形数组直接由赋值得方式初始化,要插入得整数有scanf()函数数入; （2）算法实现过程采用指针进行处理; （3）输入原始数据以及插入整数后得数据,并加以说明;

3算法描述流程图

4源程序 #include main() { int a[100],m,i,*p,n,w; printf("请输入要输入得数组得元素个数:\n"); scanf("%d",&n); printf("请输入已排好序得数组:\n"); for(i=0;i=w;i--) { a[i+1]=a[i]; } a[i+1]=m; for(i=0;i<=n;i++) { printf("%-4d",a[i]); } printf("\n"); } 5测试数据 “1,3,5,7,9,11,13,15,17,19······10” 6运行结果 7出现问题及解决方法 在编写过程中,

for(i=n-1;a[i]>=w;i--) { a[i+1]=a[i]; } a[i+1]=m; 这一步没有注意a[i++]=m与a[i+1]=m中i++与i+1不同,a[i++]=m就是先将得值赋给a[i],然后在执行自增;而在实验过程中忽略了这一点,造成了不必要得麻烦; 8实验心得 通过这次指针实验掌握了指针得概念,会定义与使用指针变量,并且能利用指针来简单化一些问题,给以后得编程带来了很大得便利;

指针综合练习题(带答案)

指针综合练习题 一、选择题 1．若有以下定义，则对a数组元素的正确引用是____d_____. int a[5],*p=a; a)*&a[5] b)a+2 c)*(p+5) d)*(a+2) 2．若有定义：int a[2][3],则对a数组的第i行j列元素地址的正确引用为__d____. a)*(a[i]+j) b)(a+i) c)*(a+j) d)a[i]+j 3．若有以下定义，则p+5表示___a____. int a[10],*p=a; a)元素a[5]的地址b)元素a[5]的值 c)元素a[6]的地址d)元素a[6]的值 4．设p1和p2是指向同一个字符串的指针变量，c为字符变量，则以下不能正确 执行的赋值语句是____b____. a)c=*p1+*p2; b)p2=c c)p1=p2 d)c=*p1*(*p2); 5．若有说明语句 char a[]="It is mine"; char *p="It is mine"; 则以下不正确的叙述是___d_____. a)a+1表示的是字符t的地址 b)p指向另外的字符串时，字符串的长度不受限制 c)p变量中存放的地址值可以改变 d)a中只能存放10个字符 二、填空题 1 指针变量保存了另一变量的（1）值，不可以任意给指针变量赋一个地址值，只能赋给 它（2）和（3）的地址。使用变量名来访问变量，是按（4）来直接存取变量称为（5）方式；而借助指针变量取得另一变量的地址，访问该变量称为（6）方式。 答案：（1）地址 （2）NULL （3）已经分配了内存的变量的地址 （4）按变量的地址 （5）直接访问 （6）间接访问 2 以下程序的功能是：通过指针操作，找出三个整数中的最小值并输出。 请填空。 void main() {int *a,*b,*c,num,x,y,z; a=&x;b=&y;c=&z; cou<<"输入3个整数："; cin>>a>>b>>c; cout<<*a<<*b<<*c; num=*a;

c语言指针实验报告

C语言实习报告 题目：指针及其应用 系别： 专业： 姓名： 学号： 日期：

一实验名称：指针及其应用 二实验目的： （1）掌握变量的指针及其基本用法。 （2）掌握一维数组的指针及其基本用法。 （3）掌握指针变量作为函数的参数时，参数的传递过程及其用法。 三实验内容： （1）运行以下程序，并从中了解变量的指针和指针变量的概念。 （2）运行以下程序，观察&a[0]、&a[i]和p的变化，然后回答以下问题： 1.程序的功能是什么？ 2.在开始进入循环体之前，p指向谁？ 3.循环每增加一次，p的值（地址）增加多少？它指向谁？ 4.退出循环后，p指向谁？ 5.你是否初步掌握了通过指针变量引用数组元素的方法？ （3）先分析以下程序的运行结果，然后上机验证，并通过此例掌握通过指针变量引用数组元素的各种方法。

（4）编写函数，将n个数按原来的顺序的逆序排列（要求用指针实现），然后编写主函数完成： ①输入10个数； ②调用此函数进行重排； ③输出重排后的结果。 四分析与讨论： （1）指针的定义方法，指针和变量的关系。 定义方法： 数据类型 *指针变量名; 如定义一个指向int型变量的指针—— int *p;

则我们可以继续写如下代码—— int a = 4; p = &a; printf("%d", *p); 在这里，我们定义了一个变量a，我们把它理解为内存空间连续的4个字节（int型占用4字节），则这4个字节的空间保存着一个数4。&是取地址符号，即把变量a的地址（即这4个字节的首地址）赋给指针p （记住指针p的类型和变量a的类型要保持一致，否则的话，要进行类型转换）。这样子，指针p就保存着变量a的地址。我们如果把指针p当做内存空间里面另外一个连续的4个字节，那么这4个字节保存的数就是变量a的地址。printf("%d",*p)和printf("%d",a)的结果是一样的。这里的*是取变量符号（与&刚好作用相反，通过变量的地址找到变量），与定义时int *p的*号作用不同（定义时的*表示该变量是个 指针变量，而非是取它指向的变量）。 （2）数组和指针的关系。 指针与数组是C语言中很重要的两个概念，它们之间有着密切的关系，利用这种关系，可以增强处理数组的灵活性，加快运行速度，本文着重讨论指针与数组之间的联系及在编程中的应用。 1．指针与数组的关系 当一个指针变量被初始化成数组名时，就说该指针变量指向了数组。如： char str[20], ＊ptr; ptr=str; ptr被置为数组str的第一个元素的地址，因为数组名就是该数组的首地址，也是数组第一个元素的地址。此时可以认为指针ptr就是数组str（反之不成立），这样原来对数组的处理都可以用指针来实现。如对数组元素的访问，既可以用下标变量访问，也可以用指针访问。 2．指向数组元素的指针 若有如下定义： int a[10], ＊pa; 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语言对数组的处理，实际上是转换成指针地址的运算。 数组与指针暗中结合在一起。因此，任何能由下标完成的操作，都可以用指针来实现，一个不带下标的数组名就是一个指向该数组的指针。

C语言数组指针的小例子

1、功能：输入6个学生的5门课程成绩，计算出每个学生的平均分和每门课程的平均分。 2、C语言实现代码：（其实就是用二维数组来实现的，二维数组的引用传递使用数组指针来完成） 复制代码代码如下: #include <stdio.h> #define STUDENT 5 #define SCORE 6 void input_array(float (*score)[STUDENT]); void avg_score(float (*score)[STUDENT]); void avg_course(float (*score)[STUDENT]); /** * calculate student average score and course average socore. */ int main(){ float a[SCORE][STUDENT]; input_array(a); avg_course(a); avg_score(a); } void input_array(float (*score)[STUDENT]){ int i, j; for(i=0; i<SCORE; i++){ printf("input the %d student score:", i+1); for(j=0; j<STUDENT; j++){ scanf("%f", score[i] + j); } } } void avg_course(float (*score)[STUDENT]){ int i,j; float s; for(j=0; j<STUDENT; j++){ printf("course%d ", j); } printf("n"); for(i=0; i<SCORE; i++){ s=0; for(j=0; j<STUDENT; j++){ printf("%f ", *(score[i] + j)); s += *(score[i] + j); }

指针练习题与答案

编程题 1用指向数组的指针变量输出数组的全部元素 #include void main( ) { int a[10], i; int *p; for (i=0; i<10; i++) cin>>a[i]; for (p=a; p void main( ) { int a[10], i; int *p=a; for (i=0; i<10; i++) cin>>a[i]; for (i=0; i<10; i++) cout<<*p++<<‘\t’; } 2 使用函数调用，形参为指针，实参为数组，把一个数组逆序存放在输出

#include void inv(int *x, int n)； void main( ) { int i, a[10]={3,7,9,11,0,6,7,5,4,2}; inv(a,10); for (i=0;i<10; i++) cout<

【实验指导书】实验7：指针 (1)

（2014~2015学年-第1学期） 1. 理解指针、地址和数组间的关系。 2. 掌握通过指针操作数组元素的方法； 3. 掌握数组名作为函数参数的编程方式。 4. 掌握通过指针操作字符串的方法。 5. 了解掌握使用断点调试程序的方法。 二、实验环境： 操作系统：Window 8 编译环境：CodeBlock 13.02 三、实验要求及内容（根据实验要求，将整个实验过程需要的数据和截屏记录于此，并整理成实验步骤。）： 1.设计一个程序计算输入的两个数的和与差，要求自定义一个函数sum_diff(float op1，float op2，float *psum，float *pdiff)，其中op1和op2是输入的两个数，*psum和*pdiff是计算得出的和与差。 解： （1）流程图如图1所示： 图1 程序7-1的流程图

图2 实验7-1实验源代码 （3）运行结果（测试用例） 实验7-1运行结果如图3所示 图3 实验7-1运行结果 2. 输入n 个正整数，使用选择法将它们从小到大排序后输出。要求：利用所学指针的内容实现。 提示：在指针这一章所学的冒泡排序算法基础上改写。 解： （1）流程图如图1所示： 图1 程序7-2的流程图

图2 实验7-2实验源代码（3）运行结果（测试用例）实验7-2运行结果如图3所示 图3 实验7-2运行结果

3. 输入10个整数存入数组a ，再输入一个整数x ，在数组a 中查找x ，若找到则输出相应的下标，否则显示“Not found ”。要求定义和调用函数seach(int list[]，int n ，int x)，在数组list 中查找元素x ，若找到则返回相应的下标，否则返回-1，参数n 代表数组list 中元素的数量。试编写相应程序。 解：(1)流程图如图1 7-3的流程图 （2）源代码 源代码如图2所示

c语言指针GetMemory经典例子

GetMemory的典型例子 2010-01-13 18:24 520人阅读评论(2) 收藏举报//NO.1：程序首先申请一个char类型的指针str,并把str指向NULL（即str里存的是NULL的地址，*str为NULL中的值为０），调用函数的过程中做了如下动作：１申请一个char 类型的指针p，２把str的内容copy到了p里（这是参数传递过程中系统所做的）,3为p指针申请了100个空间，４返回Test函数．最后程序把字符串hello world拷贝到str 指向的内存空间里．到这里错误出现了！str的空间始终为NULL而并没有实际的空间．深刻理解函数调用的第2步，将不难发现问题所在！ void GetMemory(char *p) { p = (char*)malloc(100); } void Test(void) { char *str = NULL; GetMemory(str); strcpy(str, "hello world"); printf(str); } //请问运行Test函数后会是什么样的结果？ //NO.2：程序首先申请一个char类型的指针str,并把str指向NULL．调用函数的过程中做了如下动作：１申请一数组p[]并将其赋值为hello world(数组的空间大小为12)，２返回数组名p付给str指针（即返回了数组的首地址）．那么这样就可以打印出字符串＂hello world＂了么？当然是不能的！因为在函数调用的时候漏掉了最后一步．也就是在第２步return数组名后，函数调用还要进行一步操作，也就是释放内存空间．当一个函数被调用结束后它会释放掉它里面所有的变量所占用的空间．所以数组空间被释放掉了，也就是说str所指向的内容将不确定是什么东西． char *GetMemory(void) { char p[] = "hello world"; return p;

c语言指针的习题答案

指针练习题 1.有以下程序 main() { char a[]="programming",b[]="language"; char *p1,*p2; int i; p1=a;p2=b; for(i=0;i<7;i++) if(*(p1+i)==*(p2+i)) printf("％c",*(p1+i)); } 输出结果是 A)gm B)rg C)or D)ga 2.设有说明int(*ptr)[m];其中的标识符ptr是 A）M个指向整型变量的指针 B）指向M个整型变量的函数指针 C）一个指向具有M个整型元素的一维数组的指针 D）具有M个指针元素的一维指针数组，每个元素都只能指向整型量 3.若已定义：int a[9]，*p=a；并在以后的语句中未改变p的值，不能表示a[1] 地址的表达式是 A) p+1 B) a+1 C) a++ D) ++p 4.若有语句int *point ,a=4;和point =&a;下面均代表地址的一组选项是 A. a,point,*&a B. &*a,&a,*point C. &point,*point,&a D. &a,&*point,point 5.下面程序段的运行结果是 char a[]=”language”,*p;p=a; while(*p!=’u’) {printf(“%c”, *p-32);p++;} A. LANGUAGE B. LANGuage https://www.doczj.com/doc/bc4775470.html,NG https://www.doczj.com/doc/bc4775470.html,ngUAGE 6.以下程序的运算结果是*p=1,m=3,n=5 。 #include void main() {

int a[5]={1,2,3,-4,5}; int m,n,*p; p=&a[0]; m=*(p+2); n=*(p+4); printf("*p=%d,m=%d,n=%d",*p,m,n); } 7.写一通用函数slength，求出一个字符串的长度，并用main函数调用slength。解： #include #include int slength(char str[]) { int i; for(i=0;str[i]!='\0';i++); return i; } void main() { char string[50]; int len; printf("请输入字符串:"); gets(string); len=slength(string); printf("字符串长度是%d",len); } 8.若有定义：int a[2][3],则对a数组的第i行j列元素地址的正确引用为______. A)*(a[i]+j) B)(a+i) C)*(a+j) D)a[i]+j 9.若有以下定义，则p+5表示_______. int a[10],*p=a; a)元素a[5]的地址b)元素a[5]的值 c)元素a[6]的地址d)元素a[6]的值 8．下面程序的运行结果是_______. #include #include main()

C语言实验六实验报告——指针

一、实验项目名称 指针 二、实验目的 1．掌握指针的基本概念和基本用法。包括：变量的地址和变量的值，指针变量的说明、指针变量的初始化、指针的内容与定义格式、指针的基本运算等； 2．掌握数组与指针的关系并能够利用指针解决数组的相关问题； 3．掌握字符串与指针的关系并能够利用指针处理字符串的问题； 4．掌握指针与函数的关系并能够利用指针处理函数问题； 5．了解指向指针的指针的概念及其使用方法； 6．能够使用指针进行程序设计。 三、实验内容 有关指针的程序设计 1．编程实现：任意输入的10个数，求其平均值。 要求： （1）10个数采用scanf语句读入。 （2）利用指针实现对这10个数的访问。 （3）要求平均值的精度为小数后面2位。 2．编程实现：将一个任意整数插入到一个已排序的整数数组中，插入后数组中的数仍然保持有序。 要求： （1）整数数组由初始化方式输入。任意整数由scanf函数输入； （2）实现过程采用指针处理； （3）输出原始数组数据以及插入数据后的数组数据并加以相应说明。 3．编写函数newcopy（char *new，char *old），它的功能是删除old所指向的字符串中的小写字母，并将所得到的新串存入new中。 要求： （1）在主函数中以初始化方式输入一个字符串； （2）调用newcopy（）函数； （3）在主函数中输出处理后的结果。 4．编程实现：输入三个整数，按由大到小的顺序输出。

要求： （1）通过scanf函数输入三个数据并存入三个变量中； （2）利用指针实现从大到小输出； （3）修改程序，将三个整型数据改为字符型数据，输入三个字符，按从大到小数顺序输出； （4）修改程序，将三个字符型数据改为字符串数据，输入三个字符串，按从小到大顺序输出； （5）体会指针对不同数据处理的特点。 四、实验步骤及结果 一、 #include <> void main() { int a[10],n,sum=0; float aver;/* 定义平均数为浮点型*/ int *p=a;/*初始化*/ printf("Please input 10 numbers:\n"); for (n=0;n<10;++n) scanf("%d",&a[n]);/*输入十个数*/ for (n=0;n<10;++n) sum=sum+*(p+n);/*使用指针访问数据*/ aver=(float)sum/n; printf("Average is %.2f",aver);/*精确到小数点后两位*/ } 二、 #include <> void arr(int *a,int n);/*定义排序函数*/ void insert(int *a,int num);/*插入并排序函数*/ int n=10;/*定义数据个数，可修改*/ void main()

第七章字符数组与指针练习题参考答案

第七章字符数组与字符串 【题7.29】下面是对s的初始化，其中不正确的是。 A）char s[5]={“abc”};B）char s[5]={‘a’,‘b’,‘c’}; C）char s[5]=“”;D）char s[5]=“abcdef”; 【题7.30】下面程序段的运行结果是。 char c[5]={‘a’,‘b’,‘\0’,‘c’,‘\0’}; printf(“%s”,c); A）‘a’‘b’ B）ab C）ab c 【题7.31】对两个数组a和b进行如下初始化 char a[]=“ABCDEF”; char b[]={‘A’, ‘B’,‘C’,‘D’,‘E’,‘F’}; 则以下叙述正确的是。 A）a与b数组完全相同B）a与b长度相同 C）a和b中都存放字符串D）a数组比b数组长度长 提示：‘\0’是字符串结束的标志 【题7.32】有两个字符数组a、b，则以下正确的输入格式是。 A）gets(a,b); B）scanf(“%s %s”,a,b); C）scanf(“%s %s”,&a,&b);D）gets(“a”),get(“b”); 【题7.33】有字符数组a[80]和b[80]，则正确的输出形式是。 A）puts(a,b); B）printf(“%s %s”,a[],b[]); C）putchar(a,b); D）puts(a),puts(b); 【题7.34】下面程序段的运行结果是。 char a[7]=“abcdef”; char b[4]=“ABC”; strcpy(a,b); printf(“%c”,a[5]); A）空格B）\0 C）e D）f 提示：复制后a[0]=‘A’,a[1]=‘B’,a[2]=‘C’,a[3]=‘\0’, a[4]=‘e’,a[5]=‘f’, a[6]=‘\0’,

实验报告一(指针)

指针 实验一指向变量得指针变量编程 一．实验目得与要求 1、理解指针得概念。 2、掌握指针变量得定义与使用。 ３、掌握指针变量作为函数参数得使用方法。 二.实验题目 １、用指针变量编程，求数组中得最大元素与最小元素. #inclｕde"stdｉｏ、h” ＃ｄefiｎeＮ10 ｖoｉｄmain() ｛ ?vｏiｄｍaｘmin（int aｒｒ[］，ｉnt *ｐt1，int *pt2，intｎ）； ｉｎt array[N］={10,７,１9，2９,4，0，７，35,-16，２1｝,*p1,*p２,ａ，b；?ｐ1=&a； p2=＆b； ?maxmin（ａrray，ｐ１,p2,Ｎ）； prｉnｔf(＂max＝％d，min=％ｄ\n＂,ａ，ｂ）; ｝ vｏid maｘmｉn(iｎｔ aｒr［],int *ｐt１,int *pt2,int n） ｛ iｎt i; ?＊ｐｔ1=＊pｔ２=arr[０]； for（i=１；i

二.实验题目 ２、用字符指针编程求出字符串中指定字符得个数。 例如：假设字符串为：“abｃｄagｈckｐａmｎ”，指定字符为‘a’,则结果为3. 要求:从maｉn函数输入字符串与指定字符，输出结果。 ＃include ＃defiｎeＭAＸＬEＮ 20 ｉnｔ CouｎtLetｔｅｒ(char＊stｒ, cｈar ch） { ?iｎｔ timｅ = 0； whｉlｅ(*sｔr） ?if（＊stｒ++ ==ch） ?time++ ; ｒeｔurn timｅ； ｝ int main() ｛ ?char str[MAXLEＮ] ； ｃｈａr cｈ； ?printｆ（"Please input a ｓtrinｇ:\n"）; scaｎf（”%s”，ｓtr）； getｃｈar(）；/／get enteｒ priｎtf（"Input the a lettｅｒ to count："）； scanf（"%c"， &ｃh）； ?printf(＂%d\n＂,CoｕntＬetteｒ（ｓtr， ch）） ; } 实验三指向一维数组得指针变量编程 一．实验目得与要求 １、理解指针与数组之间得关系。 ２、掌握用指针变量引用数组元素得方法。 ３、掌握用指向一维数组得指针变量编程。 二.实验题目 3、已知一个整型数组，编程将其数组元素得值改为当前元素与相邻得下一个元素得乘积,数组得最后一个元素改为它与第0个元素得乘积，要求用指针变量实现。 例如：已知ａ[5］＝{1,２，3，4，5｝; 计算后a［5］=｛2，6, １2, ２0，10}。 #ｄefｉｎe N 5 ＃iｎｃludｅ”stdio、h”

c语言指针例子

深入理解c语言指针的奥秘 指针的概念 指针是一个特殊的变量，它里面存储的数值被解释成为内存里的一个地址。要搞清一个指针需要搞清指针的四方面的内容：指针的类型，指针所指向的类型，指针的值或者叫指针所指向的内存区，还有指针本身所占据的内存区。让我们分别说明。 先声明几个指针放着做例子： 例一： (1)int*ptr; (2)char*ptr; (3)int**ptr; (4)int(*ptr)[3]; (5)int*(*ptr)[4]; 如果看不懂后几个例子的话，请参阅我前段时间贴出的文章<<如何理解c和c ++的复杂类型声明>>。 指针的类型 从语法的角度看，你只要把指针声明语句里的指针名字去掉，剩下的部分就是这个指针的类型。这是指针本身所具有的类型。让我们看看例一中各个指针的类型： (1)int*ptr;//指针的类型是int* (2)char*ptr;//指针的类型是char* (3)int**ptr;//指针的类型是int** (4)int(*ptr)[3];//指针的类型是int(*)[3] (5)int*(*ptr)[4];//指针的类型是int*(*)[4] 怎么样？找出指针的类型的方法是不是很简单？ 指针所指向的类型

当你通过指针来访问指针所指向的内存区时，指针所指向的类型决定了编译器将把那片内存区里的内容当做什么来看待。 从语法上看，你只须把指针声明语句中的指针名字和名字左边的指针声明符*去掉，剩下的就是指针所指向的类型。例如： (1)int*ptr;//指针所指向的类型是int (2)char*ptr;//指针所指向的的类型是char (3)int**ptr;//指针所指向的的类型是int* (4)int(*ptr)[3];//指针所指向的的类型是int()[3] (5)int*(*ptr)[4];//指针所指向的的类型是int*()[4] 在指针的算术运算中，指针所指向的类型有很大的作用。 指针的类型(即指针本身的类型)和指针所指向的类型是两个概念。当你对C越来越熟悉时，你会发现，把与指针搅和在一起的"类型"这个概念分成"指针的类型"和"指针所指向的类型"两个概念，是精通指针的关键点之一。我看了不少书，发现有些写得差的书中，就把指针的这两个概念搅在一起了，所以看起书来前后矛盾，越看越糊涂。 指针的值，或者叫指针所指向的内存区或地址 指针的值是指针本身存储的数值，这个值将被编译器当作一个地址，而不是一个一般的数值。在32位程序里，所有类型的指针的值都是一个32位整数，因为32位程序里内存地址全都是32位长。指针所指向的内存区就是从指针的值所代表的那个内存地址开始，长度为si zeof(指针所指向的类型)的一片内存区。以后，我们说一个指针的值是XX，就相当于说该指针指向了以XX为首地址的一片内存区域；我们说一个指针指向了某块内存区域，就相当于说该指针的值是这块内存区域的首地址。 指针所指向的内存区和指针所指向的类型是两个完全不同的概念。在例一中，指针所指向的类型已经有了，但由于指针还未初始化，所以它所指向的内存区是不存在的，或者说是无意义的。 以后，每遇到一个指针，都应该问问：这个指针的类型是什么？指针指的类型是什么？该指针指向了哪里？ 指针本身所占据的内存区 指针本身占了多大的内存？你只要用函数sizeof(指针的类型)测一下就知道了。在32位平台里，指针本身占据了4个字节的长度。 指针本身占据的内存这个概念在判断一个指针表达式是否是左值时很有用。