第六课：初级指针

目录

第六课：初级指针

1.1·指针是什么？

1.2·指针和指针类型

1.3·野指针

1.4·指针运算与指针操作

1.5·指针和数组以及变长数组(VLA)

1.6·二级指针

1.7·指针数组

1.8·指针的兼容性

---

1.1·指针是什么？

指针就是地址，口语中说的指针通常指的是指针常量。

指针理解的两个要点：

1. 指针是内存中一个最小单元的编号，也就是地址
2. 平时口语中说的指针，通常指的是指针变量，是用来存放内存地址的变量

可以理解为：

指针变量：我们可以通过&（取地址操作符）取出变量的内存其实地址，把地址可以存放到一个变量中，这个变量就是指针变量。

#include <stdio.h>
int main()
{
int a = 10;//在内存中开辟一块空间
int *p = &a;//这里我们对变量a，取出它的地址，可以使用&操作符。//a变量占用4个字节的空间，这里是将a的4个字节的第一个字节的地址存放在p变量//中，p就是一个之指针变量。
return 0;
}

总结：
指针变量，用来存放地址的变量。（存放在指针中的值都被当成地址处理）。
那这里的问题是：
①一个小的单元到底是多大？（1个字节）
②如何编址？
经过仔细的计算和权衡我们发现一个字节给一个对应的地址是比较合适的。
对于32位的机器，假设有32根地址线，那么假设每根地址线在寻址的时候产生高电平（高电压）和低电平（低电压）就是（1或者0）；那么32根地址线产生的地址就会是：

00000000 00000000 00000000 00000000
00000000 00000000 00000000 00000001
...
11111111 11111111 11111111 11111111
 

这里就有2的32次方个地址。每个地址标识一个字节，那我们就可以给 （2^32Byte == 2^32/1024KB ==2^32/1024/1024MB==2^32/1024/1024/1024GB == 4GB） 4G的空闲进行编址。同样的方法，那64位机器，如果给64根地址线，那能编址多大空间，自己计算。

这里我们就明白：
在32位的机器上，地址是32个0或者1组成二进制序列，那地址就得用4个字节的空间来存储，所以
一个指针变量的大小就应该是4个字节。
那如果在64位机器上，如果有64个地址线，那一个指针变量的大小是8个字节，才能存放一个地
址。

所以我们才能得出：

指针是用来存放地址的，地址是唯一标示一块地址空间的。
指针的大小在32位平台是4个字节，在64位平台是8个字节。

---

1.2·指针和指针类型

我们都知道，变量有不同的类型，整形，浮点型等。那指针有没有类型呢？
准确的说：有的。

char *pc = NULL;
int *pi = NULL;
short *ps = NULL;
long *pl = NULL;
float *pf = NULL;
double *pd = NULL;
//这里可以看到，指针的定义方式是： type + * 其实：
char* 类型的指针是为了存放 char 类型变量的地址。
short* 类型的指针是为了存放 short 类型变量的地址。
int* 类型的指针是为了存放 int 类型变量的地址。

指针的解引用:

举例：

//一
#include <stdio.h>
int main()
{
int n = 0x11223344;
char *pc = (char *)&n;
int *pi = &n;
*pc = 0; //重点在调试的过程中观察内存的变化。
*pi = 0; //重点在调试的过程中观察内存的变化。
return 0;
}//二
#include<stdio.h>
int main()
{int a=0x11223344;int*pa=&a;*pa=0;return 0;
}

 

 

 总结：指针的类型决定了，对指针解引用的时候有多大的权限（能操作几个字节）

 比如： char* 的指针解引用就只能访问一个字节，而 int* 的指针的解引用就能访问四个字节。
 

---

1.3·野指针

概念： 野指针就是指针指向的位置是不可知的（随机的、不正确的、没有明确限制的）

野指针形成的原因：

1.指针未初始化

2.指针越界访问

3.指针指向的空间释放

举例：

//1.指针未初始化
#include <stdio.h>
int main()
{
int *p;//局部变量指针未初始化，默认为随机值
*p = 20;
return 0;
}//2.指针越界
#include <stdio.h>
int main()
{
int arr[10] = {0};
int *p = arr;
int i = 0;
for(i=0; i<=11; i++)
{
//当指针指向的范围超出数组arr的范围时，p就是野指针
*(p++) = i;
}
return 0;
}//3.指针指向的空间释放
void test()
{
int i = 0;
int *p = (int *)malloc(10*sizeof(int));
if(NULL == p)
{exit(EXIT_FAILURE);
}
for(i=0; i<=10; i++)
{*(p+i) = i;//当i是10的时候越界访问
}
free(p);
}
free(p);

如何规避野指针：

1. 指针初始化
2. 小心指针越界
3. 指针指向空间释放即使置NULL
4. 避免返回局部变量的地址
5. 指针使用之前检查有效性
 

include <stdio.h>
int main()
{
int *p = NULL;
//....
int a = 10;
p = &a;
if(p != NULL)
{
*p = 20;
}
return 0;
}

---

1.4·指针运算与指针操作

指针+-整数：

#define N_VALUES 5
float values[N_VALUES];
float *vp;
//指针+-整数；指针的关系运算
for (vp = &values[0]; vp < &values[N_VALUES];)
{*vp++ = 0;
}

指针-指针：

int my_strlen(char *s)
{
char *p = s;
while(*p != '\0' )
p++;
return p-s;
}

 

指针操作：C提供了一些基本的指针操作。大致有8种不同的操作(指针重点就在这里，非常重要)

#include<stdio.h>
int main()
{int urn[5]={100,200,300,400,500};int* ptr1,*ptr2,*ptr3;prt1=urn;//把一个地址赋给指针ptr2=&urn[2];//把一个地址赋给指针①printf("ptr1=%p,*ptr2=%d,&ptr1=%p\n",ptr1,*ptr1,&ptr1);//指针加法ptr3=ptr1+4；②printf("ptr1+4=%p,*(ptr1+4)=%d\n",ptr1+4,*(ptr1+4));//递增指针ptr1++;③printf("ptr1=%p,*ptr1=%d,&ptr1=%p\n",ptr1,*ptr1,&ptr1);//递减指针ptr2--;④printf("ptr2=%p,*ptr2=%d,&ptr2=%p\n",ptr2,*ptr2,&ptr2);//恢复为初始值--ptr1;++ptr2;⑤printf("ptr1=%p,ptr2=%p\n",ptr1,ptr2);//一个指针减去另一个指针⑥printf("ptr1=%p,ptr2=%p,ptr2-ptr1=%td\n",ptr2,ptr1,ptr2-ptr1);//一个指针减去一个整数⑦printf("ptr3=%p,ptr3-2=%p\n",ptr3,ptr3-2);return 0;}
//输出结果(个人可能不同哈)
①ptr1=0x7fff5fbff8d0,*ptr1=100,&ptr1=0x7fff5fbff8c8
②prt1+4=0x7fff5fbff8e0,*(ptr1+4)=500
③ptr1=0x7fff5fbff8d4,*ptr1=200,&ptr1=0x7fff5fbff8c8
④ptr2=0x7fff5fbff8d4,*ptr2=200，&ptr2=0x7fff5fbff8c0
⑤ptr1=0x7fff5fbff8d0,*ptr2=0x7fff5fbff8d8
⑥ptr2=0x7fff5fbff8d8,*ptr1=0x7fff5fbff8d0,ptr2-ptr1=2
⑦ptr3=0x7fff5fbff8e0,ptr3-2=0x7fff5fbff8d8//请大家结合编译结果和下面的字来理解基本指针操作
//这里大家看这代码可能很难懂他的意思，但是在高阶指针里我会仔细跟大家讲解

①赋值：可以把地址赋给指针。例如：用数组名、带地址运算符(&)的变量名，另一个指针进行赋值。在该例中，把urn数组的首地址赋给ptr1,该地址得编号恰好是0x7fff5fbff8d0。变量ptr2获得数组urn得第3个元素(urn[2])得地址。

②解引用：*运算符给出指针指向地址上存储得值。因此，*ptr1的初值是100。该值存储在编号为0x7fff5fbff8d0的地址上。一定要牢记，千万不要解引用未初始化的指针(解引用未初始化的指针会可能不会出什么错，也可能会，擦写数据或代码，或者导致程序崩溃，切记创建一个指针时，系统只分配了存储指针本身的内存，并未分配存储数据的内存，因此，在使用指针之前，必须先用已分配的地址初始化它)

③取值：和所有变量一样。指针变量也有自己的地址和值。对指针而言，&运算符给出指针本身的地址。本例题中，ptr1存储在内存编号为0x7fff5fbff8c8的地址上，该存储单元的内容是0x7fff5fbff8d0，即urn的地址。因此&ptr1是指向ptr1的指针，而ptr1是指向urn[0]的指针。

④指针与整数相加：可以使用+运算符把指针和整数相加，或整数与指针相加，无论哪种情况，整数都会和指针所指向类型的大小(比字节为单位)相乘，然后把结果与初始地址相加。因此ptr1+4与&urn[4]等价。如果相加的结果超出了初始指针的数组范围，计算结果则是未定义的。除非正好超过数组末尾第一个位置，C保证该指针有效。

⑤递增指针：递增指向数组元素的指针可以让该指针移动到数组的下一个元素。因此，ptr1++相当于把ptr1的值加上4(我们系统中int为4字节)，ptr1指向urn[1]。现在ptr1的值是0x7fff5fbff8d4(数组的下一个元素的地址),*ptr的值为200(即urn[1]的值)。注意，ptr1本身的地址仍为0x7fff5fbff8c8毕竟，变量不会因为值发生变化就移动位置。

⑥指针减去一个整数：可以使用-运算符从一个指针中减去一个整数。指针必须是第1个运算对象，整数时第2个运算对象。该整数将乘以指针指向类型的大小(以字节为单位)，然后用初始地址减去乘积。所以ptr3-2与&urnp[2]等价，因为ptr3指向的时urn[4]，如果相减的结果超出了初始指针所指向数组的范围，计算结果则是未定义的。除非正好超出数组末尾第一个位置，C保证该指针有效。

⑦递减指针：当然，除了递增指针还可以递减指针。在本例中，递减ptr2使其指向数组的第2个元素而不是第1个元素。前缀或后缀的递增和递减运算符都可以使用。注意，在重置ptr1和ptr2前，它们都指向相同的元素urn[1]。

⑧指针求差：可以计算两个指针的差值。通常，求差的两个指针分别指向同一个数组的不同元素，通过计算求出两元素之间的距离。差值的单位与数组类型的单位相同。例如，程序的输出中，ptr2-ptr1=2，意思就是着两个指针指向的两个元素相隔2个int，而不是2字节。只要这两个指针指向相同的数组(或其中一个指针指向数组后的第1个地址)，C都能保证运算有效。如果两个不同数组的指针进行求差运算可能会得出一个值，或者导致运算时错误。

⑨比较：使用关系运算符可以比较两个指针的值，前提是两个指针都指向相同类型的对象。

//多看几遍，这里不理解很麻烦，C/C++的精髓就是使用指针和内存

---

1.5·指针和数组以及变长数组(VLA)

基本概念我们就不讲了，在初识C语言和数组里讲了，这里注重理解。

我们先看一个例子：

#include <stdio.h>
int main()
{
int arr[10] = {1,2,3,4,5,6,7,8,9,0};
printf("%p\n", arr);
printf("%p\n", &arr[0]);
return 0;
}

可见数组名和数组首元素的地址是一样的。
结论：数组名表示的是数组首元素的地址。（2种情况除外，数组章节讲解了)

那么上面的代码我们可以改成：

#include <stdio.h>
int main()
{
int arr[] = {1,2,3,4,5,6,7,8,9,0};
int *p = arr; //指针存放数组首元素的地址
int sz = sizeof(arr)/sizeof(arr[0]);
for(i=0; i<sz; i++)
{
printf("&arr[%d] = %p <====> p+%d = %p\n", i, &arr[i], i, p+i);
}
return 0;
}

 直接通过指针VLA访问数组：

int main()
{
int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
int *p = arr; //指针存放数组首元素的地址
int sz = sizeof(arr) / sizeof(arr[0]);
int i = 0;
for (i = 0; i<sz; i++)
{
printf("%d ", *(p + i));
}
return 0;
}

变成数组(VLA)：

读者在学习处理二位数组的函数中可能不太理解。为何只把数组的行数作为函数的形参，而列数却内置在函数体内。例如：

//函数
#define COLS 4
int  sum2d(int ar[][COLS],int rows)
{int r;int c;int tot=0;for(r=0;r<rows;r++)for(c=0;c<COLS;c++)tot+=ar[r][c];return tot;
}/*假设声明了下列数组：int array1[5][4];int array2[100][4];int array3[2][4];可以用sum2d()函数分别计算这些数组的元素之和:
tot=sum2d(array1,5);//5X4数组的元素之和
tot=sum2d(array2,100)；//100X4数组的元素之和
tot=sum2d(array3,2);//2X4数组的元素之和
*/

sum2d()函数之所以能处理这些数组，是因为这些数组的列数固定为4，而行数被传递给形参rows，rows是一个变量。但是如果要计算6x5的数组(即6行5列)，就不能使用这个函数，必须重新创建一个CLOS为5的函数。因为C规定，数组的维数必须是常量，不能用变量CLOS。

鉴于此，C99新增了变长数组VLA，允许使用变量表示数组的维度。

例如：

int a=4;
int b=6;
double asles[a][b];//一个变长数组

前面提到过，变长数组有一些限制。变长数组必须是自动存储类别，这意味着无论在函数中声明还是作为函数形参声明，都不能使用static或extern存储类别说明符。

注意：变长数组不能改变大小。这里的变是指不可以更改以创建数组的大小。由于变长数组是C语言的新特性，所以目前完全支持这一特性的编译器不多。

---

1.6·二级指针

指针变量也是变量，是变量就有地址，那指针变量的地址存放在哪里？
这就是 二级指针。

对于二级指针的运算有：
*ppa 通过对ppa中的地址进行解引用，这样找到的是 pa ， *ppa 其实访问的就是 pa .

 

**ppa 先通过 *ppa 找到 pa ,然后对 pa 进行解引用操作： *pa ，那找到的是 a
 

多级指针：

---

 

1.7·指针数组

指针数组是指针还是数组？
答案：是数组。是存放指针的数组。
数组我们已经知道整形数组，字符数组。

 那指针数组是怎样的？

  int* arr3[5];//是什么？
  arr3是一个数组，有五个元素，每个元素是一个整形指针。

---

 

1.8·指针的兼容性

指针之间的赋值比数组类型之间的赋值要严格。例如：

//声明
int* pt;
int (*pa)[3];
int ar1[2][3];
int ar2[3][2];
int** p2;//赋值
pt=&ar1[0][0];//都是指向int的指针
pt=ar1[0];//都是指向int的指针
pt=ar1;//无效赋值
pa=ar1;//都是指向内含3个int类型元素数组的指针
pa=ar2;//无效赋值
p2=&pt;//都是指向int*的指针
*p2=ar2[0];//都是指向int的指针
p2=ar2;//无效赋值

此内容超出了入门层次，会在深入理解C语言的时候讲解，这里先留下提供给大家一定的了解。