指针
指针概述:内存类型资源的地址、门牌号的代名词
指针只是个概念,要用还得用指针变量:存放指针这个概念的盒子
C语言编译器对指针这个特殊的概念,有2个疑问?
1、分配一个盒子,盒子要多大?
在32bit系统中,指针就是4个字节,指针大小都固定了,就是4字节,跟你指向什么类型没有关系
2、盒子里存放的地址 所指向 内存的读取方法是什么(指向这段内存的空间大小)?
char *p; char是修饰*的,这样定义就告诉p一次只读一个字节
int *p; int就代表p一次只读4个字节,这样就完成了声明和定义
int *p1;
char *p2;
printf("the p1 is %lu,the p2 is %lu\n",sizeof(p1),sizeof(p2));
打印出的结果p1、p2都是4
printf("the p1 is %lu,the p2 is %lu\n",sizeof(*p1),sizeof(*p2));
结果是4、1,一次读4个字节、1个字节,也可以理解为内容是4个字节、1个字节(指向这段内存的空间大小)
int a = 0x12345678;
int *p1;
p1 = 0x1122; //这样的写法是可以的,1122这个数肯定可以放到32bit的盒子里,是可以赋值进去的
但是!赋值进去后,属性发生了改变,原来代表数字,赋值进去后代表了地址,
而1122对应的资源是谁呢,资源合不合法呢?
所以,指针指向内存空间,一定要保证合法性,保证这个空间确实存在且能读能写
p1 = &a; 这样才正确,&a是a的门牌号
printf("the p1 is %x\n",*p1); //the p1 is 12345678 *p是取内容
当:
int a = 0x12345678;
char *p1;
p1 = &a; //a的地址一定是门牌号的最小值
printf("the p1 is %x\n",*p1); //the p1 is 78 *p是取内容
小端模式:
数据的低位放在低地址空间,数据的高位放在高地址空间
简记:小端就是低位对应低地址,高位对应高地址
大端模式:
数据的高位放在低地址空间,数据的低位放在高地址空间
简记:大端就是高位对应低地址,低位对应高地址
p、*p、&p的区别
如定义:
int a = 10;
int *p;
p = &a;
则:
p:因为p = &a;所以就是a的地址
*p:p的内容,就是a的值
&p:p自己本身的地址
二级指针也同理:
图示如下:
指针+修饰符
const:常量、只读(不能变)
const char *p; //const修饰char,一个字节只读方式来读取内存,更倾向于第一种写法
char const *p;
char * const p; //const修饰p,p指向的是一个地方,不能再变了,更倾向于第一种写法
char *p const;
const char * const p; //指向的地址不能变,内容也不能变;希望产生ROM空间时用
const char *p; //p所指向的内存空间是只读的,p可以指向任意的只读空间,但不能对p里的内容进行操作
就可以理解为字符串,"hello world",内容是永远不变的,字符串的不可变性
看到:const char *,第一反应就是字符串
char * const p; //p指向的是一个固定地址,里面的内容是可以修改的
与硬件资源相关的,如LCD显卡缓存
段错误:指针指向的内容被非法访问了
#include <stdio.h>
int main ()
{
char *p = "hello world!\n"; //指针指向字符串时,规范写法:const char *p = "xxx"
//""相当于整型常量,不可变的
printf( "the one is %x\n",*p); //打印出68,即h的ASCII码
*p = 'a'; //非法访问,出现段错误
printf( "the %s\n",p);
}
char *p = "hello world!\n"; //这段内存不可变
char buf[] = {"hello world!\n"}; //buf是可变的,buf属于main函数的变量内存
char *p2 = buf;
*p2 = 'a'; //这样就没问题
printf( "the %s\n",p2); //the aello world!
volatile:防止优化指向内存地址,多跟硬件有关
volatile char *p;
*p == 0x10; //这样编译器就会不断地从指向的内容去读,而不会优化掉
typedef
char *name_t; name_t是一个指针,指向了一个char类型的内存
typedef char *name_t; name_t是一个指针类型的别名,指向了一个char类型的内存
name_t abc;
指针+运算符
++、--、+、-
int *p = xxx; [0x12]
p+1 [0x12 + 1*(sizeof(*p))]
指针的加法、减法运算,实际上加的是一个单位,单位的大小可以使用sizeof(p[0])
int *p p+1
char *p p+1 两者的结果是不同的
p+1 p-1
p+1时:p不变,以p位参考位置,向上或向下查看,只是看
p++ p--:不仅仅是看内容,把p的内容都更新了
[]
变量名 [ n ]
n:ID号,标签
地址内容的标签访问方式
如:p[2],p为基地址的第2块内容
p+n p+n得到的是地址
p[n] 访问的是内容,加了[]后自动会把内容取出来
两种写法都是一致的
变量分配
是从高往低分配的,栈区,从上往下
int main()
{
int a = 0x12345678; a在高地址
int b = 0x99991199; b在低地址
int *p1 = &b;
char *p2 = (char *)&b; //加上强制类型转换,可以不报指针类型与数据类型不符合的警告
printf("the p1+1 is %x,%x,%x\n",*(p1+1),p1[1],*p1+1);
printf("the p2+1 is %x\n",p2[1]);
}
char *p2 = (char *)&b;
相当于分两步写:p2=&b 两边再加上char *
类型没有变化,大小还是那个大小,只是大小的属性不一致了
p1+1只是得到了a的地址(门牌号),*(p1+1)才是取内容(gcc编译器是连续存放的),其他的不一定
*(p1+1)和p1[1]是一样的,都是内容
*p1+1 是把内容先取出来,再加1,会得到0x9999119a
p2[1]的结果是11
指针越界访问
int main()
{
const int a = 0x12345678; //a在高地址
int b = 0x11223344; //b在低地址
int *p1 = &b;
p[1] = 0x100;
printf("the a is %x\n",a); //就可以越界修改a的值
}
逻辑操作符
指针用的最多的还是==、!=
1、跟一个特殊值进行比较 0x0:地址的无效值,结束标志
if(p==0x0),往往我们会写一个宏:
if(p==NULL),从语言编译器一边会预定义好NULL的值,
2、指针必须是同类型的比较才具有意义
char * int * 是不同种类型
多级指针
int **p 指向指针的指针
首先找到这行的关键字:p开头,然后左边有一个*,就告诉我们p是*(p是一个箭头),那么p就一定是地址
往外继续看,发现*p左边还有*,说明p一次读4个字节
p里面存放的内存还是一片连续的空间,这片连续空间的限制大小是4个字节,只不过这4个字节非常特殊,还是指针,这个指针就是以int决定的来读取内存
p开头,然后左边有一个*,就告诉我们p是一个箭头,这个箭头里头存什么是由第2个*决定的
说明p里面存放的还是一个箭头,这个箭头该如何操作呢,就是由int决定的
如:char **p;
p[0] p[1] ... p[n]
当某一个p[m] == NULL时,意味着这段二维空间就结束了
多级指针就是一段连续空间,这样的连续空间保存着其他空间的地址,把不连续的空间变为连续
#include <stdio.h>
int main(int argc,char **argv) //main函数的标准写法就是这样
{
int i;
for(i=0;i<argc;i++){
printf("the argv[%d] is %s\n",i,argv[i]);
}
return 0;
}
gcc -o build 005.c
执行./build
结果为:
the argv[0] is ./build
执行./build hello 123 456
结果为:
the argv[0]is ./build
the argv[1]is hello
the argv[2]is 123
the argv[3]is 456
二级指针还有一个常用的模板:
#include <stdio.h>
int main(int argc,char **argv) //main函数的标准写法就是这样
{
int i = 0;
while(argv[i] != NULL){
printf("the argv[%d] is %s\n",i,argv[i]);
i++;
}
return 0;
}
执行./build hello 123 456
结果还是一样:
the argv[0]is ./build
the argv[1]is hello
the argv[2]is 123
the argv[3]is 456
数组
数据类型 数组名[m]
m的作用域是在申请的时候
int a[100]; 定义了100个int大小的元素
数组名是地址常量,指针是表示地址的变量
数组名一定不能放到=的左边 ==大忌:a === 也不可以写a++,因为a++等价于a=a+1
char buf[100];
buf = "hello world!"; 错误!!
数组名就是一个常量标签,就像函数名叫main,不管怎么运行都不变
数组的细节知识:
a是数组首元素的地址,就是指向首元素的指针,a等于&a[0];&a是数组首地址;a和&a值是一样的
a+1:就是数组首地址加上一个元素所占的地址大小,这里int是4个字节,所以加上1x4
&a+1:代表的是加上整个数组的大小,这里数组尺寸是3,所以+1代表的是地址加上3x4,指向数组末尾的位置
* (a+1):代表的是数组第一个元素的值,就是a[1]的值,不再是元素的地址
*(&a+1):将&a+1地址取出来
&a+i = a + i*sizeof(a);
a+i = a +i*sizeof(a[0]);
数组空间的初始化
初始化实际上就是空间的赋值问题,按照标签逐一处理:a[0] = xx,a[1] = yy,...,a[n] = zz
int a[10] = 空间;
int a[10] = {10,20,30}; {}就代表空间,是一个块
===>a[0] = 10; a[1] = 20; a[2] = 30; a[3] = 0; 后面不写的默认把0赋进去(具体看编译器,也可能是随机值)
数组空间的初始化和变量的初始化本质不同,尤其是在嵌入式的裸机开发中,空间的初始化往往需要库函数的辅助
char buf[10] = {'a','b','c','\0'};
buf当成普通内存来看,没有问题
buf当成一个字符串来看,这种赋值方式一定要在最后加上一个'\0',也就是0
字符串的重要性,结尾一定有个'\0',内存中就是0的表现形式
char buf[10] = {"abc"}; 是buf当成字符串空间来看最合理的写法,C语言编译器看到""会自动加\0 所以实际上这里是4个字节了
char buf[10] = "abc"; abc这个内存逐一地拷到buf中,系统会有两个abc,一个常量的abc,一个变量abc
buf[2] = 'e'; √没问题
char *p = "abc"; 用指针去指常量区域
p[2] = 'e'; ×肯定出现段错误,因为p指向常量,不能对常量进行修改
char buf[] = "abc"; 4个字节
char buf[10] = "abc";
假如我想要让: buf = "hello world" 怎么办,当然这种写法是大错特错!!
这就是第二次内存初始化,或者说第二次赋值,只能是逐一处理
buf[0] = 'h' buf[1] = 'e' ... buf[n] = 'd' buf[n+1] = 0;字符串的赋值一定要注意0的赋值
strcpy、strncpy
当把一块空间当成字符空间时,C语言提供了一套字符拷贝函数
字符拷贝函数的原则:一旦空间中出现了0这个特殊值,函数就即将结束了,不管0在哪里,看到就结束了
strcpy():
char buf[10] = "abc";
//假如我想要让: buf = "hello world"
strcpy(buf,"hello world"); 但是在工程中绝对不要用此函数,因为会导致非常严重的内存泄露问题!!!!万一字符串很长,就会一直拷贝,不止10个元素了,就会出问题
应该使用 strncpy()函数
strncpy(buf,"hello world",n); n限制了拷贝的数量
字符空间
ASCII码编码来解码的空间,就是给人看的
用%s来看的,比如人写abc时,在计算机内存中是用'a','b','c'来表示的,就是char类型,char类型的编码方式就是ASCII码
\0作为结束标志
非字符空间
当做数据采集时要存储数据 0x00 - 0xff 8bit
形成了一个不成文的规定:
char buf[10]; ---->string
unsigned char buf[10]; ---->data
非字符空间的拷贝三要素:1、源 2、目的地 3、个数
C语言提供了一个函数:memcpy(dest, src, n)
int buf[10];
int sensor_buf[100];
memcpy(buf,sensor_buf,10*sizeof(int)); //或者用sizeof(buf)最保险
unsigned char buf1[10];
unsigned char sensor_buf[100];
memcpy(buf1,sensor_buf,10*sizeof(unsigned char));
注意:不要用strncpy(),如果一开始就有0值,那么buf就一直为空!
指针数组
由指针构成的数组
char * a[100];
sizeof(a) = 100 * 4; //每个指针是4个字节
char **a;
看到char **a,就可以通过标签a加下标:a[0]、a[1]这样的操作去访问每一个元素,然后每一个元素里面的内容就可以访问的到
多维数组
数组名的保存
定义一个指针,指向int a[10]的首地址
int *p1 = a; 没有任何问题
定义一个指针,指向int b[5] [6]的首地址
int **p2 = b; 一次读4个字节而已,并不匹配
int (*p2)[6] = b; 这样才对!
二维数组读内存的方法是一行一行读。5行6列,一次要读6个int
int *p[5]; 指针数组,好多个指针指向不同的块
int (*p)[5]; 数组指针,一个指针,一次性可以读5个块,5个int的方法读内存
数组指针和指针数组的区别
指针数组是指针类型的数组,里面的元素是指针类型的数据
数组指针(行指针)是一个指针变量,似乎是C语言里专门用来指向二维数组的,它的p+1表示到下一行。
int b[2] [3] [4];
int (*p)[3] [4];
结构体
#include <stdio.h>
struct abc{
char a;
int b;
};
int main ()
{
struct abc buf;
printf ("the buf is %lu\n",sizeof(buf));
}
>>the buf is 8
为了效率,希望牺牲一点空间换取时间的效率
#include <stdio.h>
struct abc{
char a;
short e;
int b;
};
struct my{
char a;
int b;
short e;
};
int main ()
{
struct abc buf;
struct my buf1;
printf ("the buf is %lu:%lu\n",sizeof(buf),sizeof(buf1));
}
>>the buf is 8:12
short是两个字节,因此第一种定义方式:1 0 1 1;1 1 1 1 只需要2个字节
第二种定义方式:1 0 0 0;1 1 1 1;1 1 0 0 需要3个字节
内存分布图
编译--->汇编--->链接
#include <stdio.h>
int main()
{
int a;
a = 0x10;
printf("the a is %p\n",&a); 用%p看地址会合理一些,它会自动给加上0x
printf("the is %p\n", main);
return 0;
}
>>the a is 0xbfcle8cc 局部变量在高内存区域
>>the is 0x80483e4 函数在低内存区域
#include <stdio.h>
int a;
int main()
{
a = 0x10;
printf("the a is %p\n",&a); 用%p看地址会合理一些,它会自动给加上0x
printf("the is %p\n", main);
return 0;
}
>>the a is 0x804a01c
>>the is 0x80483e4 当a为全局变量时,此时两者都在低段地址上了
内存分布图:
只读空间
代码段、只读数据段、全局变量空间都是整个程序结束后才消失,生存周期最长
静态空间,C语言编译时已确定
#include <stdio.h>
int main()
{
int a;
unsigned char *p;
a = 0x10;
printf("the a is %p\n",&a); 用%p看地址会合理一些,它会自动给加上0x
printf("the is %p\n", main);
p = (unsigned char *)main;
printf("the p[0] is %x\n",p[0]);
p[0] = 0x12; //出现了段错误
printf("+++++++ the p[0] is %x\n",p[0]);
return 0;
}
>>the a is 0x804a024
>>the is 0x80483fa
>>the p[0] is 55 //读没有问题,而且是一个字节一个字节地读
>>Segmentation fault //出现了段错误
#include <stdio.h>
int main()
{
char *p1 = "helao world";
printf("the p1 is %s\n",p1);
printf("the string address is %p\n", "helao world");
p1[3] = 'l'; //出现了段错误,因此字符串不能修改
printf("the p1 is %s\n", p1);
return 0;
}
>>the p1 is helao world //可以看,没问题
>>the string address is 0x80485a0
>>Segmentation fault //出现了段错误
''是个数,给人描述逻辑或者字符时会用到
""是一片空间,是地址的属性,不是值的属性
栈空间
运行时,函数内部使用的变量,函数一旦返回,就释放,生存周期是函数内
size命令 – 显示文件各段大小 size 文件名
text:代码段
data:已初始化地数据段
bss:未初始化的数据段
dec = text + data + bss
hex:为dec的十六进制
strings命令:把双引号里的东西打印出来 strings 文件名
nm命令:查看可执行程序的标签 nm 文件名
static修饰的就只在函数内有效,局部有效,但是存放还是在全局数据段中
堆空间
运行时,可以自由,自我管理地分配和释放地空间,生存周期由我们来决定
分配和释放必须配对
分配:
malloc()一旦成功,返回分配好的地址给我们,只需要接收即可;对于这个新地址的读法,由我们灵活把握
输入参数指定分配的大小,单位就是B(字节)。
如要申请一个int a[5]; 就要malloc(5*sizeof(int));
char *p;
p = (char *)malloc(100);
if(p == NULL){ //一般情况下需要对p为空进行判断,进行处理或者忽略,防止申请失败
error...
}
malloc申请空间运行一次就申请一次,函数返回后,p没有了,但是p指向的空间还有
释放:
free(p); 释放malloc申请的地址,不释放就会导致内存泄露
p = NULL; 释放后应将指针设置为NULL,防止悬挂指针的出现
标签:p1,04,int,内存空间,C语言,char,地址,buf,指针 From: https://www.cnblogs.com/xishiyuyuan/p/18293734