C/C++：指针
指针概念
指针变量也是一个变量
指针存放的内容是一个地址，该地址指向一块内存空间
指针是一种数据类型
指针变量定义
内存最小单位：BYTE字节（比特）
对于内存，每个BYTE都有一个唯一不同的编号，这个编号就是内存的地址
一个地址编号对应的是一个BYTE的空间大小
一个地址编号在32位系统下，是一个4个字节的无符号整数；在64位系统下是一个8个字节的无符号整数
//描 述：指针的定义
#include <stdio.h>
int main()
{
int *p;//定义int型指针变量，名字为p，int型（可以执行int型地址）
int a; //定义int型变量a
a = 1;
p = &a;//把a的内存地址赋值给p
printf("%p\n",p);
//00B7FB24 实际上a占了4个字节（地址编号），但是只输出第一个地址编号
//64位系统下a占8个字节，这也是为什么32位系统下内存用的少，64位内存用的多
return 0;
}
int *p;
//p:指针变量，存放地址
//*p:指针所指内存的实际数据
*p = 10//p指向的地址存放的值是10
//指针变量只能存放地址，不能将一个int型变量直接赋值给一个指针
取地址符号&（found/address）
&可以获取一个变量在内存中的地址
register int a;//register限定符，a变成寄存器变量，存放在cpu里而不是内存中，所以是没有地址的，不能用&进行取地址操作
void指针
void代表无类型，可以指向任何类型的地址
//描 述：void指针
#include <stdio.h>
int main01()
{
int *p;
int a;
a = 1;
p = &a;//把a的内存地址赋值给p
*p = 10; //通过指针变量间接访问a的值，把a的值改为10
printf("a = %d\n",a);
printf("*p = %d\n",*p);
a = 100; //修改a的值时*p的值也会变化
printf("a = %d\n",a);
printf("*p = %d\n",*p);
int b = 2;
p = &b; //现在指针变量p指向了b（指来指去）
*p = 50;
printf("b = %d\n",b);
printf("*p = %d\n",*p);
a = 123456;
//char *p1 = &a;//p1为char型指针变量，a为int型变量
//char *p1 = (char*)&a;//强制转换会导致错误的结果
void *p2 = &a;//void代表无类型，可以指向任何类型的地址
return 0;
}
指针占用内存
在同一个系统下，不管指向什么类型的变量，地址编号的大小总是一样的（32位系统占4个BYTE，64位系统占8个BYTE），但是不同类型变量占用的内存是不同的，见下方的代码
就像在一个酒店里，不管是单人间，双人间还是标准间，门牌号的大小都是一样的（4位数/8位数）
//描 述：指针占用内存说明
#include <stdio.h>
int main02()
{
char *p;
int *p1;
long long *p2;
printf("%lu,%lu,%lu", sizeof(p),sizeof(p1),sizeof(p2));//结果：4，4，4
return 0;
}
上述的代码与下面的代码进行比较
//描 述：不同类型变量占用的内存大小
#include<stdio.h>
int main05()
{
int a[10];
printf("%p,%p,%p\n",a,&a[0],&a[1]);
//输出结果：0135FCA0,0135FCA0,0135FCA4
//a与&a[0]是一样的，&a[0]与&a[1]中间有0135FCA0、1、2、3，因为一个int型变量占4个内存（4个地址编号）
char b[10];
printf("%p,%p,%p\n",b,&b[0],&b[1]);
//输出结果：0076FB24,0076FB24,0076FB25
//一个char类型变量占一个内存（地址编号）
long long c[10];
printf("%p,%p,%p\n",c,&c[0],&c[1]);
//输出结果：008FFC84,008FFC84,008FFC8C
return 0;
}
空指针与野指针
空指针：如果一个指针变量没有明确得指向一块内存，那么就把这个指针变量指向NULL，空指针是合法的
野指针：没有初始化过值的指针（没有指定内存），野指针是非法的
程序中避免野指针，可以使用空指针
//描 述：空指针与野指针
#include<stdio.h>
int main03()
{
/*野指针
int *p;
*p = 100;//没有指定内存
*/
//空指针
int *p1;
p1 = NULL;
return 0;
}
指针的兼容性
指针类型之间一定要匹配，指针之间的赋值比普通数据类型之间的赋值要更严格
int a;
double b = 3.45;
a = b;//正确，a = 3
int *p = &b;//错误，类型不一致
大白话：不要把指针想的太神秘，指针变量只是个变量而已，它里面放的就是一些地址编号，这些地址编号就是无符号的整数，在32位系统下是4个字节，在64位系统下是8个字节，但是这些整数不能直接赋值，来源于另外一个变量的取地址操作
指向常量的指针与指针常量
指向常量的指针
int a = 1;
const int *p = &a;//p可以指向一个int类型的地址，但不可以用*p的方式修改这个内存的值
*p = 10;//会报错：不能给常量赋值
printf("a = %d\n",a);
对于常量来说，值不能改变
const int b = 0;
b = 10;//报错，b为常量，值不能改变
但是可以创建一个指针指向它，修改
const int b = 0;
int *p = &b;
*p = 0;//不会报错，但是会warning，实际上这是不合理的，c语言的漏洞
c语言中的const是有问题的，可以通过指针变量间接修改const常量的值（c++中是无法修改的），所以在c语言中用#define常量的时候更多
指针常量
int *const p2 = &a;//p2只能指向a的地址
p2 = &b;//错误，p2是一个常量指针，只能指向固定的一个变量a的地址
//但是可以通过*p2来读写这个变量的值
*p2 = 10;
注意区分常量指针与指针常量
指针与数组的关系
p=a;数组的名字就代表数组第一个元素的地址,等同于 p = &a[0]
p1 = &a[5];//把a5的地址给指针p1
*p1 = 1000;//改变a[5]的值
p1[2] = 666;//p1指向a[5],则p1[2]顺延指向a[7],改变的是a[7]的值，把数组想象成一个队列
p[3] = 100;//当指针变量指向一个数组的时候，c语言语法规定指针变量名可以当数组名用，区别在哪里？
//区别:
printf("%lu,%lu\n", sizeof(a),sizeof(p));//对数组来讲返回数组的大小40，对指针来讲返回指针的大小4
//描 述：指针与数组的关系
#include<stdio.h>
int main()
{
int a[10] = {1,2,3,4,5,6,7,8,9,10};
int *p;
p = a;//可以这样指向，数组的名字就代表数组第一个元素的地址,等同于 p = &a[0]
int *p1;
p1 = &a[5];//把a5的地址给指针p1
*p1 = 1000;
p1[2] = 666;//p1指向a[5],则p1[2]顺延指向a[7],改变的是a[7]的值，把数组想象成一个队列
p[3] = 100;//当指针变量指向一个数组的时候，c语言语法规定指针变量名可以当数组名用，区别在哪里？
//区别:
printf("%lu,%lu\n", sizeof(a),sizeof(p));//对数组来讲返回数组的大小40，对指针来讲返回指针的大小4
int i;
for(i=0;i<10;i++)
{
printf("a[%d]=%d\n",i,a[i]);
printf("a[%d]=%d\n",i,p[i]);//像数组一样使用指针
}
return 0;
}
/*
运算结果:
40,4
a[0]=1
a[0]=1
a[1]=2
a[1]=2
a[2]=3
a[2]=3
a[3]=100
a[3]=100
a[4]=5
a[4]=5
a[5]=1000
a[5]=1000
a[6]=7
a[6]=7
a[7]=666
a[7]=666
a[8]=9
a[8]=9
a[9]=10
a[9]=10
*/
指针运算
指针变量可以计算，int* 类型加一，变化4个整数（增加4个字节），char* 类型加一，变化1个整数
//描 述：指针运算-加一
#include<stdio.h>
int main07()
{
int a = 0;
int *p = &a;
printf("%p,%p,%p\n",p,p+1,p+2);//结果：0118FCA4,0118FCA8,0118FCAC（加1操作加4个字节）
char c = 0;
char *p1 = &c;
printf("%p,%p,%p\n",p1,p1+1,p1+2);//结果：0075F937,0075F938,0075F939
return 0;
}
//描 述：指针运算2
#include<stdio.h>
int main()
{
int a[10] = { 0 };
int *p1 = a;
p1 += 5;
*p1 = 1;
p1 -= 2;
*p1 = 3;
//p1 *= 2;//混淆
int i;
for(i=0;i<10;i++)
{
printf("a[%d]=%d; ",i,a[i]);//结果：a[0]=0; a[1]=0; a[2]=0; a[3]=3; a[4]=0; a[5]=1; a[6]=0; a[7]=0; a[8]=0; a[9]=0;
}
return 0;
}
增加/减少指针值：p++；p–
求差值：pa-pb,通常用于同一个数组内求两个元素之间的距离
比较：pa == pb,通常用来比较两个指针是否指向同一个位置
通过指针使用数组元素
//描 述：指针与数组
#include<stdio.h>
int main00()
{
int a[10] = {1,2,3,4,5,6,7,8,9};
int *p = a;
p[3] = 100;//等同于下面一句，一般习惯这样写，简洁
//*[p+3] = 100;
int i;
for(i=0;i<10;i++)
{
printf("a[%d] = %d\n",i,a[i]);
}
return 0;
}
int main()
{
//c语言中所有数据类型都可以理解为一个char的数组
int a = 0x12345678;//0x开头，16进制,int是4个字节，可以视作4个char（12,34,56,78）的数组
char *p = (char *)&a;//为了防止出现warning，使用强制转换
printf("%x，%x\n", *p,p[1]);//结果：78,56，倒着放，小端对齐的概念
*p = 0;//相当于p[0],a[0]
printf("%x，%x\n", *p,p[1]);
p[2] = 0;
printf("%x\n",a);//结果：12005678
printf("--------------------\n");
char b[20] = {0};
int *p1 = (int *)&b;//防止warning强转
p1[3] = 0x12345678;//int占4个字符，3*4=12，从第13个位置也就是b[12]开始放（倒着放，小端对齐概念）
int i;
for(i=0;i<20;i++)
{
printf("b[%d] = %x\n",i,b[i]);
}
/*输出
--------------------
b[0] = 0
b[1] = 0
b[2] = 0
b[3] = 0
b[4] = 0
b[5] = 0
b[6] = 0
b[7] = 0
b[8] = 0
b[9] = 0
b[10] = 0
b[11] = 0
b[12] = 78
b[13] = 56
b[14] = 34
b[15] = 12
b[16] = 0
b[17] = 0
b[18] = 0
b[19] = 0
*/
return 0;
}
c语言中所有数据类型都可以理解为一个char的数组
练习：把ip地址转化为整数
输入ip地址
char a[100]=“192.168.2.5”
把这个ip转化为unsigned int类型的整数
//描 述：把ip地址转化为整数
#include<stdio.h>
int main003()
{
char a[] = "192.168.2.5";
unsigned int ip = 0;
unsigned char *p = (unsigned char *)&ip;
int a1,a2,a3,a4;
sscanf(a,"%d.%d.%d.%d",&a1,&a2,&a3,&a4);
printf("%d,%d,%d,%d\n",a1,a2,a3,a4);
p[0] = a4;
p[1] = a3;
p[2] = a2;
p[3] = a1;
printf("%u\n",ip);
//运行结果：192,168,2,5 3232236037
return 0;
}
练习：利用指针进行多维数组排序
//描 述：指针的灵活性——利用指针对多维数组进行排序
#include<stdio.h>
int main()
{
char a[2][5] = {{3,4,1,2,9},{3,44,98,0,5}};//把二维数组"拉直"当成一维数组
char *p =(char *)a;
int i,j;
for(i=0;i<10;i++)
{
for(j=0;j<10-i;j++)
{
if(p[j]<p[j-1])
{
char tmp = p[j];
p[j] = p[j-1];
p[j-1] = tmp;
}
}
}
for(i=0;i<2;i++)
{
for(j=0;j<5;j++)
{
printf("%d\n",a[i][j]);
}
}
return 0;
}
指针数组
指针数组的定义：
char *a[10];//定义指针数组a，每个成员是char*类型的，一共10个成员
int *b[10];//定义指针数组b，每个成员是int*类型的，一共10个成员
printf("%lu,%lu\n",sizeof(a),sizeof(b));//结果：40,40
给数组成员赋值：
char i = 0;
//a = &i;//a和b为数组名，数组名不能作为左值
//b = &i;
a[0] = &i;//合法
printf("%lu,%lu\n",sizeof(a[0]),sizeof(*a[0]));//输出结果4,1
//描 述：指针数组
#include<stdio.h>
int main0000()
{
char *a[10];//定义指针数组a，每个成员是char*类型的，一共10个成员
int *b[10];//定义指针数组b，每个成员是int*类型的，一共10个成员
printf("%lu,%lu\n",sizeof(a),sizeof(b));//结果：40,40
char i = 0;
//a = &i;//a和b为数组名，数组名不能作为左值
//b = &i;
a[0] = &i;//合法
printf("%lu,%lu\n",sizeof(a[0]),sizeof(*a[0]));//输出结果4,1
return 0;
}
int main0001()
{
int *b[10] = { NULL };
int a,b1,c;
b[0] = &a;
b[1] = &b1;
b[2] = &c;
*b[0] = 10;
printf("%d\n",a);
return 0;
}
二级指针——指向指针的指针
int a = 0; 地址是0x123456
int *p = &a; p为0x123456，*p为0，指针p的存放地址是0x100
int **pp = &p; pp为0x100（p的地址）, *pp为0x123456，**pp为0
//描 述：二级指针
#include<stdio.h>
//二级指针
int main0002()
{
int a = 0;
int *p = &a;
int **pp;//二级指针，二级指针pp存放指针p的地址，
pp = &p;
//int **pp = &p;//前两句的结合体
return 0;
}
//二级指针与数组
int main0003()
{
int a[10];
int *p = a;//p是指向数组a的指针
p[0] = 0;
p[1] = 2;
int *b[10];//定义指针数组b
int **p1 = b;//定义指向指针数组b的二级指针p1（不能用一级指针指向b）
p1[0] = NULL;
printf("%lu\n",sizeof(p1[0]));//运行结果：4
return 0;
}
对于一个指针变量b，想指向它需要定义一个二级指针a
多级指针
能用低级指针的尽量不要用高级指针，一级指针二级指针最常用，三级指针很少
//描 述：二级指针
#include<stdio.h>
//二级指针
int main0002()
{
int a = 0;
int *p = &a;
int **pp;//二级指针，二级指针pp存放指针p的地址，
pp = &p;
//int **pp = &p;//前两句的结合体
return 0;
}
//二级指针与数组
int main0003()
{
int a[10];
int *p = a;//p是指向数组a的指针
p[0] = 0;
p[1] = 2;
int *b[10];//定义指针数组b
int **p1 = b;//定义指向指针数组b的二级指针p1（不能用一级指针指向b）
p1[0] = NULL;
printf("%lu\n",sizeof(p1[0]));//运行结果：4
return 0;
}
int a = 0;
int *p = &a;
int **pp = &p;//pp代表p的地址，*pp代表a的地址，**pp代表a的值
int ***ppp = &pp;//ppp代表pp的地址，*ppp代表p的地址，**ppp代表a的地址，***ppp代表a的值
函数的参数作为指针变量
c语言想通过函数内部修改实参的值，只能给函数实参传递实参的地址来间接修改实参的值
//描 述：函数的参数作为指针变量
#include<stdio.h>
void swap(int *a,int *b)
{
int tmp = *a;
*a = *b;
*b = tmp;
}
int main0006()
{
int a = 1;
int b = 2;
swap(&a,&b);//c语言想通过函数内部修改实参的值，只能给函数实参传递实参的地址来间接修改实参的值
printf("a=%d,b=%d\n",a,b);
return 0;
}
思考代码为什么输出为4和40？
//描 述：当数组名作为函数形参时，c语言将数组名解析为指针
#include<stdio.h>
//void test(int a[10])
void test(int *a)//最常用最简单
//void test(int a[])
{
printf("%lu\n",sizeof(a));//输出结果：4
a[5] = 100;
}
int main()
{
int a[10] = {1,2,3,4,5,6,7,8,9,10};
printf("%lu\n",sizeof(a));//输出结果：40
printf("----------------\n");
test(a);
int i;
for(i=0;i<10;i++)
{
printf("a[%d]=%d\n",i,a[i]);
/*结果：
a[0]=1
a[1]=2
a[2]=3
a[3]=4
a[4]=5
a[5]=100
a[6]=7
a[7]=8
a[8]=9
a[9]=10
*/
}
return 0;
}
以下三条语句是一样的：
void test(int a[10])//当数组名作为函数形参时，c语言将数组名解析为指针
void test(int *a)//最常用最简单
void test(int a[])
函数指针参数使用const保护：
void test(const int *a)//为了不让函数内部修改数组成员的值
在c语言中，可以转个弯（强转）在函数内部修改成员的值（限制菜鸟），但是在c++中是改不了的
函数的返回类型可以是指针类型
int *test()
{
return NULL;
}
memset与memcpy与memmove
memset：将指定区域的内存置空（参数1：指定要置空内存的首地址；参数2:0；参数3：这块内存的大小，单位，字节）
memset(a,0,sizeof(a));
//描 述：memset：将指定区域的内存置空（参数1：指定要置空内存的首地址；参数2:0；参数3：这块内存的大小，单位，字节）
#include<stdio.h>
#include<string.h>
int main0008()
{
int a[10] = {1,2,3,4,5,6,7,8,9,10};
//a[10] = { 0 };//错误赋值方法，这种初始化的方法只能在创建a数组时才能用
//如果要把数组a置空，需要遍历修改
/*
int i;
for（i= 0;i<10;i++)
{
a[i] = 0;
}
*/
//采用memset可以简化上述的代码,需要加string.h的头文件
memset(a, 0, sizeof(a));
//memset(a, 0 ,10);//错误，只会把前10个字节清空
/*int *p = a;
memset(a, 0 ,sizeof(p));错误，指针变量的大小是8或4，所以只会清空前两个或者前一个字节*/
int i;
for (i=0;i<10;i++)
{
printf("a[%d] = %d",i,a[i]);
}
return 0;
}
memcpy:在两块内存之间拷贝数据（参数1：目标地址；参数2：原地址；参数3：拷贝多少内容，字节）
memcpy(a,b,sizeof(b));
//描 述：memcpy在两块内存之间拷贝数据（参数1：目标地址；参数2：原地址；参数3：拷贝多少内容，字节）
#include<stdio.h>
#include<string.h>
int main0009()
{
short a[10] = {1,2,3,4,5,6,7,8,9,10};//short一个整数占2个字节
int b[10] = { 0 };//int型一个整数占4个字节
memcpy(b, a, sizeof(a));
int i;
for(i = 0;i<10;i++)
{
printf("%08x\n",b[i]);//%x以十六进制数格式输出整数,08补齐前面的0，为了看起来更容易理解一些
}
/*输出结果：由于a和b类型不一致，所以拷贝的时候会出现下列情况
00020001
00040003
00060005
00080007
000a0009
00000000
00000000
00000000
00000000
00000000
*/
return 0;
}
memmove：移动内存(参数与memcpy一致）
memmove(a,b,sizeof(b));
注意：使用memcpy的时候一定要确保内存没有重叠区域
memcpy(&a[3],&a[0],20);//出现内存重叠区域
指针小结
int i; 定义整型变量
int *p; 定义指向int型变量的指针变量
int a[10]; 定义int数组
int *a[10]; 定义指针数组，数组中的每个元素指向一个int型变量的地址
int func(); 定义函数，返回值类型为int
int *func();定义函数，返回值类型为int *型
int **p; 定义指向int型指针的指针，二级指针
字符指针与字符串
练习：利用指针对字符串进行倒置
//描 述：利用指针对字符串进行倒置
//思 路：设两个指针，p和p1，p从头开始，p1从后开始，第一个字符与最后一个字符交换，第二个与倒数第二个，直到p>p1;
#include<stdio.h>
#include<string.h>
int main0011()
{
char a[100] = "hello world";
char *p = a;
int len = strlen(a);
char *p1 = p;//等同于*p1 = a;
p1 += len -1;
while(p<p1)
{
char tmp = *p;//值交换
*p = *p1;
*p1 = tmp;
p1--;//地址加1减1
p++;
}
printf("%s\n",a);//%s字符串
return 0;
}
c语言中，大部分的字符操作就是指针操作。
char s[] = "hello,world"
char *p = s;
p[0] = 'a';
数组作为函数的参数
如果一个数组作为函数的参数，那么数组的成员数量在函数内部是不可见的，一般在传递一个数组的时候，同时提供另一个参数，表明这个数组有几个成员
但是如果传递的是一个字符串，那么并不需要传递一个参数说明字符串的长度（因为字符串总是以0结尾，可以在内部判断0从而判断字符串的长度）
数组作为函数的参数
//描 述：数组作为函数的参数
#include<stdio.h>
//void test(char a[10])等价
//void test(char a[])
void print_array(int n,int *a)//提供另一个参数n表明数组的成员数量
{
int i;
for(i = 0;i<n;i++)
{
printf("%d\n",a[i]);
}
}
int main()
{
int a[] = {1,2,3,4,5,6,7,8,9};
print_array(sizeof(a)/sizeof(a[0]),a);//n=sizeof(a)/sizeof(a[0])
return 0;
}
指针数组作为main函数的形参
int main(int argc, char *argv[]);
main函数是系统调用的，main函数的参数功能是得到命令行的参数
argc:argv数组的成员数量
argv：数组的每个成员都是char类型
argc：命令行参数的数量
argv：命令行参数的字符串数组
指针数组作为main函数的形参
//描 述：指针数组作为main函数的形参
#include<stdio.h>
//int main(int argv, char *args[])
int main(int argv, char **args)//args是一个指针数组char*，argc代表数组的成员数量
{
int i;
for(i=0;i<argv;i++)
{
printf("%s\n",args[i]);
}
return 0 ;
}
练习：通过main函数实现四则加法运算，例如，命令行输入a 5 + 6 输出5+6的结果11
//描 述：利用main实现四则加法运算,例如，命令行输入a 5 + 6 输出5+6的结果11
#include<stdio.h>
#include<stdlib.h>//atoi的头文件
int main(int argc, char **args)
{
if (argc<4)//如果参数不足直接提示并退出
{
printf("参数不足\n");
return 0;
}
//注意：main函数的参数都是字符串，没有char，中间的+是“+”而不是‘+’
int a = atoi(args[1]);//把第一个参数5转化为int型
int b = atoi(args[3]);//把第三个参数6转化为int型
char *s = args[2];//+是字符串，因此不能写成下面一句
//char c = args[2];
char c = s[0];//+是“+”的第一个字符，可得到第二个参数+字符
//以上两句建议合并为下面一句
//char c = args[2][0];
switch (c)
{
case '+':
printf("%d\n",a+b);
case '-':
printf("%d\n",a-b);
case '*':
printf("%d\n",a*b);
case '/':
printf("%d\n",a/b);
default:
printf("error\n");
}
return 0;
}
//注意：*代表的是通配符，运算时结果是error，要想使用*运算符，加转移符号\
//如：a 1 \* 5
总结
最近刚考完嵌入式操作系统，顺路将指针用法整理了一下，如有错误，请大家在评论区或私信我就可以，谢谢！
