指针数组和数组指针的区别

C语言指针大杂烩

先举个栗子(*p)[4],*p[4],*(p[0]+0),*(*(p+0)+0)有何区别

如果都能明白请绕道。

数组指针，指针数组不要傻傻的分不清楚。

下面是肝货。。。

在观看以下知识点之前，要掌握如下知识点：运算符的优先级和结合性、一维数组的定义和一维数组、二维数组的定义和二维数组、一维数组和指针、二维数组和指针以及基础的c语言知识。

1.指针讲解

所谓指针变量实质就是一种保存变量地址的变量。

char a;//定义一个字符型变量

char *a://定义一个字符型指针变量

int q;//定义一个整型变量

int *q;//定义一个整形指针变量

int **q;//定义一个整形的指向指针的指针变量

int k=1,*q,**w;

q=&k;// &作用为取变量的地址，指针中存放的为地址

w=&q;//w为指向指针的指针变量，顾名思义，它是用来存放指针的

可以把指针看成一种容器，容器中存放的是另一个变量的地址。

2.指针数组和数组指针的区别

引入一道c程序片段：

int a[12],*p[3]，**pp,i；

for(i=0;i<12;i++)

a[i]=I;

for(i=0;i<3;i++)

p[i]=&a[i*4];

pp=p;

指针数组

回想一下指针讲解中的内容，然后理解*p[3]，它是一个指针数组，可把他看成容器，*p[3]这个容器由3个指针变量组成*p[0],*p[2],*p[3]；

将a数组分成3段，指针p[0]存放a[0]的地址, p[1]存放a[4]的地址, p[2]存放a[9]的地址；

pp为指向指针的指针变量，存放指针数组p的地址；

可以打印一下

样式一：*(pp[?]+?)、*(*(pp+？)+？)

pp[0][0]、*(pp[0]+0)、*(*(pp+0)+0)、

pp[0][1]、*(pp[0]+1)、*(*(pp+0)+1)

看起来不同实质指的是同一个地址（*有规律的东东，把这三种表示形式记下来）

样式二：*pp[?] *pp[0]、*pp[1]、*pp[2],等价于指针数组*p[3]中3个指针变量的值，每个指针存放4个内存块，行指针

样式三：*（p+?）[?] *(p+1)[1]、*(p+0)[2]、*(p+2)[0]、**（pp+2）、pp[2][0],指向同一个地址，两个？的和为行指针的标号

以上是指针数组的三种形式，指针数组，就是由指针组成的数组，常用于一维数组分段；试着敲下理解，会发现还是很难理解，隔一天再试一次，我相信你会理解的。

附加程序代码

void main()

{

int a[12],*p[3],**pp,i;

for(i=0;i<12;i++)

{

a[i]=i;

}

for(i=0;i<3;i++)

{

p[i]=&a[i*4];

}

pp=p;

//printf("%d ",pp[0][0]);

//printf("%d %d\n",*pp[0],*p[0]);

//printf("%d %d\n",*pp[1],*p[1]);

//printf("%d %d\n",*pp[2],*p[2]);

printf("%d ",*(p+1)[1]);

printf("%d ",*(p+0)[2]);

printf("%d ",*(p+2)[0]);

printf("%d ",pp[2][0]);

printf("\n");

system("pause");

}

#endif

数组指针

int s[3][4],(*pp)[4];

pp=s;

这里要考虑优先级的，“（）“优先级高，所以它是数组指针，仅仅是占一个指针变量的空间，用于指向二维数组。

与指针数组用法相同不在举例

附加程序代码

void main()

{

int s[3][4],(*pp)[4],i,j,k=0;

pp=s;

for(i=0;i<3;i++)

{

for(j=0;j<4;j++)

s[i][j]=k++;

}

printf("%d ",pp[0][0]);

printf("%d ",*(pp[0]+0));

printf("%d \n",*(*(pp+0)+0));

printf("%d ",*(pp[0]+1));

printf("%d ",*(*(pp+0)+1));

/*printf("%d ",**(pp+2));

printf("%d ",*(pp+0)[2]);

printf("%d ",*(pp+1)[1]);

printf("%d ",*(pp+2)[0]);*/

system("pause");

}

总结

写了这么多，它俩的区别是啥呢？

指针数组是个容器包含多个指针变量，指向一维数组。

数组指针只是一个指针变量，占一个指针的存储空间，专用指向二维数组。

以上是个人见解，有不到位的地方，还请各位指教，在评论区留言。

数组名和指针的区别(小结)

在Win 32 中： 1. (1) 对数组名进行sizeof运算时，结果是整个数组占用空间的大小; (2) 但是数组作为函数参数时，对数组名进sizeof 运算，结果为4; (2) 对指针进行sizeof运算得到的值是编译器分配给指针(也就是一个地址)的内存空间，即为4。 2. (1) 对数组名作&运算，得到的还是数组第一个元素的地址; (2) 对指针取地址时得到的结果是指针所在的地址，也就是指向这个指针的指针，与指针的值不同。 BOOL mytest(char param[100]) { //参数数组名：paramBytes int paramBytes = sizeof(param); printf("paramBytes \t%d\n",paramBytes); //数组：mych1[] char mych1[] = "abcdefg123"; //若定义为mych1[100] int mych1Bytes = sizeof(mych1); printf("mych1Bytes \t%d\n",mych1Bytes);//输出：100 //数组：mych[200] char mych[200] = {0}; int myBytes = sizeof(mych); printf("myBytes \t%d\n",myBytes); printf("---addr \t%d\n",mych); printf("---addr \t%d\n",&mych); //指针：pch char* pch = "12345abc"; int pchBytes = sizeof(pch); printf("pchBytes \t%d\n",pchBytes); //pch = mych; printf("---addr \t%d\n",pch); printf("---addr \t%d\n",&pch); return TRUE; } 运行：

指针数组及指向一维数组的指针讲解

一、指针数组及指向一维数组的指针（数组指针）讲解 1、数组指针（也称行指针） 定义 int (*p)[n]; ()优先级高，首先说明p是一个指针，指向一个整型的一维数组，这个一维数组的长度是n，也可以说是p的步长。也就是说执行p+1时，p要跨过n个整型数据的长度。 如要将二维数组赋给一指针，应这样赋值：int a[3][4];int (*p)[4]; //该语句是定义一个数组指针，指向含4个元素的一维数组。 p=a; //将该二维数组的首地址赋给p，也就是a[0]或&a[0][0] p++; //该语句执行过后，也就是p=p+1;p跨过行a[0][]指向了行a[1][] 所以数组指针也称指向一维数组的指针，亦称行指针。 2、指针数组 定义 int *p[n]; []优先级高，先与p结合成为一个数组，再由int *说明这是一个整型指针数组，它有n个指针类型的数组元素。这样赋值是错误的：p=a；只存在p[0]、p[1]、p[2]...p[n-1],而且它们分别是指针变量可以用来存放变量地址。但可以这样 *p=a; 这里*p表示指针数组第一个元素的值，a的首地址的值。 如要将二维数组赋给一指针数组: int *p[3]; int a[3][4]; for(i=0;i<3;i++) p[i]=a[i]; 这里int *p[3] 表示一个一维数组内存放着三个指针变量，分别是p[0]、p [1]、p[2]所以要分别赋值。 这样两者的区别就豁然开朗了，数组指针只是一个指针变量，似乎是C语言里专门用来指向二维数组的，它占有内存中一个指针的存储空间。指针数组是多个指针变量，以数组形式存在内存当中，占有多个指针的存储空间。 还需要说明的一点就是，同时用来指向二维数组时，其引用和用数组名引用都是一样的。 比如要表示数组中i行j列一个元素： *(p[i]+j)、*(*(p+i)+j)、(*(p+i))[j]、p[i][j] 优先级：()>[]>* 例1、下列给定程序中，函数fun()的功能是：从N个字符串中找出最长的那个串，并将其地址作为函数值返回。 #include #include #define N 4

指针函数与函数指针的区别

指针函数与函数指针的区别 一、 在学习arm过程中发现这“指针函数”与“函数指针”容易搞错，所以今天，我自己想一次把它搞清楚，找了一些资料，首先它们之间的定义： 1、指针函数是指带指针的函数，即本质是一个函数。函数返回类型是某一类型的指针 类型标识符 *函数名(参数表) int *f(x，y); 首先它是一个函数，只不过这个函数的返回值是一个地址值。函数返回值必须用同类型的指针变量来接受，也就是说，指针函数一定有函数返回值，而且，在主调函数中，函数返回值必须赋给同类型的指针变量。 表示： float *fun(); float *p; p = fun(a); 注意指针函数与函数指针表示方法的不同，千万不要混淆。最简单的辨别方式就是看函数名前面的指针*号有没有被括号（）包含，如果被包含就是函数指针，反之则是指针函数。来讲详细一些吧！请看下面 指针函数： 当一个函数声明其返回值为一个指针时，实际上就是返回一个地址给调用函数，以用于需要指针或地址的表达式中。 格式： 类型说明符* 函数名(参数) 当然了，由于返回的是一个地址，所以类型说明符一般都是int。 例如：int *GetDate(); int * aaa(int,int); 函数返回的是一个地址值，经常使用在返回数组的某一元素地址上。 int * GetDate(int wk,int dy); main() { int wk,dy; do { printf(Enter week(1-5)day(1-7)\n); scanf(%d%d,&wk,&dy); } while(wk<1||wk>5||dy<1||dy>7); printf(%d\n,*GetDate(wk,dy));

数组及指针 知识点总结

第9章数组 第1课 知识点一 定义一维数组 格式: 类型名数组名[元素个数] 例1 定义一个包含4个整数的数组a int a[4]; 例2 定义一个包含3个双精度数的数组b double b[3]; 注意: C语言中数组的下界从0开始计数。 例如: a[4]的4个元素分别为a[0]、a[1]、a[2]、a[3] 知识点二 一维数组的初始化 用一对大括号将数组的初值括起来。 例1 int a[3]={1, 2, 3}; 此例中a[0]值为1、a[1]值为2、a[2]值为3

例2 int a[5]={0}; 此例中数组a的全部元素值均为0 例3 int a[3]={1, 2, 3, 4}; 此例中由于初值个数多于数组元素个数，所以非法。例4 int a[ ]={0, 0, 0, 0}; 此例中省略数组元素个数，初值为4个0 等价于int a[4]={0}; 注意: 数组名是一个常量值，不能对它赋值。 例如: int a[3]; a=5; 此语句非法，应改为a[0]=5; 知识点三 一维数组应用 例1 从键盘上输入10个整数，输出最大数和最小数。 #include main() { int a[10],i,max,min; printf("请输入10个整数:\n");

for(i=0;i<=9;i++) scanf("%d",&a[i]); max=a[0]; min=a[0]; for(i=1;i<=9;i++) { if(a[i]>max) max=a[i]; if(a[i]

C语言数组参数与指针参数

C语言数组参数与指针参数 我们都知道参数分为形参和实参。形参是指声明或定义函数时的参数，而实参是在调用函数时主调函数传递过来的实际值。 一、一维数组参数 1、能否向函数传递一个数组？看例子： void fun(char a[10]) { char c = a[3]; } intmain() { char b[10] = “abcdefg”; fun(b[10]); return 0; } 先看上面的调用，fun(b[10]);将b[10]这个数组传递到fun 函数。但这样正确吗？b[10]是代表一个数组吗？ 显然不是，我们知道b[0]代表是数组的一个元素，那b[10]又何尝不是呢？只不过这里数组越界了，这个b[10]并不存在。但在编译阶段，编译器并不会真正计算b[10]的地址并取值，所以在编译的时候编译器并不认为这样有错误。虽然没有错误，但是编译器仍然给出了两个警告： warning C4047: 'function' : 'char *' differs in levels of indirection from 'char ' warning C4024: 'fun' : different types for formal and actual parameter 1 这是什么意思呢？这两个警告告诉我们，函数参数需要的是一个char*类型的参数，而实际参数为char 类型，不匹配。虽然编译器没有给出错误，但是这样运行肯定会有问题。如图： 这是一个内存异常，我们分析分析其原因。其实这里至少有两个严重的错误。

第一：b[10]并不存在，在编译的时候由于没有去实际地址取值，所以没有出错，但是在运行时，将计算b[10]的实际地址，并且取值。这时候发生越界错误。 第二：编译器的警告已经告诉我们编译器需要的是一个char*类型的参数，而传递过去的是一个char 类型的参数，这时候fun 函数会将传入的char 类型的数据当地址处理，同样会发生错误。（这点前面已经详细讲解） 第一个错误很好理解，那么第二个错误怎么理解呢？fun 函数明明传递的是一个数组啊，编译器怎么会说是char *类型呢？别急，我们先把函数的调用方式改变一下： fun(b); b 是一个数组，现在将数组b 作为实际参数传递。这下该没有问题了吧？调试、运行，一切正常，没有问题，收工！很轻易是吧?但是你确认你真正明白了这是怎么回事？数组b真的传递到了函数内部？ 2、无法向函数传递一个数组 我们完全可以验证一下： void fun(char a[10]) { int i = sizeof（a）； char c = a[3]; } 如果数组b 真正传递到函数内部，那i 的值应该为10。但是我们测试后发现i 的值竟然为4！为什么会这样呢？难道数组b 真的没有传递到函数内部？是的，确实没有传递过去，这是因为这样一条规则： C 语言中，当一维数组作为函数参数的时候，编译器总是把它解析成一个指向其首元素首地址的指针。 这么做是有原因的。在C 语言中，所有非数组形式的数据实参均以传值形式（对实参做一份拷贝并传递给被调用的函数，函数不能修改作为实参的实际变量的值，而只能修改传递给它的那份拷贝）调用。然而，如果要拷贝整个数组，无论在空间上还是在时间上，其开销都是非常大的。更重要的是，在绝大部分情况下，你其实并不需要整个数组的拷贝，你只想告诉函数在那一刻对哪个特定的数组感兴趣。这样的话，为了节省时间和空间，提高程序运行的效率，于是就有了上述的规则。同样的，函数的返回值也不能是一个数组，而只能是指针。这里要明确的一个概念就是：函数本身是没有类型的，只有函数的返回值才有类型。很多书都把这点弄错了，甚至出现“XXX 类型的函数”这种说法。简直是荒唐至极！ 经过上面的解释，相信你已经理解上述的规定以及它的来由。上面编译器给出的提示，说函数的参数是一个char*类型的指针，这点相信也可以理解。既然如此，我们完全可以把fun 函数改写成下面的样子： void fun(char *p) { char c = p[3];//或者是char c = *(p+3); }

指针与数组练习题

指针与数组练习题 1、下面程序实现如下功能：输入一个整数字符串转换为一个整数值，如”1234”转换为1234，”-1234”转换为-1234。读懂main函数，编写转换函数chnum #include #include void main() { char s[6]; int n; int chnum(char *p); gets(s); if (*s=='-') n=-chnum(s+1); else n=chnum(s); printf("%d\n",n); } int chnum(char*p) { int sum=0; while(*p!='\0') { if(*p>='0'&&*p<='9') sum=sum*10+*p-'0'; p++; } return sum; } 2、从键盘输入一个字符串，去掉所有非十六进制字符后转换成十进制数输出。读懂以下main函数，编写相应的函数del16和htod。 #include #include void main() { char s1[10],s2[10]; void del16(char*,char*); int htod(char*); gets(s1); //读入一字符串 del16(s1,s2); //去掉所有非十六进制字符到s2 printf("%d\n",htod(s2)); //把s2转换为10进制 }

void del16(char*s1,char*s2){ for(;*s1!='\0';s1++) if(*s1>='0'&&*s1<='9'||*s1>='a'&&*s1<='f'||*s1>='A'&&*s1<='F'){ *s2 = *s1; s2++;} *s2='\0'; } int htod(char*s2){ int sum=0; for(;*s2!='\0';s2++){ if(*s2>='0'&&*s2<='9') sum=sum*16+*s2-'0'; else if(*s2>='a'&&*s2<='f') sum=sum*16+*s2-'a'+10; else if(*s2>='A'&&*s2<='F') sum=sum*16+*s2-'A'+10; } return sum; } 3、编写函数insert(char *s1,char *s2,int pos)，实现在字符串s1中的指定位置pos处插入字符串s2。 Happy Year New 7 Happy New Year #include #include int main(void) { void insert(char *s1,char *s2,int pos); char s1[80],s2[80]; int pos; gets(s1); gets(s2); scanf("%d",&pos); insert(s1,s2,pos); puts(s1); return 0; } void insert(char *s1,char *s2,int pos) {

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

第七章字符数组与字符串 【题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’,

C语言指针数组函数练习(含参考答案)

作业（使用指针、数组、函数完成） 1. 编写一个通用函数，该函数可以实现判断：一个含有五位数字的整数是否是回文数。回文数的含义是从左向右与从右向左看，数是相同的。如：23732是回文数，而23564则不是。编写主程序调用该函数实现求所有5位数字中满足条件的数的个数。 #include int Judge(int num) { int w,q,b,s,g; w=num/10000; q=num%10000/1000; s=(num%100)/10; g=num%10; if((w==g)&&(q==s)) return 1; else return 0; } void main() { int count=0; int i; for(i=10000;i<=99999;i++) if(Judge(i)) count++; printf("%d\n",count); } 2．编写一个通用函数，该函数可以实现对数值型数组的倒序。倒序的含义是把数组的元素值前后颠倒。例数组：20，19，18，15，13，10倒序的结果为：10，13，15，18，19，20。编写主程序，数组初始化方式不限，并输出，然后调用该函数实现倒序后再输出倒序的结果。#include #define N 6 void Transfer(double *b,int n) { double temp; double *i=b; double *j=b+n-1; while(j>i) { temp=*i; *i=*j; *j=temp; i++;

j--; } } void main() { double array[N]={20，19，18，15，13，10}; int i; for(i=0;i #include double Cal(double *p,int n) { int i,j; double sum=0; for(i=0;i

变量的指针和指针变量的区别是什么

2变量的指针和指针变量的区别是什么。 答；一个变量的地址指出了变量的存储单元在内存中的具体位置，能对变量进行存取操作。这个变量的地址就是变量的指针。指针是一种具有特殊意义的整型数，指针不能存放在一般的整型变量中，必须存放在专门指针的变量中，这类变量就是指针变量。 3 一维数组元素的引用有哪些方式。 答；下标法、地址法、指针法 4 2维数组列地址有哪些计算方法。 答；1 根据数组元素所在的行计算出行地址，然后把行地址转换成行中首元素的地址，再根据数组元素所在的列计算数组元素的地址。 2 根据2维数组的数组元素在存储空间上按行连续存放的特点，每个数组元素的地址等于2维数组元素的首元素地址加上该数组元素相对于首元素位置的偏移量。 3把2维数组的每一行当作一个一维数组，用一维数组元素地址的计算方法计算相应的2维数组元素的地址。 第9章结构体与共用体 1 什么是链表。其中单向链表具有哪些特点。 答；链表是若干个同样类型的结构通过依次串接方式构成的一种动态数据结构。链表中的每一个结构体数据成为结点，链表可以分成单向链表和双向链表 单向链表的特点；1 链表中的结点数据可以改变的 2 结点占用的内存是动态分配内存和动态释放内存函数。 2 对单向链表的常用操作有哪些。 答；对单向链表的常用操作有建立、显示、插入，删除和查找。 3 什么是共用体。 答；共用体是一个集合体。它的各个成员的数据类型可以是不相同的，所有成员共享同一段存储空间，存储空间的大小取决存储单元最大的成员的数据类型。 4 指向结构体类型变量的指针变量引用形式有哪些。 答；有两种形式；【星号指针变量名】。成员名和指针变量名-大于号成员名。 第10章位运算及编译预处理 1 C提供的编译预处理功能有哪些。如何实现。 答；功能有三种；宏定义、文件包含和条件编译，分别用宏定义命令、文件包含命令、条件编译命令实现。 2 文件包含的基本功能是什么。 答；文件包含处理是一个源文件可以将另一个源文件的全部内容包含到本文件中来，作为本文件的一部分，这可以节省程序设计人员的重复劳动。 【3【在C语言中提供了几种什么样的位运算符。 答；-、小于小于、大于大于、 4 文件包含需要注意哪些问题 答；一个井include命令只能指定一个被包含文件，包含多个文件侧需多个井include命令；文件包含可以嵌套，即一个被包含文件中可以包含另一个被包含的文件；在井include命令中，文件名可以用双引号或尖括号括起来。 第11章文件 1 文件的结束标志有哪些。 答；每个文件都有一个结束标志。当文件的位置指针移到文件的结束标志处时，表示文件结束。如何测试文件是否结束，常有2种方法 1 ASCII码文件的结束标志用【-1】表示。

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/e617242240.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/e617242240.html,

实验三 数组与指针实验

实验三数组与指针实验 【实验目的】 1．学习使用数组数据对象。 2．掌握指针的使用方法。 3．学习通过动态内存分配实现动态数组的定义和使用，并体会指针在其中的作用。4．练习通过Debug观察指针的内容及其所指对象的内容。 【实验内容】 1．运行下列程序，观察运行结果。 （1）#include class ArrayElem { int x; public: ArrayElem(int i){x=i;} //带参数的构造函数 int getx(){return x;} }; int main() { ArrayElem obs[4] ={-1,-2,-3,-4}; //创建对象数组并初始化 for(int i=0;i<4;i++) cout<<"obs["< class NumClass { int num; public: void set_num(int val){num=val;} void show_num(){cout<<"The num is :"<set_num(20);p->show_num(); //通过指针调用成员函数 return(0); } （3）#include class NumClass

C语言笔记第五章数组和指针的关系

C语言笔记第五章数组和指针的关系 第五章数组和指针的关系 如果对声明数组的语句不太明白的话，请参阅我前段时间贴出的文章< 理解c和c++的复杂类型声明>>。 数组的数组名其实可以看作一个指针。看下例： 例八： int array[10]={0,1,2,3,4,5,6,7,8,9},value; ... ... value=array[0];//也可写成：value=*array; value=array[3];//也可写成：value=*(array+3); value=array[4];//也可写成：value=*(array+4); 上例中，一般而言数组名array代表数组本身，类型是int [10]，但如果把a rray看做指针的话，它指向数组的第0个单元，类型是int *，所指向的类型是数组单元的类型即int。因此*array等于0就一点也不奇怪了。同理，array+3是一个指向数组第3个单元的指针，所以*(array+3)等于3。其它依此类推。 例九： 例九： char *str[3]={ "Hello,this is a sample!", "Hi,good morning.", "Hello world" }; char s[80]； strcpy(s,str[0]);//也可写成strcpy(s,*str); strcpy(s,str[1]);//也可写成strcpy(s,*(str+1)); strcpy(s,str[2]);//也可写成strcpy(s,*(str+2));

上例中，str是一个三单元的数组，该数组的每个单元都是一个指针，这些指 针各指向一个字符串。把指针数组名str当作一个指针的话，它指向数组的第0号单元，它的类型是char**，它指向的类型是char *。 *str也是一个指针，它的类型是char*，它所指向的类型是char，它指向的地 址是字符串"Hello,this is a sample!"的第一个字符的地址，即'H'的地址。 str+1也是一个指针，它指向数组的第1号单元，它的类型是char**，它指向 的类型是char *。 *(str+1)也是一个指针，它的类型是char*，它所指向的类型是char，它指向"Hi,good morning."的第一个字符'H'，等等。 下面总结一下数组的数组名的问题。声明了一个数组TYPE array[n]，则数组 名称array就有了两重含义：第一，它代表整个数组，它的类型是TYPE [n]；第二，它是一个指针，该指针的类型是TYPE*，该指针指向的类型是TYPE，也就是数组单元的类型，该指针指向的内存区就是数组第0号单元，该指针自己占有单独的内存区，注意它和数组第0号单元占据的内存区是不同的。该指针的值是不能修改的，即类似array++的表达式是错误的。 在不同的表达式中数组名array可以扮演不同的角色。 在表达式sizeof(array)中，数组名array代表数组本身，故这时sizeof函数 测出的是整个数组的大小。 在表达式*array中，array扮演的是指针，因此这个表达式的结果就是数组第 0号单元的值。sizeof(*array)测出的是数组单元的大小。 表达式array+n（其中n=0，1，2，....。）中，array扮演的是指针，故arr ay+n的结果是一个指针，它的类型是TYPE*，它指向的类型是TYPE，它指向数组第n号单元。故sizeof(array+n)测出的是指针类型的大小。 例十： int array[10]; int (*ptr)[10]; ptr=&array; 上例中ptr是一个指针，它的类型是int (*)[10]，他指向的类型是int [10] ，我们用整个数组的首地址来初始化它。在语句ptr=&array中，array代表数组本身。

使用数组和指针统计成绩

int pingjun( int *b); int zuidi(int *b); int kemu(int *c,int n); #include void main() {int a[9]={75,80,83,85,86,30},i,b; char *name[5]={"数学","物理","外语","政治","体育"}; char *meanlow[4]={"人数","平均成绩","最低分数科目成绩","最低分科目"}; printf("原始信息如下：\n"); for(i=0;i<5;i++) printf("%s:%d\n",name[i],a[i]); for(i=0;i<4;i++) printf("%s:%d\n",meanlow[i],a[i+5]); printf("全班各科平均成绩如下：\n"); for(i=0;i<5;i++) printf("%s:%d\n",name[i],a[i]); printf("统计结果如下：\n"); printf("%s:%d\n",meanlow[0],a[5]); printf("%s:%d\n",meanlow[1],pingjun(a)); printf("%s:%d\n",meanlow[2],zuidi(a)); b=kemu(a,5); printf("%s:%s\n",meanlow[3],name[b]); } int pingjun( int *b)//求平均成绩 {int sum=0 ,i,aver; for(i=0;i<5;i++) sum=sum+b[i]; aver=sum/5; return aver; } int zuidi(int *b)//求最低成绩 {int t=b[0],i; for(i=0;i<5;i++) {if(t>b[i]) t=b[i];} return t; } int kemu(int *c,int n)//求最低成绩的科目 {int i, t=c[0],m=0; for(i=1;ic[i]) {t=c[i];m++;} }

指针与数组 函数的组合

指针和数组 ? ? 1.指针数组：是其数组元素为指针的数组。记住：是一个存放着指针的数组，而不是一个指针 ?定义格式为：数据类型* 数组名[数组长度] ?如：int * a[10] ; [ ]的优先级高于*，意味着使得a是一个指针数组，表示具有10个元素的数组，每个元素是一个指向int 型的指针。 ? ?2，指向数组的指针：是一个指针，指向的是一个数组。 ?定义格式为：数据类型(*数组名) [数组长度] ?如：int (*a) [10]；*先于a 结合，意味着a 是一个指针，指向具有10个int 值的数组， ? ? ?指针与函数 ? ?1, 函数的指针：首先它是一个指针，指向函数的入口地址；在C语言中，函数名就是来标识函数的入口地址。 ?与指向数组的指针不同，在数组中，可以对数组中的元素访问，可以进行算术运算。 而在函数中，只需考虑函数的入口地址，而不考虑函数中某具体指令或数据所在存 储单元的地址，即不能进行算术运算 ?定义格式：存储类型数据类型(*函数名) ( ) ?如：static int (*p) (); ?存储类型表示函数在文件中的存储方式 ?数据类型表示被指函数的返回值的类型 ?最后的空括号表示指针变量所指的是一个函数 ? ?如何用指向函数的指针变量的方式来调用相应的函数： ?1), 使用前，必须先定义并赋值 ?2), 指向函数的指针定义形式中的数据类型必须和赋给它的函数返回值类型相同 ?3), 指向函数的指针只能指向函数的入口，而不能使用*(p+1) 来表示函数的下一命令?4), 在函数指针赋值时，只需给出函数名而不需给参数，如p = max; ?5), 调用时，只需将(*p) 代替函数名即可，在p 后面的括号中根据需要写上实参，如： c = (*p) (a,b) ; ?如下程序：求直角三角形的斜边 ?#include ? #include ?main() ?{ ? int a ,b ,c , f() , (*f1)(); ? a = 3; b = 4;

C语言指针数组和数组指针

C语言指针数组和数组指针 一、指针数组和数组指针的内存布局 初学者总是分不出指针数组与数组指针的区别。其实很好理解： 指针数组：首先它是一个数组，数组的元素都是指针，数组占多少个字节由数组本身决定。它是“储存指针的数组”的简称。 数组指针：首先它是一个指针，它指向一个数组。在32 位系统下永远是占4 个字节，至于它指向的数组占多少字节，不知道。它是“指向数组的指针”的简称。 下面到底哪个是数组指针，哪个是指针数组呢： A) int *p1[10]; B) int (*p2)[10]; 每次上课问这个问题，总有弄不清楚的。这里需要明白一个符号之间的优先级问题。 “[]”的优先级比“*”要高。p1 先与“[]”结合，构成一个数组的定义，数组名为p1，int *修饰的是数组的内容，即数组的每个元素。那现在我们清楚，这是一个数组，其包含10 个指向int 类型数据的指针，即指针数组。至于p2 就更好理解了，在这里“（）”的优先级比“[]”高，“*”号和p2 构成一个指针的定义，指针变量名为p2，int 修饰的是数组的内容，即数组的每个元素。数组在这里并没有名字，是个匿名数组。那现在我们清楚p2 是一个指针，它指向一个包含10 个int 类型数据的数组，即数组指针。我们可以借助下面的图加深理解：

二、int (*)[10] p2-----也许应该这么定义数组指针 这里有个有意思的话题值得探讨一下：平时我们定义指针不都是在数据类型后面加上指针变量名么？这个指针p2 的定义怎么不是按照这个语法来定义的呢？也许我们应该这样来定义p2： int (*)[10] p2; int (*)[10]是指针类型，p2 是指针变量。这样看起来的确不错，不过就是样子有些别扭。其实数组指针的原型确实就是这样子的，只不过为了方便与好看把指针变量p2 前移了而已。你私下完全可以这么理解这点。虽然编译器不这么想。^_^ 三、再论a 和&a 之间的区别 既然这样，那问题就来了。前面我们讲过a 和&a 之间的区别，现在再来看看下面的代码： int main() { char a[5]={'A','B','C','D'}; char (*p3)[5] = &a; char (*p4)[5] = a; return 0;

C语言 数组和指针练习题

若当堂没做完，下周四之前上交也可。 至ftp://211.64.82.253/ 用户名和密码：stu Ｃ语言程序设计练习题——数组 一、选择题 77、以下对一维数组a的正确说明是＿d ＿＿＿ A、char a(10)； B、int a[ ]； C、int k=5,a[k]； D、char a[ ]={'a' , 'b' , 'c'}； 78、若有说明语句：int a[2][4]；，则对a数组元素的正确引用是＿a＿＿＿ A、a[0][3] B、a[0][4] C、a[2][2] D、a[2][2+1] 79、以下能对二维数组y进行初始化的语句是＿b＿＿ A、static int y[2][ ]={{1,0,1}, {5,2,3}}； B、static int y[ ][3]={{1,2,3}, {4,5,6}}； C、static int y[2][4]={{1,2,3}, {4,5} , {6}}； D、static int y[ ][3]={{1,0,1,0}, { }, {1,1}}； 80、若有说明语句：int y[ ][4]={0,0}；则下面叙述不正确的是＿d＿＿＿ A、数组y的每个元素都可得初值0 B、二维数组y的行数为1 C、该说明等价于int y[ ][4]={0}； D、只有元素y[0][0]和y[0][1]可得到初值0，其余元素均得不到初值0 81、以下各组选项中，均能正确定义二维实型数组s的选项是＿c＿＿＿ A、float s[3][4]； B、float s(3,4)； float s[ ][4]； float s[ ][ ]={{0}；{0}}； float s[3][ ]={{1},{0}}； float s[3][4]； C、 float s[3][4]； D、float s[3][4]； static float s[ ][4]={{0},{0}}； float s[3][ ]； auto float s[ ][4]={{0},{0},{0}}； float s[ ][4]； 82、若有说明语句：int a[ ][3]={1,2,3,4,5,6,7,8}； ,则a数组的行数为＿＿a＿＿ A、3 B、2 C、无确定值 D、1 83、若二维数组y有m列，则在y[i][j]前的元素个数为＿B＿＿＿ A、j*m+i B、i*m+j C、i*m+j-1 D、i*m+j+1 84、下面程序中有错误的行是＿＿D＿＿ 1、 main( ) 2、 { 3、 int x[3]={1}； 4、 int k； 5、 scanf("%d", &x)； 6、 for (k=1； k<3； k++) 7、 x[0]=x[0]+x[i]； 8、 printf("x[0]=%d\n", x[0])； 9、 } A、3 B、6 C、7 D、5 85、若有以下语句，则正确的描述是＿＿b＿＿ char x[ ]="12345"； char y[ ]={'1', '2', '3', '4', '5'}； A、x数组与y数组的长度相同 B、x数组长度大于y数组长度 C、x数组长度小于y数组长度

力控数组指针的实现

：《再问如何把一个变量的采样值保存到一个数组中呢》本论题共有134人阅读，有4人回复。 我设计了一个循环，每隔一定时间把变量值赋给一个中间变量，但是发现这个数组的每个元素都是一样的值，不知是怎么回事？该如何解决呢? tmp为间接变量 WHILE(t<=15) DO t=t+1; tmp[t]=uc.PV; Delay(100); ENDWHILE yz 以下是对《再问如何把一个变量的采样值保存到一个数组中呢》的回复：111 sunwaywell

VarRedir(DbVar,"t" + IntToStr(i, 10) + ".pv"); DbVar = i; NEXT 这个循环结束后，可以看到t1 - t15都赋值完成了。 关于循环中用到的函数VarRedir，说明如下（详见力控联机帮助）： VarRedir 数据库变量重定向。 语法 VarRedir(var, NewTagPar) 说明 用于将数据库变量或间接变量重定向，对于数据库变量改变变量的数据库参数名称，使其指向其他数据库参数；而对于间接变量则改变其变量指向，使其指向名字为 NewTagPar的变量，该变量在DRAW中一定要存在。 通常可用于历史报表，趋势中变量动态替换。 参数 var: 重定向变量，该变量必须为数据库变量或间接变量。 NewTagPar:字符串类型，新数据库参数或变量名称名称。 示例 VarRedir(dbvar1, "a1.pv");//dbvar1将指向数据库参数a1.pv VarRedir(dbvar1, "a2.pv");//dbvar1将指向数据库参数a2.pv dbvar1为已定义的数据库变量。 VarRedir(var, "var1"); var为间接变量，var1为要转向的变量名称。 sunwaywell

C++常量指针与指针常量_数组指针与指针数组_函数指针与指针函数

常量指针与指针常量 一) 常量指针。 常量是形容词，指针是名词，以指针为中心的一个偏正结构短语。这样看，常量指针本质是指针，常量修饰它，表示这个指针乃是一个指向常量的指针（变量）。 指针指向的对象是常量，那么这个对象不能被更改。 在C/C++中，常量指针是这样声明的： 1）constint *p; 2）intconst *p; 常量指针的使用要注意，指针指向的对象不能通过这个指针来修改，可是仍然可以通过原来的声明修改，也就是说常量指针可以被赋值为变量的地址，之所以叫做常量指针，是限制了通过这个指针修改变量的值。例如： int a = 5; constint b = 8; constint *c = &a; // 这是合法的，非法的是对c的使用 *c = 6; // 非法，但可以这样修改c指向的对象的值：a = 6; constint *d = &b; // b是常量，d可以指向b，d被赋值为b的地址是合法的 细心的朋友在使用字符串处理函数的时候，应该会注意到这些函数的声明。它们的参数一般声明为常量指针。例如，字符串比较函数的声明是这样的： intstrcmp(const char *str1, const char *str2); 可是这个函数却可以接收非常量字符串。例如这段程序： char *str1, *str2; str1 = "abcde1234"; str2 = "bcde"; if(strcmp(str1, str2) == 0) {printf("str1 equals str2.");} str1和str2的内容显然是可以更改的，例如可以使用“str1[0] = x;”这样的语句把str1的内容由“abcde1234”变为“xbcde1234”。因为函数的参数声明用了常量指针的形式，就保证了在函数内部，那个常量不被更改。也就是说，对str1和str2的内容更改的操作在函数内部是不被允许的。（就目前的应用来看，我觉得设置常量指针就是为函数参数声明准备的，不然还真不知道用在什么地方呢，呵呵！） 虽然常量指针指向的对象不能变化，可是因为常量指针是一个变量，因此，常量指针可以不被赋初始值，且可以被重新赋值。例如： constint a = 12;