在C语言中地址就是存在指针变量当中,指针就是存地址的变量
内存与地址
我们知道计算机上CPU在处理数据时,需要的数据是在内存中读取的,处理之后的数据也会放回内存中,内存中会划分为一个个的内存单元,每个内存单元的大小取1个字节。8个比特位(bite)
这样来看,就像我们想要找到宿舍楼中的朋友,就要找到朋友对应宿舍的门牌号。
首先我们要明白每个内存单元相当于一个学生宿舍,一个字节空间里面能放8个比特位,就相当于一个宿舍住8个人。每个内存单元也有一个编号有了这个内存单元的编号,CPU就可以快速地找到一个内存空间,这个编号就相当于每个宿舍的门牌号,方便我们快速找到朋友所在宿舍。在计算机中我们把内存单元的编号称为地址,C语言中叫:指针
内存单元的编号==地址==指针
取地址操作符(&)与解引用操作符(*)
取地址操作符(&)
我们知道C语言中,创建变量其实就是向内存申请空间,&(取地址操作符)这个操作符可以让们得到这个空间的地址,取出的地址是我们申请的空间中地址较小字节的地址(也就是第一个字节的地址)。
我们通过&得到一个地址的数值,这个地址有时候也是需要存储起来方便我蒙后期使用,而存放地址值的变量就是指针变量
int main()
{
int a = 0;
int * pa= &a;//取出a的地址并存储到指针变量pa中
return 0 ;
}
指针变量就是来存放地址的,存放在指针变量中的值会理解为指针。
pa左边写的是int*,*是在说明pa是指针变量,而前面的int是在说明pa指向的是整形类型的对象。
我们拿到指针,就可以通过指针去找到指针指向的对象。
取地址操作符&,可以取出一个变量或者常量的地址
解引用操作符*,用来取出指针中存放的值
int main()
{
int a = 0;
int * pa= &a;//取出a的地址并存储到指针变量pa中
*pa=10;//通过pa中存放的地址,找到指向的空间,就是变量a,将变量a改为10
return 0 ;
}
指针变量的大小取决于地址的大小
int main() //32位环境 64位环境
{ //X86 X64
printf("%zd\n", sizeof(char *)); //4 8
printf("%zd\n", sizeof(short *)); //4 8
printf("%zd\n", sizeof(int *)); //4 8
printf("%zd\n", sizeof(double*)); //4 8
printf("%zd\n", sizeof(float *)); //4 8
return 0;
}
所以指针变量的大小和类型是无关的,只要指针类型的变量在相同平台下,大小都是相同的
指针的解引用
指针类型决定了指针进行解引用操作符的时候访问几个字节,也就是说决定指针的权限。
int main()
{
int n = 0x11223344;
int* pi = &n;
*pi = 0;
printf("%0x", n);//输出结果:0
return 0;
}
int main()
{
int n = 0x11223344;
char* pi = &n;
*pi = 0;
printf("%0x", n);//输出结果:11223300
return 0;
}
所以我们看到char*的指针解引用就只能访问一个字节,int*的指针解引用可以访问4个字节。
void*(泛型指针)
char*指向字符的指针
int * 指向整型的指针
short*指向短整型的指针
float*指向单精度浮点数的指针
double*指向双精度浮点数的指针
void*是无具体类型的指针(泛型指针)
这种类型的指针可以用来接收任意类型地址,但是void*类型的指针不能直接进行指针的+ - 整数和解引用运算,因为void*未知大小
一般void*类型的指针是使用在函数参数部分,用来接收不同类型数据的地址,这样的设计可以实现泛型编程的效果,使得一个函数来处理多种类型的数据
const修饰指针
const修饰变量
变量是可以修改的,当这个变量加上const,就不能被修改了。
int main()
{
int m = 0;
m = 20;//此时m是可以被修改的
const int n = 0;
n = 20;//此时n是不可以被修改的,会报错
return 0;
}
n具有了常属性,虽然n不能被修改,但n依旧是变量。在c++中const修饰的变量就是常量
但是如果把变量的地址交给一个指针变量,通过指针变量也还是可以修改这个变量。
const修饰指针变量
void test1()
{
int n = 10;
int m = 20;
int* p = &n;
*p = 20;
p = &m;
}
void test2()
{
int n = 10;
int m = 20;
const int* p = &n;
*p = 20;
p = &m;
}
void test3()
{
int n = 10;
int m = 20;
int* const p = &n;
*p = 20;
p = &m;
}
void test4()
{
int n = 10;
int m = 20;
const int* const p = &n;
*p = 20;
p = &m;
}
int main()
{
test1();//无const
test2();//const放在*左边
test3();//const放在*右边
test4();//*左右两边都有const
return 0;
}
const修饰指针变量的时候,放在*的左边,const限制的是指针指向的内容,保证了指针指向的内容不能通过指针来改变。但是指针变量本身的内容改变,可以指向其他变量
const修饰指针变量的时候,放在*的右边,const限制的是指针变量本身。保证了指针变量不能在指向其他变量,但可以通过指针变量,修改指针变量指向的内容。
指针运算
指针 + - 整数
指针+指针
int main()
{
int a = 10;
int* pa = &a;
char* pc = &a;
printf("pa = %p\n", pa); //pa = 0113FC68
printf("pa+1 = %p\n", pa+1); //pa+1 = 0113FC6C
printf("pc = %p\n", pc); //pc = 0113FC68
printf("pc+1 = %p\n", pc+1); //pc+1 = 0113FC69
return 0;
}
指针的类型决定了指针进行+1,-1的时候,向前或者向后跳过多大一步
char* 类型的指针变量+1,跳过一个字节,int* 类型的指针变量+1,跳过四个字节。
type * p;
p+1——>会跳过 *sizeof(type)
p+n——>会跳过n*sizeof(type)
打印数组
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
int* p = &arr[0];
int sz = sizeof(arr) / sizeof(arr[0]);
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%d", *(p+i));//p+i就是指针+整数
}
return 0;
}
指针-指针
指针-指针计算的前提条件一定是:两个指针指向了同一块空间
指针1 + 整数 == 指针2
指针2 - 指针1 == 整数
(指针-指针)的绝对值==整数(两个指针之间元素个数)
int main()
{
int arr[10] = { 0 };
printf("%d", &arr[9] - &arr[0]);//9
return 0;
}
int main()
{
int arr[10] = { 0 };
printf("%d", &arr[0] - &arr[9]);//-9
return 0;
}
计算字符串长度
//my_strlen计算的是字符字符串中\0之前的字符个数
int my_strlen1(const char* str)
{
int count = 0;
while (*str != '\0')
{
count++;
str++;
}
return count;
}
方法二
int my_strlen2(const char* str)
{
char* start = str;
while (*str != '\0')
{
str++;
}
return str - start;
}
int main()
{
char arr[] = "abcdefg";
int len = my_strlen1(arr);//数组名就是数组首元素的地址
printf("%d", len);
int len = my_strlen2(arr);//数组名就是数组首元素的地址
printf("%d", len);
return 0;
}
指针的关系运算
指针与指针比较大小,地址与地址比较大小。
int main()
{
int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
int sz = sizeof(arr) / sizeof(arr[0]);
int* p = &arr;
while (p < arr + sz)//指针的大小比较
{
printf("%d", *p);
p++;
}
return 0;
}
野指针
野指针:指针指向的位置是不可知的(随机的、不正确的、没有明确限制的)
野指针成因
指针未初始化
int main()
{
int* p;//局部变量指针未初始化
*p = 20;
return 0;
}
//一个局部变量不初始化,默认值为随机值
指针越界访问
int main()
{
int arr[10] = { 0 };
int* p = &arr[0];
int i = 0;
for (i = 0; i <= 11; i++)
{
*(p++) = i;
}
return 0;
}
当指针指向的范围超出数组arr的范围时,p就是野指针
指针指向的空间已释放
int* test()
{
int n = 100;
return &n;
}
//当函数结束时,其占用的空间就会被释放
int main()
{
int* p = test();
printf("%d\n", *p);
return 0;
}
规避野指针
使用空指针(NULL)初始化指针变量,如果不知道指针应该指向哪里,就可以给指针赋值NULL,在指针释放后将其设置为NULL。NULL的值是0,0也是地址,这个地址是无法使用的,读写该地址会报错。只要是NULL指针就不去访问,同时使用指针之前可以判断指针是否为NULL
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
int* p = &arr[0];
for (int i = 0; i < 10; i++)
{
*(p++) = i;
}//此时p已经越界,可以把p置为NULL
p = NULL;
//下次使用的时候,判断p不为NULL的时候再使用
p = &arr[0];
if (p != NULL)
{
}
return 0;
}
确保指针始终指向有效的内存地址,检查指针的有效性后再进行访问
assert断言
assert.h头文件定义了宏assert(),用于在运行时确保程序符合指定条件,如果不符合,就报错终止运行,这个宏被称为“断言”。
assert(p != NULL);
assert()接受一个表达式作为参数,如果表达式为真,就不会产生任何作用,程序继续运行。如果表达式为假,程序就会报错
- 出错时,直接会报错并且指明在什么文件哪一行
- assert宏可以通过编译选项进行启用或禁用。不使用assert()时,在#include<assert.h>前面定义一个宏 "#define NDEBUG"
assert宏在linux里,realse版本也会起作用。
传值调用与传址调用
写一个函数,交换两个整数类型的变量
传值调用
void Swap(int x,int y)
{
int tmp = x;
x = y;
y = tmp;
}
int main()
{
int a = 20;
int b = 10;
printf("交换前:a= %d b=%d\n",a,b);//交换前:a= 20 b=10
Swap(a, b);
printf("交换后:a= %d b=%d\n",a,b);//交换后:a= 20 b=10
return 0;
}
为什么这个函数不能完成我们所达到的效果,因为x的地址和a的地址不一样 ,y的地址和b的地址不一样 。x与y是独立的空间,当我们在交换x和y时,a与b的值不会改变。当Swap函数调用结束后回到main函数,a与b的值没有交换。swap函数在使用的时候,是把变量本身直接传给了函数这种就叫传值调用。
实参传递给形参的时候,形参会单独创建一份临时的空间来接收参数,对形参的修改不影响实参
传址调用
要具体解决这个问题就要在main函数中将a和b的地址传给函数,Swap函数里面通过地址间接的操作main函数中a和b的值,这就是传址调用。它可以让函数与主调函数之间建立真正的联系,在函数内部可以修改主调函数中的变量
void Swap(int* px, int* py)
{
int tmp = 0;
tmp = *px;
*px = *py;
*py = tmp;
}
int main()
{
int a = 20;
int b = 10;
printf("交换前:a= %d b=%d\n", a, b);//交换前:a= 20 b=10
Swap(&a, &b);
printf("交换后:a= %d b=%d\n", a, b);//交换后:a= 10 b=20
return 0;
}