char指针与char数组的区别

转自：https://www.doczj.com/doc/f210858676.html,/johnny710vip/article/details/6725637 指针：char *p = “helloworld”;

在这里p是一个变量,其类型为指针类型,并且指向一个字符串,字符串内容为”helloworld”,如果要访问p[2]的话,就需要先从p中取出地址,该地址为”helloworld”的首地址,然后再加上偏移量2,就得到了’l’这个字符,所以其访问的方式为先从p 中取出地址,然后再将该地址加上偏移量,得到一个地址,最后从这个地址中取出值来。其分为三步:

1.取p的值,该值即为字符串的首地址；

2.该地址加上偏移量,得到所要取的字符的地址；

3.从这个地址中取得值。

此处p是一个变量,它自己是存放在一个地址中的,而它的内容

则是”helloworld”这个字符串的地址. p与字符串是分开的。同时,该指针的值是动态确定的,必须在运行的时候才能确定其值,并通过该值访问到字符串。

而如果是数组的话,则为

char p[20] = “helloworld”;

在这里p为一个字符串的标识,其类型是一个字符数组的类型,且该数组有20个char类型的大小.此时如果要访问p[2]的话,分2步：

1.直接使用该字符数组的首地址加上2个char类型的大小的长度就得到了要访问的字符的地址；

2.最后再从这个地址中取出值来.而且此时p的地址为该字符数组的首地址,其内容为’h’，一个字符类型。

所以在这个地方数组与指针是不相同的,因为此时数组取值

的第一步并不是从p中读取地址来再加上偏移量的.此时的p这个地址的值就为’h’这个字符,其类型为字符型而不是一个指针类型.此时p的地址与p[0]的地址是相同的。

同时,每个符号的地址在编译时就确定了,所以这里p的地址就已经确定了,如果需要访问p[2],则直接使用该地址加上2这个偏移量就可以取到这个值了.它不需要指令再取得这个首地址.而第一种情况下,还需要指令取得指针中的值,并通过这个值来

访问字符串。

一个直观的看法就是前一种是两个不同的, 而后一种则是在同一个里面。

另外，还有一个不同之处在于第一个情况下 p 指向的是一个常量区, 是不能改变的, 即不能够对p[i]赋值, 而第二种情况下, p是一个字符数组, 其是可以改变的，可以对p[i]赋值的。他们俩*p的值是一样的，都是h字符！

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

在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));

指针与数组练习题

指针与数组练习题 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) {

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); }

数组及指针 知识点总结

第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]

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

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/f210858676.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/f210858676.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语言指针数组函数练习(含参考答案)

作业（使用指针、数组、函数完成） 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

计算机二级c语言第九章 数组和指针习题与答案

第九章数组和指针 1、有以下程序 main() { int a[]={2,4,6,8,10}, y=0, x, *p; p=&a[1]; for(x= 1; x< 3; x++) y += p[x]; printf("%d\n",y); } 程序运行后的输出结果是 A)10 B)11 C)14 D)15 2、有以下程序 void sum(int a[]) { a[0] = a[-1]+a[1]; } main() { int a[10]={1,2,3,4,5,6,7,8,9,10}; sum(&a[2]); printf("%d\n", a[2]); } 程序运行后的输出结果是 A)6 B)7 C)5 D)8 3、有以下程序 main() { int p[8]={11,12,13,14,15,16,17,18},i=0,j=0; while(i++< 7) if(p[i]%2) j+=p[i]; printf("%d\n",j); } 程序运行后的输出结果是 A)42 B)45 C)56 D)60 4、设有定义语句 int x[6]={2,4,6,8,5,7},*p=x,i; 要求依次输出x数组6个元素中的值，不能完成此操作的语句是 A)for(i=0;i<6;i++) printf("%2d",*(p++)); B)for(i=0;i<6;i++) printf("%2d",*(p+i)); C)for(i=0;i<6;i++) printf("%2d",*p++); D)for(i=0;i<6;i++) printf("%2d",(*p)++); 5、有以下程序 #include < stdio.h > main() { int a[]={1,2,3,4,5,6,7,8,9,10,11,12,},*p=a+5,*q=NULL; *q=*(p+5); printf("%d %d\n",*p,*q); } 程序运行后的输出结果是 A)运行后报错 B)6 6 C)6 11 D)5 10

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数组长度

指针与数组 函数的组合

指针和数组 ? ? 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;

第4章 指针思考与练习题答案

第4章指针 思考与练习题 1、什么叫内存单元的地址？什么叫指针？ 答：在计算机内部的存储器（简称内存）中，每一个字节单元，都有一个编号，称为地址。内存单元的编号，称为内存单元的地址。 在C++语言中，内存单元的地址称为指针。 2、什么叫指针变量？什么叫指针的目标？ 答：专门用来存放地址的变量，称为指针变量(pointer variable)。指针指向的内存区域中的数据称为指针的目标。 3、什么叫空指针？其作用是什么？ 答：所谓空指针就是指针变量的内容为零的状态。 4、指针运算的实质是什么？ 答：指针运算是以指针变量所存放的地址量作为运算量而进行的运算。因此，指针运算的实质就是地址的计算。 5、指针有哪些运算？请枚举这些计算。 答：指针运算的种类是有限的，它只能进行算术运算、关系运算和赋值运算。 6、什么叫数组的指针？什么叫指针数组的指针？ 答：在C++语言中，数组的指针是指数组在内存中的起始地址。 指针变量数组和普通的一般变量数组一样，编译系统在处理指针数组说明时，按照指定的存储类型为它在内存中分配一定的连续存储空间，这时指针数组名就表示该指针数组的存储首地址，即指针数组的指针。 7、什么叫二级指针变量？什么叫多级指针变量？ 答：对于指向处理数据的指针变量称为一级指针变量，简称一级指针。而把指向一级指针变量的指针变量称为二级指针变量，简称二级指针。我们把一个指向指针变量的指针变量，称为多级指针变量。 8、new运算符的作用是什么？delete运算符的作用是什么？ 答：运算符new主要用于分配内存，并获得分配到的内存的首地址，通常需要将其赋给相应数据类型的指针。如果程序中不再需要由new分配的内存空间时，用运算符delete

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;

指针和数组习题

一、1 数组可以在定义时整体赋初值，但不能在赋值语句中整体赋值。（） 2. 取数组a的第5个元素的地址，正确的写法是（） A) *a[4] B) &a[4]C) a[4] D) *(a+4) 3. 程序段输出结果是（） int main() { double number = 12345.12345678; cout << setw(10) << setprecision(5) << number << endl; cout << setw(10) << setprecision(10) << number << endl; return 0; } 12345 B）12345 C) 12345 D) 12345 12345.12346 12345.12345 12345.12345 12345.1235 4、若x为整形变量，p是基类型为整形的指针变量，则正确的赋值表达式（） A p=&x B p=x C *p=&x D *p=*x 5，设p1和p2均为指向同一个int型一维数组的指针变量，k为int型变量，下列不正确的语句是（） A k=*p1+*p2 B k=*p1*（*p2） C p2=k D p1=p2 6．对于相同类型的指针变量，不能进行（）运算。 A，+ B，- C，= D，== 7．有函数定义如下，则其返回值为（） int *f（int a） { Int*p，n； n=a； p=&n； return p； } A 一个不可用的存储单元地址值 B一个不可用的存储单元地址值 C n中的值 D 形参a中得值 8，下列关于字符串的描述中，错误的是（） A，一维字符数组可以存放一个字符串 B，可以用一个字符串给二维字符数组赋值 C，二维字符数组可以存放多个字符串 D；可以用一个字符串给二维字符数组进行初始化 9；下列关于字符数组的描述中，错误的是（） A．字符数组中得每一个元素都是字符 B，字符数组可以使用初始值表进行初始化 C，字符数组可以存放字符串 D 字符数组就是字符串 10；下列关于数组下标的描述中，错误的是（） A；C++中，数组元素的下标是从0开始的 B，数组元素下标是一个整型常量表达式

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;

指针数组和数组指针

一、指针数组和数组指针的内存布局 初学者总是分不出指针数组与数组指针的区别。其实很好理解： 指针数组：首先它是一个数组，数组的元素都是指针，数组占多少个字节由数组本身决定。它是“储存指针的数组”的简称。 数组指针：首先它是一个指针，它指向一个数组。在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 之间的区别