第十七章
二维数组的地址和指向二维数组的指针变量
一．二维数组的地址.
1二维数组元素的地址:int a[3][4]
A[2][3] &-----取地址运算符来获得.
2、二数组的地址.
用数组名代表数组首地址也是第一个元素的地址.
Int a[3][3]
1Int a[3] *(a+0)
A[2]
*(A+2)
*(P+1) p[1]
A[2][3]
*(A[2]+3)
*(*(A+2)+3)
备注[]为变地址运算符优先级高于*.
二、行指针变量
1、行指针变量的定义格式:
数据类型(*指针变量名)[常量表达式]
Int (*pr)[4]
备注:
(1)数据类型为基本数据类型
(2)指针变量名
(3)常量表达式规定指针变量指向二维数的一行的元素个数.
(4)*----只起说明作用.说明变量为指针变量。
（5）（）----不能省略。
[]----变地址运算符的优先级高于间接访问运算符.(省略则为指针
数组)
2、行指针指向二维数组.
<1>格式:
行指针变量名=二维数组名
三、二维数组名作为函数实际参数
形式参数有两类
1\数据类型相同数组元素个数相同的二维数组.
原理:形参数组和实参数组共同占用一段内存单元,通过处理形参数组来处理实参数组.
2\数据类型相同的行指针变量原理:
行指针变量指向二维数组.通过行指针变量的移动来访问二维数组.
四、指针数组
1、概念:指针变量的有序集合.
2、指针数组定义格式.
数据类型*数组名[常量表达式]
（6）指针数组中的每个元素是一个列指针变量.
五、二级指针（指向指针变量的指针变量）
1、格式
数据类型**指针变量名
2、备注:
(1)数据类型为基本数据类型
(2)**只起说明作用,说该变量为指向指针变量的指针变量.
3、二级指针指向指针数组.
要用指针处理二维数组，首先要解决从存储的角度对二维数组的认识问题。我们知道，一个二维数组在计算机中存储时，是按照先行后列的顺序依次存储的，当把每一行看作一个整体，即视为一个大的数组元素时，这个存储的二维数组也就变成了一个一维数组了。而每个大数组元素对应二维数组的一行，我们就称之为行数组元素，显然每个行数组元素都是一个一维数组 下面我们讨论指针和二维数组元素的对应关系，清楚了二者之间的关系，就能用指针处理二维数组了。 设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指针---指向指针的指针 彻底搞定C指针---指向指针的指针一．回顾指针概念： 今天我们又要学习一个叫做指向另一指针地址的指针。让我们先回顾一下指针的概念吧！ 当我们程序如下申明变量： short int i; char a; short int * pi; 程序会在内存某地址空间上为各变量开辟空间，如下图所示。 内存地址→6 7 8 9 10 11 12 13 14 15 ------------------------------------------------------------------------------------- … | | | | | | | | | | ------------------------------------------------------------------------------------- |short int i |char a| |short int * pi| 图中所示中可看出： i 变量在内存地址5的位置，占两个字节。 a变量在内存地址7的位置，占一个字节。 pi变量在内存地址9的位置，占两个字节。(注：pi 是指针，我这里指针的宽度只有两个字节，32位系统是四个字节) 接下来如下赋值: i=50; pi=&i; 经过上在两句的赋值，变量的内存映象如下: 内存地址→6 7 8 9 10 11 12 13 14 15 -------------------------------------------------------------------------------------- … | 50 | | | 6 | | | | -------------------------------------------------------------------------------------- |short int i |char a| |short int * pi| 看到没有：短整型指针变量pi的值为6，它就是I变量的内存起始地址。所以，这时当我们对*pi进行读写操作时，其实就是对i变量的读写操作。如：*pi=5; //就是等价于I=5; 你可以回看本系列的第二篇，那里有更加详细的解说。 二．指针的地址与指向另一指针地址的指针 在上一节中，我们看到，指针变量本身与其它变量一样也是在某个内存地址中的，如pi的内存起始地址是10。同样的，我们也可能让某个指针指向这个
一、指针数组及指向一维数组的指针（数组指针）讲解 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
在开发工业以太网项目的时候经常遇到一些小细节问题，在建立数据报进行传输的过程中传递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
. 编程题 1用指向数组的指针变量输出数组的全部元素 2 使用函数调用，形参为指针，实参为数组，把一个数组逆序存放在输出 练习题： 一判断题 1．指针是变量，它具有的值是某个变量或对象的地址值，它还具有一个地址值，这两个地址值是相等的。 2．指针的类型是它所指向的变量或对象的类型。 3．定义指针时不可以赋初值。 4．指针可以赋值，给指针赋值时一定要类型相同，级别一致。5．指针可以加上或减去一个int型数，也可以加上一个指针。6．两个指针在任何情况下相减都是有意义的。 7．数组元素可以用下标表示，也可以用指针表示。 8．指向数组元素的指针只可指向数组的首元素。 9．字符指针是指向字符串的指针，可以用字符串常量给字符指针赋值。 10．引用是一种变量，它也有值和地址值。 11．引用是某个变量的别名，引用是被绑定在被引用的变量上。
12．创建引用时要用一个同类型的变量进行初始化。 13．指针是变量，它可以有引用，而引用不能有引用。 ;. . 二单选题 1．下列关于定义一个指向double型变量的指针，正确的是（）。A．int a(5)；double *pd=a； B．double d(2.5)，*pd=&d；C．double d(2.5)，*pd=d； D．double a(2.5)，pd=d；。）．下列关于创建一个int型变量的引用，正确的是（2A．int a(3)，&ra=a； B int ． a(3),&ra=&a；ra=a；D．int a(3)， C．double d(3.1)；int &rd=d；．下列关于指针概念的描述中，错误的是（）。3 A．指针中存放的 是某变量或对象的地址值．指针的类型是它所存放的数值的类型 B ．指针是变量，它也具有一个内存地址值 C ．指针的值是可以改 变的D 。．下列关于引用概念的描述中，错误的是（）4 A．引 用是变量，它具有值和地址值 B．引用不可以作数组元素 C．引用是变量的别名 D．创建引用时必须进行初始化。++*p相同的是（）*p=a5．已知：int a[5]，；则与a[0] ． B．*++p A++a[0] ．C*p++ D．;. . 6．已知：int a[ ]={1,2,3,4,5}，*p=a；在下列数组元素地址的表
指向二维数组的指针 一. 二维数组元素的地址 为了说明问题, 我们定义以下二维数组: 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 列元素的地址。
编程题 1用指向数组的指针变量输出数组的全部元素 2 使用函数调用，形参为指针，实参为数组，把一个数组逆序存放在输出 练习题： 一判断题 1．指针是变量，它具有的值是某个变量或对象的地址值，它还具有一个地址值，这两个地址值是相等的。 2．指针的类型是它所指向的变量或对象的类型。 3．定义指针时不可以赋初值。 4．指针可以赋值，给指针赋值时一定要类型相同，级别一致。 5．指针可以加上或减去一个int型数，也可以加上一个指针。 6．两个指针在任何情况下相减都是有意义的。 7．数组元素可以用下标表示，也可以用指针表示。 8．指向数组元素的指针只可指向数组的首元素。 9．字符指针是指向字符串的指针，可以用字符串常量给字符指针赋值。 10．引用是一种变量，它也有值和地址值。 11．引用是某个变量的别名，引用是被绑定在被引用的变量上。 12．创建引用时要用一个同类型的变量进行初始化。 13．指针是变量，它可以有引用，而引用不能有引用。
二单选题 1．下列关于定义一个指向double型变量的指针，正确的是（）。 A．int a(5)；double *pd=a；B．double d(2.5)，*pd=&d；C．double d(2.5)，*pd=d；D．double a(2.5)，pd=d； 2．下列关于创建一个int型变量的引用，正确的是（）。 A．int a(3)，&ra=a；B．int a(3),&ra=&a； C．double d(3.1)；int &rd=d；D．int a(3)，ra=a； 3．下列关于指针概念的描述中，错误的是（）。 A．指针中存放的是某变量或对象的地址值 B．指针的类型是它所存放的数值的类型 C．指针是变量，它也具有一个内存地址值 D．指针的值是可以改变的 4．下列关于引用概念的描述中，错误的是（）。 A．引用是变量，它具有值和地址值 B．引用不可以作数组元素 C．引用是变量的别名 D．创建引用时必须进行初始化 5．已知：int a[5]，*p=a；则与++*p相同的是（）。 A．*++p B．a[0] C．*p++ D．++a[0]
一、指针：内容是指示一个内存地址的变量；类型是指示编译器怎么解释指针内容指向地址中的内容，以及该内存区域有多大； 例子： [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/dd2156157.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/dd2156157.html,
以前一直有种误解： 二维数组的是数组的数组，所以数组的首地址是指向第一个元素指针，而这个元素又是一个数组，所以把数组首地址理解为指向指针的指针。 如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语言时，对于指针是最容易让人迷糊的，尤其对于指针数组，而且是指向字符串的指针数组，恐怕就更难理解了。下面本人给出一个例子，详细讲解指向字符串的指针数组的使用情况。希望给予学习C的朋友一点帮助。 下述程序执行后，输出结果是什么？ #include
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语言指针数组和数组指针 一、指针数组和数组指针的内存布局 初学者总是分不出指针数组与数组指针的区别。其实很好理解： 指针数组：首先它是一个数组，数组的元素都是指针，数组占多少个字节由数组本身决定。它是“储存指针的数组”的简称。 数组指针：首先它是一个指针，它指向一个数组。在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;
二次指针与二维数组 首先我们需要知道，什么是二次指针？下面的代码就定义了一个二次指针变量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]这样的下标处理一个维度变化的二维数组。 通过指针数组，我们可以实现一个一维长度不同的二维数组。当然，这也就意味着该二维数
：《再问如何把一个变量的采样值保存到一个数组中呢》本论题共有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
1．变量的指针和指向变量的指针变量 读起来很拗口，说白了就是变量的地址和用来存放变量地址的地址变量。因为一个变量在编译的时候系统要为它分配一个地址，假如再用一个变量来存放这个地址，那么这个变量就叫做指向变量的指针变量，也就是用来存放变量地址的这么一个变量。所谓"指向"就是指存放××的地址，如指向变量的指针变量，"指向"就是指用来存放变量的地址，再如指向数组的指针变量，"指向"就是指存放数组的地址。只要理解了这个，指针也就不难了。另外，还有指向字符串的指针变量，指向函数的指针变量，指向指针的指针变量等。 1) 指针变量的定义 形式：类型标识符*标识符如：int *pointer; 要注意两点：*表示pointer是个指针变量，在用这个变量的时候不能写成*pointer，*pointer 是pointer指向的变量。一个指针变量只能指向同一个类型的变量。如上面 pointer只能指向int型变量。 2)指针变量的引用 两个有关的运算符： & 取地址运算符&a 就代表变量a的地址 * 指针运算符*a就代表变量a的值 2．数组的指针和指向数组的指针变量 数组的指针指数组的起始地址，数组元素的指针指数组元素的地址。 1)指向数组元素的指针变量的定义与赋值 定义和指向变量的指针变量定义相同，c规定数组名代表数组的首地址，即第一个数组元素地址。 2)通过指针引用数组元素 我们通常引用数组元素的形式是a，如果用指针可以这样引用，*(a+i)，或定义一个指针变量p，将数组a的首地址赋给p，p=a;然后用*(p+i)引用。 注意：指针变量ｐ指向数组a首地址，则p++指向数组ａ的下一元素地址，即a[1]的地址。 3)数组名作函数参数 形参数组和实参数组之间并不是值传递，而是共用同一段地址，所以在函数调用过程中如果形参的值发生变化，则实参的值也跟着变化。 4)指向多维数组的指针和指针变量
二重指针详解 朱有鹏 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语言多维数组与多级指针 多维数组与多级指针也是初学者感觉迷糊的一个地方。超过二维的数组和超过二级的指针其实并不多用。如果能弄明白二维数组与二级指针，那二维以上的也不是什么问题了。所以本节重点讨论二维数组与二级指针。 一、二维数组 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
指向对象的指针变量 定义的一般形式： 类名*指针变量名； p-> (*p). 指向对象的成员变量的指针变量： 1.该指针变量可出现在成员函数中，通过获取该成员变量的地址，然后通过（*指针变量名）访问该成员变量 class aa { int a; public: aa() { a=0; } aa(int a) { this->a=a; } void get_a() { int *p; p=&a; cout<<*p< } }; int main() { aa b(3); b.get_a(); aa *p; p=new aa[2]; (p+1)->get_a(); p[1].get_a(); int *q; q=&b.a; return 0; } 指向成员函数的指针变量： 定义的一般形式： 函数类型名(类名::*指针变量名)(参数)； 赋值的一般形式： 指针变量名=对象名.成员函数名 指针变量名=&类名.成员函数名或指针变量名=类名.成员函数名通过指针变量引用对象的成员函数 一般形式：(对象名.*指针变量名)(参数) this指针 #include 指针数组和数组指针的区别 以前这两问题一直都不是很清晰，写程序也管不了这么多，只要不出错能跑出结果就行，其实很多用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]指针数组和数组指针的区别
相关主题
文本预览