C语言学习笔记（七） | 初识指针

目录

指针

指针是什么？

 指针和指针类型

指针类型的意义 

野指针 

野指针成因

如何规避野指针 

指针运算

指针 + - 整数

指针 - 指针

指针的关系运算

指针和数组 

 二级指针

指针数组 

---

指针

指针是什么？

在计算机科学中，指针（Pointer）是编程语言中的一个对象，利用地址，它的值直接指向（points to）存在电脑存储器中另一个地方的值。由于通过地址能找到所需的变量单元，可以说，地址指向该变量单元。因此，将地址形象化的称为“指针”。意思是通过它能找到以它为地址的内存单元。

 指针是个变量，存放内存单元的地址（编号）。

对应到代码

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

总结：指针就是变量，用来存放地址的变量。（存放在指针中的值都被当成地址处理）。

对于32位的机器，假设有32根地址线，那么假设每根地址线在寻址的是产生一个电信号正电/负电（1或 者0），这里就可以产生2的32次方个地址。 

每个地址标识一个字节，那我们就可以给

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

4G的空闲进行编址。64位机器，计算方式同理。

这里我们就明白：

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

总结：

指针是用来存放地址的，地址是唯一标示一块地址空间的。

指针的大小在32位平台是4个字节，在64位平台是8个字节。

 指针和指针类型

指针的定义方式是： type + * 。

其实：

char* 类型的指针是为了存放 char 类型变量的地址。

short* 类型的指针是为了存放 short 类型变量的地址。

int* 类型的指针是为了存放 int 类型变量的地址。

指针类型的意义 

 int、char类型举例

#include<stdio.h>

int main()
{
	int a = 0x11223344;
	int* pa = &a;
	char* pc = &a;
	printf("%p\n", pa);//00AFF8A0
	printf("%p\n", pa+1);//00AFF8A4
	printf("%p\n", pc);//00AFF8A0
	printf("%p\n", pc+1);//00AFF8A1
	*pa = 0;
	printf("%d\n", a);//0
	a = 0x11223344;
	*pc = 0;
	printf("%d\n", a);//287453952 - 11223300

	return 0;
}

总结：

1.虽然二者存储的地址相同，但是指针类型决定了指针进行解引用操作时候，能访问空间的大小。
    int* p：*p 能访问4个字节
    char* p：*p 能访问1个字节
    double* p：*p能够访问8个字节

2.指针类型还决定了指针走一步走多远（指针的步长）
    int* p：p+1->4个字节
    char* p：p+1->1个字节
    double* p：p+1->8个字节

野指针 

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

野指针成因

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++)
   {
        *(p++) = i;//当指针指向的范围超出数组arr的范围时，p就是野指针
   }
    return 0;
}

3. 指针指向的空间释放

#include<stdio.h>

int* test()
{
	int a = 0;
	return &a;
}
int main()
{
	int* p = test();//函数返回地址后，a的空间就还回系统了
	*p = 20;
	printf("%d\n", *p);
	return 0;

如何规避野指针 

1. 指针初始化

#include<stdio.h>

int main()
{
    int a = 10;
    int* pa = &a;//初始化
    //不知道初始化成什么时
    int* p = NULL;//NULL - 用来初始化指针，给指针赋值
    return 0;
}

2. 小心指针越界
3. 指针指向空间释放了，可指向NULL
4. 指针使用之前检查有效性 - 指针为NULL时不能用

指针运算

指针+-整数

#include<stdio.h>

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

指针-指针

#include<stdio.h>

int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	char ch[5] = { 0 };
	printf("%d\n", &arr[9] - &arr[0]);//9=元素个数
	printf("%d\n", &ch[5] - &ch[0]);//5=元素个数  
	return 0;
}

应用

前面递归文章中已经实现了两种模拟strlen - 计数器的方式。

方式3

#include<stdio.h>

int my_strlen(char* str)
{
	char* start = str;
	char* end = str;
	while (*end != '\0')
	{
		end++;
	}
	return end - start;
}

int main()
{
	//strlrn - 求字符串长度
	char arr[] = "hello";//hello\0
	int len = my_strlen(arr);
	printf("%d\n", len);
	return 0;
}

指针的关系运算

即比较指针大小。

代码演示

#include<stdio.h>

int main()
{
	int arr[5] = { 1 };
	int* p;
    //1.
	for (p = &arr[5]; p > &arr[0];)
	{
		printf("%d ", * --p = 0);
	}
	//2.化简
	for (p = &arr[4]; p >= &arr[0];p--)
	{
		printf("%d ", *p = 0);
	}

	//尽量写第一种
	//第2种实际在绝大部分的编译器上是可以顺利完成任务的，但我们还是应该避免这样写，
    //因为标准并不保 证它可行。 

	return 0;
}

 标准规定：

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

指针和数组 

数组名是什么？我们看一个例子：

#include<stdio.h>

int main()
{
    int arr[10] = { 1,2,3,4,5,6,7,8,9,0 };
    printf("%p\n", arr);//00FAFD24
    printf("%p\n", &arr[0]);//00FAFD24
    //数组名表示的是数组首元素的地址。

    //两个例外
    //一、
    //&arr 取出的是整个数组的地址
    //二、
    //sizeof(arr)  计算的整个数组的大小
    return 0;
}

结论：数组名表示的是数组首元素的地址。 

那么这样写代码是可行的：

int arr[10] = {1,2,3,4,5,6,7,8,9,0};
int *p = arr;//p存放的是数组首元素的地址

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

例如：

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

运行结果

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

 二级指针

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

代码演示

#include <stdio.h>

int main()
{
	int a = 10;
	int* pa = &a;
	int** ppa = &pa;//ppa - 二级指针
	int*** pppa = &ppa;//pppa - 三级指针
	printf("%p\n", pa);//00CFF840
	printf("%p\n", ppa);//00CFF834
	printf("%p\n", pppa);//00CFF828

	printf("%d\n", *pa);//10 - a
	printf("%d\n", **ppa);//10 - a
	printf("%d\n", ***pppa);//10 - a
	return 0;
}

指针数组 

指针数组就是存放指针的数组。

代码演示

#include <stdio.h>

int main()
{
	int a = 10;
	int b = 20;
	int c = 30;
	int* arr[3] = { &a,&b,&c };//指针数组
	int i = 0;
	for (i = 0; i < 3; i++)
	{
		printf("%d ", *arr[i]);
	}
	return 0;
}