c语言---指针

目录

一、指针是什么？

1.指针

2.指针变量

3.一个小的单元是多大？ 如何编址？

4.总结

 二、指针和指针类型

1.指针 + - 整数

2.指针的解引用

三、 野指针

1.野指针成因

2.如何规避野指针

四、指针运算

1.指针+-整数

2.指针-指针

3.指针的关系运算

五、指针和数组

六、二级指针

1.概念

 2.对于二级指针的运算

 七、指针数组

---

一、指针是什么？

1.指针

        1. 指针是内存中一个最小单元的编号，也就是地址。

        2. 平时口语中说的指针，通常指的是指针变量，是用来存放内存地址的变量。

2.指针变量

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

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

3.一个小的单元是多大？ 如何编址？

        经过仔细的计算和权衡发现一个字节给一个对应的地址是比较合适的。对于32位的机器，假设有32根地址线，那么假设每根地址线在寻址的时候产生高电平（高电压）和低电平（低电压），就是（1或者0）；那么32根地址线产生的地址就会是：

00000000 00000000 00000000 00000000

00000000 00000000 00000000 00000001

...

11111111 11111111 11111111 11111111

        这里总共有2的32次方个地址。

        每个地址标识一个字节，那我们就可以给4G的空间进行编址。

（2^32Byte == 2^32/1024KB == 2^32/1024/1024MB==2^32/1024/1024/1024GB == 4GB）

一个字节八个bite位

这里我们就明白：

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

 4.总结：

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

#include<stdio.h>
int main()
{
	int a = 10;
	int* pa = &a;
	char ch = 'w';
	char* pc = &ch;
	printf("%d\n", sizeof(pa));  //4
	printf("%d\n", sizeof(pc));  //4
	return 0;
}

 输出结果都是4，和是整形还是字符无关。

 二、指针和指针类型

char  *pc = NULL;

int   *pi = NULL;

short *ps = NULL;

long  *pl = NULL;

float *pf = NULL;

double *pd = NULL;

1.指针 + - 整数

#include <stdio.h>
int main()
{
	int n = 10;
	char* pc = (char*)&n;
	int* pi = &n;
	printf("%p\n", &n);
	printf("%p\n", pc);
	printf("%p\n", pc + 1);
	printf("%p\n", pi);
	printf("%p\n", pi + 1);
	return  0;
}

        输出结果是： 

0000007F50CFFA24
0000007F50CFFA24
0000007F50CFFA25
0000007F50CFFA24
0000007F50CFFA28

2.指针的解引用

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

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

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

三、 野指针

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

1.野指针成因

a.指针未初始化

#include <stdio.h>
int main()
{ 
     int *p;//局部变量指针未初始化，默认为随机值
     *p = 20;
     return 0;
}

b.指针越界访问

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

c.指针指向的空间释放

2.如何规避野指针

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.指针+-整数

#define N_VALUES 5
float values[N_VALUES];
float *vp;
for (vp = &values[0]; vp < &values[N_VALUES];)
{
     *vp++ = 0;
}

2.指针-指针

int main()
{
	int arr[10] = { 0 };
	printf("%d\n", &arr[0] - &arr[9]);
	return 0;
}

 答案是9。

my_strlen的实现
1. 计数器的方法   2. 递归  3. 指针-指针

int my_strlen(char* str)
{
	char* start = str;
	while (*str)
	{
		str++;
	}
	return str - start;
}
int main()
{
	char arr[] = "abcdef";
	int len = my_strlen(arr);
	printf("%d\n", len);
	return 0;
}

3.指针的关系运算

for(vp = &values[N_VALUES]; vp > &values[0];)
{
    *--vp = 0;
}

代码简化, 这将代码修改如下：

for(vp = &values[N_VALUES-1]; vp >= &values[0];vp--)
{
    *vp = 0;
}

标准规定：

允许指向数组元素的指针与指向数组最后一个元素后面的那个内存位置的指针比较，但是不

允许与指向第一个元素之前的那个内存位置的指针进行比较。

五、指针和数组

既然可以把数组名当成地址存放到一个指针中，我们使用指针来访问一个就成为可能。

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

运行结果：

&arr[0] = 0000005B079BF618   <====> p+0 = 0000005B079BF618
&arr[1] = 0000005B079BF61C   <====> p+1 = 0000005B079BF61C
&arr[2] = 0000005B079BF620   <====> p+2 = 0000005B079BF620
&arr[3] = 0000005B079BF624   <====> p+3 = 0000005B079BF624
&arr[4] = 0000005B079BF628   <====> p+4 = 0000005B079BF628
&arr[5] = 0000005B079BF62C   <====> p+5 = 0000005B079BF62C
&arr[6] = 0000005B079BF630   <====> p+6 = 0000005B079BF630
&arr[7] = 0000005B079BF634   <====> p+7 = 0000005B079BF634
&arr[8] = 0000005B079BF638   <====> p+8 = 0000005B079BF638
&arr[9] = 0000005B079BF63C   <====> p+9 = 0000005B079BF63C

所以 p+i 其实计算的是数组 arr 下标为i的地址。 那我们就可以直接通过指针来访问数组。

int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int* p = arr;
	int sz = sizeof(arr) / sizeof(arr[0]);
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", *(p + i));
	}
	printf("%p\n", arr);
	printf("%p\n", &arr[0]);
	printf("%d\n", sizeof(arr));
	return 0;
}

输出结果：

1 2 3 4 5 6 7 8 9 10
012FFDAC
012FFDAC
40   

数组名是数组首元素的地址
但是有2个例外：
sizeof(数组名)，数组名表示整个数组，计算的是整个数组的大小
&数组名，数组名表示整个数组，取出的是整个数组的地址

int main()
{
	int arr[10] = { 0 };
	printf("%p\n", arr);
	printf("%p\n", arr+1);
	printf("%p\n", &arr[0]);
	printf("%p\n", &arr[0]+1);
	printf("%p\n", &arr);
	printf("%p\n", &arr+1);
	return 0;
}

 输出结果：

0053FE64
0053FE68
0053FE64
0053FE68
0053FE64
0053FE8C

六、二级指针

1.概念

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

 2.对于二级指针的运算

int main()
{
	int a = 10;
	int* pa = &a;//pa是指针变量（一级指针）
	int** ppa = &pa;//ppa是一个二级指针
	int*** pppa = &ppa;//pppa就是三级指针
	return 0;
}

 七、指针数组

指针数组是指针还是数组？

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

int main()
{
	int a = 10;
	int b = 11;
	int c = 12;
	int d = 13;
	int e = 14;
	int* arr2[5] = {&a, &b, &c, &d, &e};//指针数组
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		printf("%d ", *(arr2[i]));
	}
	return 0;
}

输出是：10 11 12 13 14

int main()
{
	int data1[] = { 1,2,3,4,5 };
	int data2[] = { 2,3,4,5,6 };
	int data3[] = { 3,4,5,6,7 };
	int* arr[3] = { data1 ,data2, data3 };  //arr就是一个指针数组
	int i = 0;
	for (i = 0; i < 3; i++)
	{
		int j = 0;
		for (j = 0; j < 5; j++)
		{
			printf("%d ", arr[i][j]);
		}
		printf("\n");
	}
	return 0;
}

输出结果是：

1 2 3 4 5
2 3 4 5 6
3 4 5 6 7