第6章 指针与数组-2011

程序设计

指针与数组

指针与数组的关系

多级指针的概念

在程序设计语言中，占用连续空间的数据对象都与其所占存储区域的起始地址相关。

如何用表明存储系统中线性连续区域的起始地址表示是几维空间的起始地址。

使用地址的不同级别描述不同空间数据对象的首地址 一级地址描述线性空间

二级地址描述平面空间

多级地址描述多维空间

又分别称为一级指针、二级指针和多级指针。

指针与数组的关系

指针与数组的关系

指针与数组的关系

指针与数组的关系

一维数组与指针的关系

000000000

0a[0]a[1]a[2]a[3]a[4]a[5]a[6]a[7]a[8]a[9]

p1p2p1100p2

p2*******p1p21000

指针与数组的关系

2345678910

1a[0]a[1]a[2]a[3]a[4]a[5]a[6]a[7]a[8]a[9]

p1

p2

5个整型数据（20个字节）

例6-2随机生成一个数组的所有元素，并用指针移动的方式输出这些元素值。

指针与数组的关系

指针与数组的关系

数组名与指向数组的指针变量的区别

根本的区别：

数组名是地址常量，任何想改变其值的运算都是非

法的，例如：a=p、a++等，只能是*(a+i)；

指针变量的值是可以改变的，例如：p=arr、p++等

都是有意义的操作。

例6-3使用不同的指针形式引用一维数组元素示例。

指针与数组的关系

指针与数组的关系

二维数组与指针的关系

二维数组中的地址表示形式

一个二维数组a被认为是由若干个名字分别为：a[0]、

a[1]、a[2]…、a[i]、…的一维数组组成。一维数组

的名字代表了该一维数组的首地址，即该一维数组0号

元素的地址，可以表示为a[i]和&a[i][0]两种等价形

式。

按照地址加法的规则，一维数组a[i]的j号元素地址可

以表示为a[i]+j和&a[i][j]两种等价形式。由于a[i]

等价于*(a+i)，所以有二维数组a的i行j列元素地址的

等价表示形式：a[i]+j、*(a+i)+j和&a[i][j]。

指针与数组的关系

指针与数组的关系

指针与数组的关系

指针与数组的关系

指向由若干个元素组成的数组的指针 指针的级别与它所指向的若干元素构成的数组结

构相关。

若元素构成的是一维数组，则相应的指针变量是二级指针变量；

若是二维数组，则对应三级指针变量。

因此若是n-1维数组，则对应n级指针变量

指针与数组的关系

程序设计中如果需要让指针的一次移动可以跨过所需要的数据对象个数

定义指向由若干个元素组成的一维数组的指针。定义指向由若干个元素组成的一维数组指针的一般形式为：[存储类别符] 数据类型符(*ptr)[常量表达式];

注：式中常量表达式的值就是指针所需要跨过的元素个数；

例：int (*ptr)[10];

定义了指针变量ptr；

指针ptr的一次移动可以移动过10个整型数据所占用的连续存储区域；

此时ptr 是二级地址；

指针与数组的关系

如果其定义中的常量表达式值与一个二维数组的列数

指针与数组的关系

例6-6使用指向由若干个元素组成的一维数组的指针处理二维数组。

例6-7指向若干个元素组成的一维数组指针变量作函数形式参数（求二维数组中全部元素之和）。

指针与数组

二维数组和指针

要用指针处理二维数组，首先要解决从存储的角度对二维数组的认识问题。我们知道，一个二维数组在计算机中存储时，是按照先行后列的顺序依次存储的，当把每一行看作一个整体，即视为一个大的数组元素时，这个存储的二维数组也就变成了一个一维数组了。而每个大数组元素对应二维数组的一行，我们就称之为行数组元素，显然每个行数组元素都是一个一维数组 下面我们讨论指针和二维数组元素的对应关系，清楚了二者之间的关系，就能用指针处理二维数组了。 设p是指向数组a的指针变量，若有： p=a[0]; 则p+j将指向a[0]数组中的元素a[0][j]。 由于a[0]、a[1]┅a[M-1]等各个行数组依次连续存储，则对于a数组中的任一元素a[i][j]，指针的一般形式如下： p+i*N+j 元素a[i][j]相应的指针表示为： *( p+i*N+j) 同样，a[i][j]也可使用指针下标法表示，如下： p[i*N+j] 例如，有如下定义： int a[3][4]={{10,20,30,40,},{50,60,70,80},{90,91,92,93}}; 则数组a有3个元素，分别为a[0]、a[1]、a[2]。而每个元素都是一个一维数组，各包含4个元素，如a[1]的4个元素是a[1][0]、a[1][1]、a[1]2]、a[1][3]。 若有： int *p=a[0]; 则数组a的元素a[1][2]对应的指针为：p+1*4+2 元素a[1][2]也就可以表示为：*( p+1*4+2) 用下标表示法，a[1][2]表示为：p[1*4+2] 特别说明： 对上述二维数组a，虽然a[0]、a都是数组首地址，但二者指向的对象不同，a[0]是一维数组的名字，它指向的是a[0]数组的首元素，对其进行“*”运算，得到的是一个数组元素值，即a[0]数组首元素值，*a等价于a[0] a[0]等价于&a[0][0],因此，*a[0]与a[0][0]是同一个值；

C语言程序设计实验答案数组、指针与字符串

实验06 数组、指针与字符串（4学时） （第6章数组、指针与字符串） 一、实验目的 二、实验任务 6_1（习题6-25）编写并测试3×3矩阵转置函数，使用数组保存3×3矩阵。 6_2（习题6-26）使用动态内存分配生成动态数组来重新完成上题（n阶方阵），使用指针实现函数的功能。 6_3 编程实现两字符串的连接。要求使用字符数组保存字符串，不要使用系统函数。 6_4 使用string类声明字符串对象，重新实现上一小题。 6_5（习题6-27）声明一个Employee类。 其中包括姓名、街道地址、城市和邮编等属性，以及change_name()和display()等函数。display()显示姓名、街道地址、城市和邮编等属性，change_name()改变对象的姓名属性，实现并测试这个类。 6_6（习题6-27）声明包含5个元素的对象数组，每个元素都是Employee 类型的对象。 6_7 修改实验4中的people（人员）类。 具有的属性如下：姓名char name[11]、编号char number[7]、性别char sex[3]、生日birthday、身份证号char id[16]。其中“出生日期”声明为一个“日期”类内嵌子对象。 用成员函数实现对人员信息的录入和显示。 要求包括：构造函数和析构函数、拷贝构造函数、内联成员函数、聚集。 在测试程序中声明people类的对象数组，录入数据并显示。

三、实验步骤 1.（编程，习题6-25）编写矩阵转置函数，输入参数为3×3整型数组。 使用循环语句实现矩阵元素的行列对调，注意在循环语句中究竟需要对哪些元素进行操作，编写main()函数实现输入输出。程序名：lab6_1.cpp。 参考运行结果： ★程序及运行结果： //lab6_1.cpp #include using namespace std; void move(int matrix[][3]){ int temp; for(int i=0;i<3;i++) for(int j=0;j>mat[i][j]; } cout<<"\n输入的3×3矩阵为："<

关于二维数组地址和指针之间的赋值

在开发工业以太网项目的时候经常遇到一些小细节问题，在建立数据报进行传输的过程中传递txbuf缓冲区的地址的时候就遇到类似下面的问题。 一．简单说明1 定义一个2X3的int型的二维数组int array[2][3];并且给这个二维数组赋值1,2,3,4,5,6；array[0][0]=1 array[0][1]=2 array[0][2]=3 array[1][0]=4 array[1][1]=5 array[1][2]=6 输出结果 1 2 3 4 5 6 array[0]表示第一行的首地址，也就是第一行第一个数的地址，也就是&array[0][0] So array[0]==&array[0][0]；其实&array[0]还==array[0]==&array[0][0]，都表示第一行的首地址。 array[1]是第二行的首地址，也就是第二行第一个数的地址，也就是&array[1][0] so array[1]=&array[1][0];试试&array[1]还==array[1]==&array[1][0] 定义一个指针变量int *p;将第一行的首地址赋给p有3种方式。 1. p=array[0]; 2. p=&array[0]; 3. p=&array[0][0]; p[0]就等同于array[0][0],也就是p[0]==1;(为了形象记忆，可以用替换的角度去记忆和理解。因为之前说过p=array[0], so， p[0]就把p换成array[0]再加上[0]就是arary[0][0]) p[1]等于array[0][1]等于2 p[2]等于array[0][2]等于3

C语言字符串指针问题

C语言字符串指针问题 在C语言中，可以用两种方法访问一个字符串。 用字符数组存放一个字符串，然后输出该字符串。 1.main(){ 2.char string[]=”I love China!”; 3.printf("%s\n",string); 4.} 说明：和前面介绍的数组属性一样，string是数组名，它代表字符数组的首地址。 用字符串指针指向一个字符串。 1.main(){ 2.char *string=”I love China!”;

3.printf("%s\n",string); 4.} 字符串指针变量的定义说明与指向字符变量的指针变量说明是相同的。只能按对指针变量的赋值不同来区别。对指向字符变量的指针变量应赋予该字符变量的地址。如： char c,*p=&c; 表示p是一个指向字符变量c的指针变量。而： char *s="C Language"; 则表示s是一个指向字符串的指针变量。把字符串的首地址赋予s。 上例中，首先定义string是一个字符指针变量，然后把字符串的首地址赋予string（应写出整个字符串，以便编译系统把该串装入连续的一块内存单元），并把首地址送入string。程序中的：char *ps="C Language"; 等效于： char *ps; ps="C Language"; 输出字符串中n个字符后的所有字符。 1.main(){ 2.char *ps="this is a book";

3.int n=10; 4.ps=ps+n; 5.printf("%s\n",ps); 6.} 运行结果为： book 在程序中对ps初始化时，即把字符串首地址赋予ps，当ps= ps+10之后，ps指向字符“b”，因此输出为"book"。 在输入的字符串中查找有无‘k’字符。 1.main(){ 2.char st[20],*ps; 3.int i; 4.printf("input a string:\n"); 5.ps=st; 6.scanf("%s",ps); 7.for(i=0;ps[i]!='\0';i++) 8.if(ps[i]=='k'){ 9.printf("there is a 'k' in the string\n"); 10.break; 11.} 12.if(ps[i]=='\0') printf("There is no 'k' in the string\n");

指向二维数组的指针

指向二维数组的指针 一. 二维数组元素的地址 为了说明问题, 我们定义以下二维数组: int a[3][4]={{0,1,2,3}, {4,5,6,7}, {8,9,10,11}}; a为二维数组名, 此数组有3行4列, 共12个元素。但也可这样来理解, 数组a由三个元素组成: a[0], a[1], a[2]。而它中每个元素又是一个一维数组, 且都含有4个元素(相当于4列), 例如, a[0]所代表的一维数组所包含的4 个元素为a[0][0], a[0][1], a[0][2], a[0][3]。如图5.所示: ┏━━━━┓┏━┳━┳━┳━┓ a─→┃a[0] ┃─→┃0 ┃1 ┃2 ┃3 ┃ ┣━━━━┫┣━╋━╋━╋━┫ ┃a[1] ┃─→┃4 ┃5 ┃6 ┃7 ┃ ┣━━━━┫┣━╋━╋━╋━┫ ┃a[2] ┃─→┃8 ┃9 ┃10┃11┃ ┗━━━━┛┗━┻━┻━┻━┛ 图5. 但从二维数组的角度来看, a代表二维数组的首地址, 当然也可看成是二维数组第0行的首地址。a+1就代表第1行的首地址, a+2就代表第2行的首地址。如果此二维数组的首地址为1000, 由于第0行有4个整型元素, 所以a+1为1008, a+2 也就为1016。如图6.所示 a[3][4] a ┏━┳━┳━┳━┓ (1000)─→┃0 ┃1 ┃2 ┃3 ┃ a+1 ┣━╋━╋━╋━┫ (1008)─→┃4 ┃5 ┃6 ┃7 ┃ a+2 ┣━╋━╋━╋━┫ (1016)─→┃8 ┃9 ┃10┃11┃ ┗━┻━┻━┻━┛ 图6. 既然我们把a[0], a[1], a[2]看成是一维数组名, 可以认为它们分别代表它们所对应的数组的首地址, 也就是讲, a[0]代表第0 行中第0 列元素的地址, 即&a[0][0], a[1]是第1行中第0列元素的地址, 即&a[1][0], 根据地址运算规则, a[0]+1即代表第0行第1列元素的地址, 即&a[0][1], 一般而言, a[i]+j即代表第i行第j列元素的地址, 即&a[i][j]。 另外, 在二维数组中, 我们还可用指针的形式来表示各元素的地址。如前所述, a[0]与*(a+0)等价, a[1]与*(a+1)等价, 因此a[i]+j就与*(a+i)+j等价, 它表示数组元素a[i][j]的地址。 因此, 二维数组元素a[i][j]可表示成*(a[i]+j)或*(*(a+i)+j), 它们都与a[i][j]等价, 或者还可写成(*(a+i))[j]。 另外, 要补充说明一下, 如果你编写一个程序输出打印a和*a, 你可发现它们的值是相同的, 这是为什么呢? 我们可这样来理解: 首先, 为了说明问题, 我们把二维数组人为地看成由三个数组元素a[0], a[1], a[2]组成, 将a[0], a[1], a[2]看成是数组名它们又分别是由4个元素组成的一维数组。因此, a表示数组第0行的地址, 而*a即为a[0], 它是数组名, 当然还是地址, 它就是数组第0 行第0 列元素的地址。

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

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

关于二维数组和指向指针的指针

以前一直有种误解： 二维数组的是数组的数组，所以数组的首地址是指向第一个元素指针，而这个元素又是一个数组，所以把数组首地址理解为指向指针的指针。 如int a[3][2];，以前一直认为a是一个指向int指针的指针，即是一个int**。最近发现这是错的。 如果int **p=a; 编译就会报错。如果强制转换int **p=(int **)a，则使用p[i][j]访问数组元素时出错。 首先，因为a的定义为int a[3][2];则a的类型是int* [3][2]数组类型，或者int* [][2],即指向大小为2的数组的指针，类型与int **不同，所以int **p=a;出错。 其次，考虑p[i][j]访问a的数组元素时出错的问题。当我们使用指向二维数组的指针的下标运算来访问数组元素时，如a[i][j]，它等同于*(a+i*2+j);即必须要知道第二维的大小才能访问。考虑我使用p[i][j]的后果：p是int**，所以p[i]为*(p+i)，而这个结果被视作一个指针，在这里记做pp＝*(p+i)，所以p[i][j]等同于pp[j]。最终的结果为*(pp+j)，并将这个结果解释为一个int值。 int a[3][2]; int val=0; for(int i=0;i<3;++i) { for(int j=0;j<2;++j) { a[i][j]=val++; } } /*使用a[i][j]的方式显然可以正常访问该二维数组*/ /*下面使用指针直接访问，当然是不是int**了……*/ int *p=&a[0][0];/*注意，此处使用int *p=a;或者int *p=a[0];是不对的，p的类型是int型指针，*a或者a[0]是int (*)[2]类型，编译会报错的，* *尽管&a[0][0]、a、a[0]的数值相同……*/ for(int i=0;i<6;++i) { p[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

字符数组,字符指针,sizeof,strlen总结

[cpp] 字符数组,字符指针,sizeof,strlen总结 作者：Hui Wang来源：博客园发布时间：2011-03-26 14:22 阅读：728 次原文链接[收藏]对于字符数组与字符指针: 1. 以字符串形式出现的，编译器都会为该字符串自动添加一个0作为结束符，如在代码中写"abc",那么编译器帮你存储的是"abc\0". 2. 字符串直接量作为字符指针的初始值 ＂hello＂是一个字符串直接量，编译器将其作为const char*处理，与之相关联的内存空间位于内存的只读部分，即允许编译器重用指向等价字符串直接量的引用以优化内存使用， 即使程序中使用了字符串直接量500次，编译器在内存中也只是创建了一个实例。例如: char *ptr = “hello”; 等价于const char *ptr = “hello”; 字符串直接量＂hello＂关联的是只读内存，如果试图修改将出错，例如ptr[1] = …a?;是会引起错误的。 3. 字符串直接量作为基于栈的字符数组的初始值 由于基于栈的变量不可能引用其他地方存储的内存，编译器会负责将字符串直接量复制到基于栈的数组内存中。 例如: char stackArray[] = “hello”; 做如下修改: stackArray[1] = …a?;是真确的。 4. 字符数组与字符指针 字符数组的形式如下,会将字符直接量拷贝到栈上: char str[] = "abc"; // 实际的数据存储: a b c \0,也就是增加了一个终结符\0 char str[3] = {'a','b','c'}; // 实际的数据存储: a b c,并没有在最后添加终结符 char str[10] = {'a','b','c'}; // 实际的数据存储: a b c \0 \0 \0 \0 \0 \0 \0 字符指针的形式如下: char *str = “abc”;// 实际的数据存储: a b c \0,也就是增加了一个终结符\0 5. 类型的决定 1). 数组的类型是由该数组所存放元素的类型以及数组本身的大小决定的 如char s1[3]和char s2[4]，s1的类型就是char[3]，s2的类型就是char[4]，也就是说尽管s1和s2都是字符数组，但两者的类型却是不同的。 2). 字符串常量的类型可以理解为相应字符常量数组的类型 如"abcdef"的类型就可以看成是const char[7],也就是说实际的数据存储为"abcdef\0"。 3). 函数参数列表中的以数组类型书写的形式参数,编译器把其解释为普通的指针类型

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

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

指针经典练习题及答案

二、程序题 1、计算字符串中子串出现的次数。要求:用一个子函数subString()实现, 参数为指向字符串和要查找的子串的指针,返回次数。 2、加密程序:由键盘输入明文，通过加密程序转换成密文并输出到屏幕上。 算法：明文中的字母转换成其后的第4个字母,例如，A变成E(a变成e)， Z变成D,非字母字符不变；同时将密文每两个字符之间插入一个空格。 例如，China转换成密文为G l m r e。 要求：在函数change中完成字母转换，在函数insert中完成增加空格， 用指针传递参数。 3、字符替换。要求用函数replace将用户输入的字符串中的字符t(T)都替换为e(E)， 并返回替换字符的个数。 4、编写一个程序，输入星期，输出该星期的英文名。用指针数组处理。 5、有5个字符串，首先将它们按照字符串中的字符个数由小到大排列， 再分别取出每个字符串的第三个字母合并成一个新的字符串输出 （若少于三个字符的输出空格）。要求：利用字符串指针和指针数组实现。 6、定义一个动态数组，长度为变量n，用随机数给数组各元素赋值， 然后对数组各单元排序，定义swap函数交换数据单元，要求参数使用指针传递。7、实现模拟彩票的程序设计：随机产生6个数字，与用户输入的数字进行比较， 输它们相同的数字个数（使用动态内存分配）。 /*1、计算字符串中子串出现的次数。要求:用一个子函数subString()实现, 参数为指向字符串和要查找的子串的指针,返回次数。*/ #include int subString(char *a, char *b) { int i = 0; int j = 0; int m = 0; char *p = b; while(*a) { while(*a) { if(*a == *b) { break; } a++; } while(*b) { if(*a != *b)

二次指针与二维数组

二次指针与二维数组 首先我们需要知道，什么是二次指针？下面的代码就定义了一个二次指针变量p2。 char **p2; 还是通过图来说明变量、指针变量、二次指针变量的关系吧。 对于代码： char c = …h?; char *p1 = &c; char **p2 = &p1; 其中c、p1、p2的关系如下图所示： 由于“指针生成”规则（参见教材P176）的存在，我们无法将一个数组传递给一个函数。一个折中的解决办法是传递这个数组的第一个元素的地址，以及数组的各个维数，然后在函数中计算得到要操作的数组元素的地址来操作该数组元素。例如： void fun(char *p, int n, int m)//从传入指针指向元素开始，将m*n个元素赋值为5 { for (int i = 0; i < m; i++) for (int j = 0; j < n; j++) *(p + i*n + j) = 5; } main() { char a[2][3]; fun(&a[0][0], 2, 3); return 0; } 显然，其中的fun(&a[0][0], 2, 3);对数组的操作相当于： for (int i = 0; i < m; i++) for (int j = 0; j < n; j++) a[i][j] = 5; 在这段代码中，a[i][j]的形式显然更为浅显易懂，也*(p + i*n + j) = 5更为安全（不容易写错）。接下来我们要做的，就是希望实现这样的功能：函数能够以a[i][j]这样的下标处理一个维度变化的二维数组。 通过指针数组，我们可以实现一个一维长度不同的二维数组。当然，这也就意味着该二维数

指针和数组习题

一、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，数组元素下标是一个整型常量表达式

第8章 指针-3字符数组和字符指针 - 字符串的表示与存储

第8章指针——字符数组与字符指针：字符串的表示与存储

printf("How are you"); H o w a r e y o u \0

printf("How are you.\n "); printf("\"How are you.\"\n"); How are you. _ printf("How are you. Press \ a key and then press Enter:\n"); How are you. Press a key and then press Enter: _ "How are you." _ printf("How are you. Press " "a key and then press Enter:\n"); 问题：如果字符串太长，怎么表示？

?C语言没有提供专门的字符串数据类型 ?字符数组——每个元素都是字符类型的数组 H o w a r e y o u 0 H o w a r e y o u \0

?字符数组的定义 #define STR_LEN 80 char str[STR_LEN+1]; ?字符数组的初始化 用字符常量的初始化列表对数组初始化 char str[6] = {'C','h','i','n','a','\0'}; 用字符串常量直接对数组初始化 char str[6] = {"China"}; char str[6] = "China"; char str[ ] = "China"; char char str[10] = "China";

?字符指针就是指向字符串首地址的指针 ?定义一个字符指针，使其指向一个字符串常量 H e l l o C h i n a \0

字符串指针和字符数组,静态全局、静态局部、全局和局部变量区别,字符串常量和字符串变量,程序的内存分配

最近工作之余，发现了两个自己在C语言学习中的难点，一个是字符串指针和字符数组的区别，一个就是静态全局变量、静态局部变量、全局变量和局部变量的区别，在网上查了不少资料，收获良多，现在与大家分享，有错误的地方请大家指正！ 以下程序用VC++6.0调试 先说说字符串指针和字符数组的区别 1.相同点： /* 用字符数组实现字符串操作*/ main( ) { char str[]="Welcome to study C !"; int i; printf("%s\n",str); for (i=0;i<=7;i++) printf("%c",str[i]); //用*(str+i)也行 printf("\n"); } /* 用字符指针实现字符串操作*/ main() { char *str="Welcome to study C !"; int i; printf("%s\n",str); for(i=0;i<=7;i++) printf("%c",*(str+i)); //用str[i]也行 printf("\n"); } 2.不同点： a)赋值方式不同，字符数组只能对各个元素分别赋值，而字符指针只需赋给字符串的 首地址就可以了。 如: char *str; str="Welcome to study C ！"; 以下对字符数组的赋值是错误的： char str[80]; str[ ]="Welcome to study C ！"; b)字符指针指向字符串，＂hello＂是一个字符串常量，与之相关联的内存空间位于内 存的只读部分，如: char ch[] = "china\n"; char *p; char *pp = "CHINA\n"; p = ch; *(p+2) = 'h';//就是可以的 *(pp+2) = 'h';//此处在编译时不会出错，在执行的时候会出错

二重指针详解

二重指针详解 朱有鹏 1.二重指针 1.1、二重指针与普通一重指针的区别 本质上来说，二重指针和一重指针的本质都是指针变量，指针变量的本质就是变量。 一重指针变量和二重指针变量本身都占4字节内存空间， 1.2、二重指针的本质 (1)二重指针本质上也是指针变量，和普通指针的差别就是它指向的变量类型必须是个一重指针。二重指针其实也是一种数据类型，编译器在编译时会根据二重指针的数据类型来做静态类型检查，一旦发现运算时数据类型不匹配编译器就会报错。 (2)C语言中如果没有二重指针行不行？其实是可以的。一重指针完全可以做二重指针做的事情，之所以要发明二重指针（函数指针、数组指针），就是为了让编译器了解这个指针被定义时定义它的程序员希望这个指针被用来指向什么东西（定义指针时用数据类型来标记，譬如int*p，就表示p要指向int型数据），编译器知道指针类型之后可以帮我们做静态类型检查。编译器的这种静态类型检查可以辅助程序员发现一些隐含性的编程错误，这是C 语言给程序员提供的一种编译时的查错机制。 (3)为什么C语言需要发明二重指针？原因和发明函数指针、数组指针、结构体指针等一样的。 1.3、二重指针的用法 (1)二重指针指向一重指针的地址 (2)二重指针指向指针数组的 (3)实践编程中二重指针用的比较少，大部分时候就是和指针数组结合起来用的。 (4)实践编程中有时在函数传参时为了通过函数内部改变外部的一个指针变量，会传这个指针变量的地址（也就是二重指针）进去 1.4、二重指针与数组指针 (1)二重指针、数组指针、结构体指针、一重指针、普通变量的本质都是相同的，都是变量。 (2)所有的指针变量本质都是相同的，都是4个字节，都是用来指向别的东西的，不同类型的指针变量只是可以指向的（编译器允许你指向的）变量类型不同。 (3)二重指针就是：指针数组指针 2、二维数组 2.1、二维数组的内存映像 一维数组在内存中是连续分布的多个内存单元组成的，而二维数组在内存中也是连续分布的多个内存单元组成的。从内存角度来看，一维数组和二维数组没有本质差别。如：二维数组int a[2][5]和一维数组int b[10]对应关系如下： a[0][0]a[0][1]a[0][4]a[1][0]a[1][1]a[1][4] b[0]b[1]b[4]b[5]b[6]b[9] 既然二维数组都可以用一维数组来表示，那二维数组存在的意义和价值在哪里？明确告诉大家：二维数组a和一维数组b在内存使用效率、访问效率上是几乎相同。使用用二维数组而不用一维数组，原因是在某些情况下，二维数组更好理解、利于组织。我们使用二维数组，并不是必须，而是一种简化编程的方式。一维数组的出现其实也不是必然的，也是为了

C语言多维数组与多级指针

C语言多维数组与多级指针 多维数组与多级指针也是初学者感觉迷糊的一个地方。超过二维的数组和超过二级的指针其实并不多用。如果能弄明白二维数组与二级指针，那二维以上的也不是什么问题了。所以本节重点讨论二维数组与二级指针。 一、二维数组 1、假想中的二维数组布局 我们前面讨论过，数组里面可以存任何数据，除了函数。下面就详细讨论讨论数组里面存数组的情况。Excel 表，我相信大家都见过。我们平时就可以把二维数组假想成一个excel表，比如： char a[3][4]; 2、内存与尺子的对比 实际上内存不是表状的，而是线性的。见过尺子吧？尺子和我们的内存非常相似。一般尺子上最小刻度为毫米，而内存的最小单位为1 个byte。平时我们说32 毫米，是指以零开始偏移32 毫米；平时我们说内存地址为0x0000FF00 也是指从内存零地址开始偏移0x0000FF00 个byte。既然内存是线性的，那二维数组在内存里面肯定也是线性存储的。实际上其内存布局如下图：

以数组下标的方式来访问其中的某个元素：a[i][j]。编译器总是将二维数组看成是一个一维数组，而一维数组的每一个元素又都是一个数组。a[3]这个一维数组的三个元素分别为： a[0],a[1],a[2]。每个元素的大小为sizeof（a[0]）,即sizof(char)*4。由此可以计算出a[0],a[1],a[2]三个元素的首地址分别为& a[0]，& a[0]+ 1*sizof(char)*4，& a[0]+ 2*sizof(char)*4。亦即a[i]的首地址为& a[0]+ i*sizof(char)*4。这时候再考虑a[i]里面的内容。就本例而言，a[i]内有4个char 类型的元素，其每个元素的首地址分别为&a[i]，&a[i]+1*sizof(char)，&a[i]+2*sizof(char)&a[i]+3*sizof(char)，即a[i][j]的首地址为 &a[i]+j*sizof(char)。再把&a[i]的值用a 表示，得到a[i][j]元素的首地址为：a+ i*sizof(char)*4+ j*sizof(char)。同样，可以换算成以指针的形式表示：*(*(a+i)+j)。 经过上面的讲解，相信你已经掌握了二维数组在内存里面的布局了。下面就看一个题： #include intmain(int argc,char * argv[]) { int a [3][2]={(0,1),(2,3),(4,5)}; int *p; p=a [0]; printf("%d",p[0]); } 问打印出来的结果是多少？ 很多人都觉得这太简单了，很快就能把答案告诉我：0。不过很可惜，错了。答案应该是1。如果你也认为是0，那你实在应该好好看看这个题。花括号里面嵌套的是小括号，而不是花括号！这里是花括号里面嵌套了逗号表达式！其实这个赋值就相当于 int a [3][2]={ 1, 3,5}; 所以，在初始化二维数组的时候一定要注意，别不小心把应该用的花括号写成小括号

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

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

指针数组和数组指针的区别 以前这两问题一直都不是很清晰，写程序也管不了这么多，只要不出错能跑出结果就行，其实很多用C的程序员对C的基础知识都一知半解。 这次要给学生讲指针这一章，特意关注了一下。 而网上一些相关回答也没严格区分，显得十分晦涩。 这里整理如下： 数组指针（也称行指针） 定义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][] 所以数组指针也称指向一维数组的指针，亦称行指针。 指针数组 定义int *p[n]; []优先级高，先与p结合成为一个数组，再由int*说明这是一个整型指针数组，它有n个指针类型的数组元素。这里执行p+1是错误的，这样赋值也是错误的：p=a；因为p是个不可知的表示，只存在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]

实验4(数组、指针、字符串)

实验二C++程序设计基础 一、实验目的 （1）、学习并掌握指针的性质 （2）、掌握指针参数的运用，进一步掌握引用的使用方法 （3）、学习函数指针的应用和带参数的main函数 （4）、学习掌握指针与引用、指针与数组、指针与字符串的用法 二、实验内容及步骤 1、选择题 （1）已知一函数的形参说明为int arr[5][6]，在下列说明中，与此等效的形参说明为__________。 A. int arr[][] B. int [5][] C. int *a[6] D. int (* a)[6] （2）已知函数f的原型是：int f(char a,char * b=NULL,double c=0.0); 则下列调用中，不能正确地调用f函数的是__________ 。 A. f(99) B. f(‘A’,4.5) C. f(‘A’,”123”) D. f((char)65,”123”) （3）已知函数f的原型为：void f(int &a,char *b); 变量s,t的定义是：int s; char t[]=”ABCD”;把s和t分别作为第一参数和第二参数来调用函数f，正确的调用语句是：__________ 。 A. f(&s,&t); B. f(&s,t); C. f(s,t); D. f(s,&t); （4）若指针p定义为const char *p="Luchy!"; 则[ ]。 A) p所指向的数据不可改变，p在定义时可以不初始化。 B) p所指向的数据不可改变，p在定义时必须初始化。 C) p本身不可改变，p在定义时可以不初始化。 D) p本身不可改变，p在定义时必须初始化。 （5）已知数组A和指针p定义为：int A[20][10],*p;，要使p指向A的首元素，正确的赋值表达式是[ ]。 A) p=&A 或p=A[0][0] B) p=A 或p=&A[0][0] C) p=&A[0] 或p=A[0][0] D) p=A[0] 或p=&A[0][0] （6）已知函数func的原形是 double func(doouble *pd,int &ri); 变量x和y的定义是 double x; int y; 把x和y分别作为第一参数和第二参数来调用函数func，正确的调用语句是[ ]。 A) func(x,&y); B) func(&x,y); C) func(&x,&y); D) func(x,y); （7）若指针p定义为char * const p="Luchy!"; 则[ ]。 A) p所指向的数据不可改变，p在定义时可以不初始化。 B) p所指向的数据不可改变，p在定义时必须初始化。