什么是指针?
通俗来说指针就相当于地址,因为我们写入的代码每个变量的数据类型不同,字节大小不同,在计算机内存中所开辟存储的大小自然不同,且指针通常存储的是内存单元中最小单元的编号
比如:int*指针的大小是4个字节,在内存存储地址分别为0x11223344 0x11223355 0x11223366 0x11223377,那么int*指针存储的就是0x11223344内存地址(内存地址是我随便编的,因为在计算机中内存存储中地址是计算机随机分配的地址)
#include<stdio.h>
int main()
{
int a = 10;
//%p是用来打印地址的
//&a取地址符号
printf("%p\n", &a);
return 0;
}
在内存中的分配
每个内存都有自己对应的唯一编号,编号==地址==指针,在写代码时创建的变量、数组、结构体等都要在内存上开辟空间。
为什么一个内存单元字节要设置为1个字节呢?
经过前人的不断钻研和计算,发现给内存单元一个字节大小是最优解。
在32位的计算机上有32根物理地址线,在32根地址线在寻找地址的时候产生高电平(1)和低电平(0)
就是二进制的1和0 那么它们能产生的地址如下:
也就是2^32次方 2^32=4294967296字节 能够管理4294967296内存字节空间
差不多4GB多一点内存空间
这就是为什么64位机器比32位机器内存空间大 比32位机器寻址能力强
在进行复杂的数据处理时,性能强 速度快等优点。
#include<stdio.h>
int main()
{
//在内存中开辟4个字节大小
int a = 10;
//int*的指针变量 通过&取地址将a中4个内存单元中最小字节存储到了指针变量p中
int* p = &a;
printf("%p\n", &a);
printf("%p\n", p);
return 0;
}
p就是一个指针变量,用来存放地址的变量。
指针大小
通过32位机器中32根地址线和64位机器中64根地址线,就能发现指针大小不同。
一般在32位机器中不管指针变量存储的是什么数据类型的地址,大小都为4个字节
一般在64位机器中不管指针变量存储的是什么数据类型的地址,大小都为8个字节
VS2019 32位环境编译
#include<stdio.h>
int main()
{
printf("%d\n", sizeof(int*));
printf("%d\n", sizeof(char*));
printf("%d\n", sizeof(short*));
printf("%d\n", sizeof(double*));
printf("%d\n", sizeof(long long*));
return 0;
}
VS2019 64位环境编译
指针和指针类型
在创建变量中,系统提供的内置类型有很多,比如int、short、double...等,那么指针也有类型吗?
指针也有对应的指针类型,也是整形,浮点型等,因为指针存储的就是变量的地址。
#include<stdio.h>
int main()
{
int a = 0x11223344;
int* pa = &a;
*pa = 0;
return 0;
}
我们可以看见不同类型指针变量,能够解引用*操作的空间与指针类型有关。
int*的指针解引用4个字节 char*的指针解引用1个字节
总结:指针类型决定了指针解引用的操作权限。
(也就是指针解引用访问多少个字节空间取决于指针类型)
Type*p
*p表明是一个指针变量 p指向的对象类型是Type p解引用的时候访问对象大小是sizeof(Type)。
int*pa=&a 的意思是 *p表明是一个指针变量 p指向的对象类型是int
p解引用访问的对象大小字节是int(4个字节)
#include<stdio.h>
int main()
{
int a = 0x11223344;
int* pa = &a;
char* pb = (char*)&a;
printf("%p\n", pa);
printf("%p\n", pa+1);
printf("%p\n", pb);
printf("%p\n", pb+1);
return 0;
}
C4到C8是4个字节大小 C4到C5是一个字节大小
总结:指针的类型决定了指针向前或者向后走一步有多大(距离) 。
什么是野指针
野指针:野指针就是指针指向的位置是未知的(随机的,不正确的,没有明确限制的)。
比如野狗就是野指针,没有主人,它就没有温暖的家,只能四处流浪。
*p就相当于野狗具有危险性
*p1=NULL 相当于野狗拴上了狗链子,危险性大大降低。
野指针是怎么形成的?
1.指针没有初始化
#include<stdio.h>
int main()
{
int* p;
int a = 10;
*p = a;
return 0;
}
在*p没有初始化,局部变量没有初始化,希望默认为随机值,一般不知道指针变量要指向哪个变量,就置为空即可(NULL)。
在C语言中NULL就是0
2.指针越界访问
#include<stdio.h>
int main()
{
int arr[5] = { 0 };
int* p = arr;
int i = 0;
for (i = 0; i <= 5; i++)
{
*(p++) = i;
}
return 0;
}
当指针指向的范围超出了数组arr范围时,就会造成野指针,因为数组arr总共就5个数,数组下标从0到4,而for循环的判断条件却是小于等于5,超出数组原本的范围,形成了数组越界访问,造成野指针的形成。在VS2019编译器会帮忙检查越界,不同编译器不同,如果你在工作时编译器不会帮你检查越界问题,而代码运行不起来时,你就要开始自己疯狂挠头了!所以要避免野指针的形成。
3.指针指向的空间释放
在动态内存管理malloc realloc calloc free,忘记free开辟的动态内存空间,一般情况下不用释放也行,虽然不释放形成了野指针,但只要没有人用就没有危险,但一般动态内存开辟使用完,记得free也是一个好习惯。
避免野指针的形成
1.指针初始化
2.小心指针越界
3.指针指向空间free释放置为空
4.指针使用之前检查有效性
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
int main()
{
//指向初始化
int* p = NULL;
p = (int*)malloc(sizeof(20));
if (p == NULL)//使用之前检查有效性(是否为空)
{
perror("malloc fail");
exit(-1);
}
//p!=NULL
*p = 20;
printf("%d\n", *p);
free(p);
p = NULL;
return 0;
}
指针和数组
指针和数组虽然是两个不同的东西,但它们俩之间却有着千丝万缕的联系。
#include<stdio.h>
int main()
{
int arr[10] = { 0 };
int* p = &arr[0];
int i = 0;
for (i = 0; i < 10; i++)
{
*p = i;
p++;
}
for (i = 0; i < 10; i++)
{
printf("%d ", arr[i]);
}
return 0;
}
首先我们要注意:数组名原则上会被解释为指向该数组起始元素的指针
但有两种情况下,数组名不会为视为指向起始元素的指针。
1.作为sizeof运算符的操作数出现时
sizeof(数组名)不会生成指向起始元素的指针的长度,而是生成数组整体的长度。
2.作为取地址运算符&的操作数出现时
&数组名不是指向起始元素的指针的指针,而是指向数组整体的指针。
在数组中,数组名arr和&arr[0]的地址是相同,既arr的值就是arr[0]的地址,既&arr[0]。
不管arr的元素有多少个,只要元素类型有Type型,arr的表达式类型就是Type*。
而在两个例外中可以发现,sizeof数组名是整个数组的长度,不再是指针。
而取地址数组名,是指向的不是数组首个元素,而是指向整个数组整体的指针。
&arr+1 可以发现B0到D8,正好是数组10个元素的字节长度40。
将数组名视为指针,也催生出了数组和指针的密切关系。
指针的初始值是&arr[0],写成arr也是一样的,指针p被初始化为指向数组arr的起始元素arr[0];
*p既然指数组首个元素的值,通过指针本身p++遍历数组,将自己的值赋值给数组,打印出了0~9。
指针运算符和下标运算符
#include<stdio.h>
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
int* p = arr;
int i = 0;
for (i = 0; i < 10; i++)
{
printf("a[%d]=%p p+%d=%p\n",i,&arr[i],i,p+i);
}
printf("\n");
return 0;
}
如果将指向数组内元素p+i前写上解引用操作符*会怎么样呢?
#include<stdio.h>
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
int* p = arr;
int i = 0;
for (i = 0; i < 10; i++)
{
printf("a[%d]=%d p+%d=%d\n",i,*(arr+i),i,*(p+i));
}
printf("\n");
return 0;
}
我们看见arr[i]==*(arr+i) p+i==*(p+i)
由此我们可以推断 arr[0]==*(arr+0) arr[1]==*(arr+1) ....
通过交换律我们发现*(p+i)==*(i+p) 这样一看是不是p[i]可以写成i[p]呢?
答案是可以的!
因为[]下标运算符,是一个具有两个操作数的双目运算操作符,下标运算符[]的操作数顺序是随意的
就像1+2==2+1一样,arr[1]和1[arr]也是等价的。
所以我们可以写成arr[i] i[arr] *(i+a) *(a+i) p[i] i[p] ....
但为了让别人看起来简洁高效,最好不要使用i[arr]等容易出现错误的写法。
指针运算
指针+-整数
#include<stdio.h>
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
int* p = arr;
int i = 0;
for (i = 0; i < 10; i++)
{
printf("a[%d]=%d ",i,*p++);
}
printf("\n");
return 0;
}
指针-指针
#include<stdio.h>
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
printf("%d\n", &arr[9] - &arr[0]);
return 0;
}
指针减去指针得到的数值是:指针和指针之间的元素。
指针-指针的前提是:指针和指针指向了同一块空间 。
指针之间可以相减但不能相加
二级指针
指针变量也是变量,是变量就要开辟内存空间,就会有所对应的地址。
#include<stdio.h>
int main()
{
int a = 20;
int* p = &a;
int** pp = &p;
*(*pp) = 100;
printf("%d\n", a);
return 0;
}
int* *pp=&p *pp表示是一个指针变量 再通过解引用保存p的地址
*(*pp) *pp就是访问的就是p 再通过解引用操作 访问到*p的整个空间区域 就是a
因此最后结果是100。
指针数组
指针数组是指针?还是数组?
是数组!是存放指针的数组。
整形数组和字符数组
整形数组:存放整形的数组
字符数组:存放字符的数组
指针数组
#include<stdio.h>
int main()
{
char arr1[] = "abc";
char arr2[] = "bcd";
char arr3[] = "adas";
char* parr[] = { arr1,arr2,arr3 };
int i = 0;
for (i = 0; i < 3; i++)
{
printf("%s\n", parr[i]);
}
return 0;
}
parr存储三个字符数组,再通过解引用保存各数组首元素值的地址,再用for循环打印出来,因为printf具有链接性,只要知道首个元素的地址就能将后面直至\0之间的内容都自动打印出来。
指针数组就是存放指针(地址)的数组。
其实通过上面的例子,我们可以变相的用指针数组模拟实现二维数组。
int* parr[3]是什么意思? parr[3]是一个数组,里面有3个元素,每个元素是一个整形指针。
#include<stdio.h>
int main()
{
int arr1[] = { 1,2,3 };
int arr2[] = { 4,5,6 };
int arr3[] = { 7,8,9 };
int* parr[3] = { arr1,arr2,arr3 };
int i = 0;
for (i = 0; i < 3; i++)
{
int j = 0;
for (j = 0; j < 3; j++)
{
printf("%d ", parr[i][j]);
}
printf("\n");
}
return 0;
}
数组指针
数组指针是数组?还是指针?
是指针!
int*p是指向整形数据的指针
float*p1是指向浮点型数据的指针
那么数组指针:就是指向数组的指针
以下两种,哪个才是数组指针?
int(*p1)[10]才是数组指针,因为下标操作符[]的优先级高于解引用*的符号的优先级,如果不加括号p就先会和[]先结合,变成了指针数组。为了避免这种情况,为了解引用先生效,要先加括号。
因此int(*p1)[10]才是一个指向数组的指针,指向的数组大小为10,p1是一个指针变量,指向一个数组。
数组指针既然指向的数组,那数组指针存放的应该是数组的地址。
但一般我们写代码时,很少这样使用数组指针。
一般是在二维数组传参时,才使用数组指针。
#include <stdio.h>
void print_arr1(int arr[3][5], int row, int col)
{
int i = 0;
for (i = 0; i < row; i++)
{
int j = 0;
for (j = 0; j < col; j++)
{
printf("%d ", arr[i][j]);
}
printf("\n");
}
}
void print_arr2(int(*arr)[5], int row, int col)
{
int i = 0;
for (i = 0; i < row; i++)
{
int j = 0;
for (j = 0; j < col; j++)
{
printf("%d ", arr[i][j]);
}
printf("\n");
}
}
int main()
{
int arr[3][5] = { 1,2,3,4,5,6,7,8,9,10 };
print_arr1(arr, 3, 5);
print_arr2(arr, 3, 5);
return 0;
}
二维数组其实本质就是一维数组。
二维数组的每一行可以理解为二维数组的一个元素,而二维数组的每一行又是一个一维数组。
二维数组名,也是就是首元素的地址,也就是第一行的地址-一维数组的地址arr。
arr[0][0]是首元素地址 也就是arr 第一行的地址。
数组传参和指针传参
一维数组传参
#include <stdio.h>
void test1(int arr[])test1传的数组首元素地址,而int arr[]本质上是指针 用来存放首元素地址 ok
{
}
void test1(int arr[10])同理
{
}
void test1(int* arr)以指针变量来存放首元素地址 ok
{
}
void test2(int* arr[20])指针数组用来接收实参arr2 指针数组中首元素地址 ok
{
}
void test2(int** arr) 以二级指针来存储指针数组的地址 ok
{
}
int main()
{
int arr[10] = { 0 };
int* arr2[20] = { 0 };
test1(arr);
test2(arr2);
}
二维数组传参
void test(int arr[3][5])数组int arr[3][5]本质上是数组指针 用来存储首元素地址 ok
{
}
void test(int arr[][])错误 二维数组可以省略行 列不能省略
{
}
void test(int arr[][5])同理 ok
{
}
void test(int *arr)错误 二维数组只能用数组指针接受
{
}
void test(int* arr[5])错误 这是一个指针数组
{
}
void test(int (*arr)[5])正确的 数组指针 用来存放数组的指针 可以通过(*arr)遍历来对应行的元素
{
}
void test(int **arr)错误的 二维数组只能用数组指针接受
{
}
int main()
{
int arr[3][5] = {0};
test(arr);
}
一级指针传参
#include <stdio.h>
void print(int* p, int sz)
{
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%d\n", *(p + i));
}
}
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9 };
int* p = arr;
int sz = sizeof(arr) / sizeof(arr[0]);
print(p, sz);
return 0;
}
p实参其实就是arr 用指针变量当形参接受(没有任何问题)。
函数参数为一级指针时,函数可以接受什么参数呢?
#include <stdio.h>
void test(char* p)
{
}
int main()
{
char arr[] = "abcd";
char ch = '2';
char* ptr = &ch;
test(arr);
test(&ch);
test(ptr);
return 0;
}
二级指针传参
#include <stdio.h>
void test(int** ptr)
{
printf("num = %d\n", **ptr);
}
int main()
{
int n = 10;
int*p = &n; //一级指针
int **pp = &p;//二级指针
test(pp);
test(&p);
return 0;
}
当函数的参数为二级指针时,函数可以接受什么参数呢?
#include <stdio.h>
void test(char** p)
{
}
int main()
{
char* arr[5];
char ch = 'a';
char* p = &ch;
char* pp = &p;
test(arr);
test(&p);
test(pp);
return 0;
}