参考:麦子学院-嵌入式C语言高级-内存空间
2-3 : C语言内存空间的使用-数组
内存分配的一种形式
数组的定义及初始化
定义一个空间:
1、大小
2、读取方式
数组名[]:升级为连续空间的名称, [m]的作用域只在申请的时候起作用
每个多大?数组名前定义数据类型,按int 还是char进行切割?
数组名是地址常量符号,地址常量标签;一定不要放在等号左边
char buff[100];
buf = “hello world!” //该语法错误,不能赋值给常量。
int a[100]; //空间申请的一种方式
数据会有越界问题
a[10] a是门牌号,是常量,a的属性已定。而指针是内存,可变。
数组空间的初始化
空间的赋值
按照标签逐一处理
int a[10]: [0-9]
a[0]= xx;
a[1]= yy;
程序员这样赋值,工作缗比较大,能不能让编译器进行一些自动处理,帮助程序员写如上的程序
空间的第一次赋值
->空间定义时,就告知编译器的初始化情况,空间的第一次赋值,初始化操作
int a[10] = 空间; //调用标准库或者逐一拷贝,和普通变量初始化有本质不同
c语言本身,CPu内部本身一般不支持大空间和大空间的拷贝
int a[10] = {10,20,30} //3个B,3个字节。
=====>拷贝的过程,CPU做了,a[0] = 10; a[1] = 20; a[2] = 0
和逐一赋值是一样的,{}代表空间的限制块
数组空间的初始化和变量的初始化李质不同,尤其在嵌入式的裸机开爱书,空间的初始化往往需要库函数的铺助。
char
char buf[10] = {‘a’,‘b’,‘c’} //a是8b,占1个B,共占3个字节
buf当成普通内存来看,没有问题
buf当成一个字符串来看,最后加上一个’\0’或者0
字符串的重要属性是,结尾一定有一个’\0’(内存中0的表示形式)
char buf[10] = {“abc”}; //编译器看到"“自动加0
char buf[10] = “abc”; //执行后,系统中有2个abc,一个是"abc”(常量),一个是buf的变量-字符串"abc",=号完成常量向变量去拷贝。buf可变,可操作。不能改变abc
本质区别于:char p = “abc”; //指向"abc"的指针,buf可变,但p不变
buf[2] = ‘e’ //可行, p[2] = ‘e’ //不行,出现段错误,因为p指向常量,不能修改
示例:
#include <stdio.h>
int main()
{
printf("the x is %x\n","abc"); //显示的是内存地址
return 0;
}
// E:\temp>cd "e:\temp\" && gcc 2.c -o 2 && "e:\temp\"2
// the x is 409020
char buf[]=“abc”; //4个字节,因为还有0
char buf[10] = “abc”;
buf = “hello world!” //buf是常量标签,不能修改,故编译错误,标签不能变
第二次内存初始化,赋值?
逐一处理 buf[0] = ‘h’ ,…buf[n+1] = 0;
strcpy(工程禁用), strncpy(推荐)
一块空间,当成字符空间,提供了一套字符拷贝函数
字符拷贝函数的原则:
内存空间和内存空间的逐―赋值的功能的一个封装体,一旦空间中出现了0这个特殊体,则函数拷贝结束。
strcpy()
标准函数代码中会嵌入一些汇编语言,开发过程中效率进一步提高。
嵌入式开发工程师:根据CPU的体系结构不同以及CPU的能力,这段程序是可以改变的,能够更加优化。
char buf[10] = “abc”;
strcpy(buf,“hello world”); //完成复制,并自动加入"\0"结束标志
当"hello world*********"等待复制的字符串会一直copy,典型的内存泄漏,工程不能使用,只能用strncpy,控制复制长度,限制拷贝数量。
非字符串空间
字符空间
ASCII码编码来解码的空间,–》给人看
%s abc ‘a’ ‘b’ ‘c’
'\0’作为结束标志
非字符空间
数据采集 采集0x00-0xff 8bit
开辟一个存储这些数据的盒子,
定义时用
char buf[10]; ----》string
有歧义,怎么能保证完全是数据?
采集过来的只有位的概念,和符号无关,
必须定义为unsigned char buf[10]; ----》一定是最小data单位
unsigned char *p = sensor_ base;
strcpy(buf,p);//此方法这里不适用,看到\0才停止,存在非常不合理的风险,
所有,非字符串空间只管逐一拷贝,结束在哪里?只能是定义个数。
拷贝三要素:
1、src
2、dest
3、个数(sizeof)
memcpy
int buf[10];
int sensor_buf[100];
memcpy(buf,sensor_buf,10sizeof(int)); //非单字节空间是,需sizeof
unsigned char buf1[10];
unsigned char sensor_buf[100];// 00 00 00 23 45 78
// strncpy(buf,sensor_buf,10) //拷贝不成功,因为数据00开头
memcpy(buf,sensor_buf,10*sizeof(unsigned char)); //10个字节(数据空间),对应10个内存单位,这里正好一一对应,书写规范要求带sizeof
先找对象(有无符号),再确定操作。
指针与数组
指针数组
建立与二维指针的关系,哪种好理解,记哪个
*a[100] //*代表a的属性
char *a[100];
sizeof(a) = 100 * 4; //一个地址4个字节
char **a;
数组名的保存
定义一个指针,指向int a[10]的首地址
定义一个指针,指向int b[5][6]的首地址
int *p1 = a; //这种写法是合理的,p指针定义读内存的方法是int,4个字节一组,读取,与原数据定义一致,2个内存读取的方式一样,就不会报警告或者错误。
int **p2 = b; //错误方法
示例代码
#include <stdio.h>
int main()
{
int a[10];
int b[5][6];
int *p1 = a;
int **p2 = b; //提示警告,因为二维数组与二维指针没有任何关系
}
// E:\temp>cd "e:\temp\" && gcc 2.c -o 2 && "e:\temp\"2
// 2.c: In function 'main':
// 2.c:10:16: warning: initialization from incompatible pointer type [enabled by default]
二维数组不是按基本的数据类型读内容,因为每行中的列不同,上例中,每移动一行的指针,内存跨度为4*6=24B,是一块一块的内存。
正确写法为:int (*p)[6]; //*p是整体,[6]每行二维数组的列数。
故示例中应改为:
int (*p2)[6] = b; //在内存中指针移动或指代的方式根据之前的int和之后的[]修饰
int b[2][3][4]
int (*p)[3][4];
2-4 : C语言内存空间的使用-结构体
字节对齐
出于CPU效率的考虑,牺牲一点空间换取时间的效率。
这样的解决方案又称为字节对齐,32bit对齐。
示例
#include <stdio.h>
struct abc
{
char a;
int b;
};
int main()
{
struct abc buf;
printf("the buf is %lu\n",sizeof(buf)); //8个字节
};
// E:\temp>cd "e:\temp\" && gcc 2.c -o 2 && "e:\temp\"2
// the buf is 8
打包顺序的影响
最终结构体的大小一定是4的倍数
结构体成员变量顺序不一致,也会影响他们的大小
可以由低2位对齐,满足效率要求。
示例
#include <stdio.h>
struct abc
{
char a;
short e;
int b;
};
struct my
{
char a;
int b;
short e;
};
int main()
{
struct abc buf1;
struct my buf2;
printf("the buf1 is %lu\n",sizeof(buf1)); //8个字节
printf("the buf2 is %lu\n",sizeof(buf2)); //8个字节
};
// E:\temp>cd "e:\temp\" && gcc 2.c -o 2 && "e:\temp\"2
// the buf1 is 8
// the buf2 is 12
内存分布图
内存的属性
1、大小
2、在哪里
int a; //默认方式进行最终的定位,放置的区域叫section(分段)的概念
编译—》汇编―–》链接
*.o build
#include <stdio.h>
int a; //主函数体外,可看成是全局变量,存放位置离mian的空间较近
int main()
{
//int a; //临时的,当函数完成后,会销毁,存放位置也相对较高
a = 0x10;
printf("the a is %p\n",&a);
printf("the main is %p\n",main);
return 0;
};
// 局部变量:
// E:\temp>cd "e:\temp\" && gcc 2.c -o 2 && "e:\temp\"2
// the a is 000000000064FE2C
// the main is 0000000000401500
// 全局变量:
// E:\temp>cd "e:\temp\" && gcc 2.c -o 2 && "e:\temp\"2
// the a is 000000000040D3C8
// the main is 0000000000401500
内核空间 应用程序不许访问,看也不行
----------------3G
栈空间(局部变量)
运行时的堆空间(malloc申请的空间)
全局数据空间 (初始化的空间,未初始化) data bss
只读数据段 "hello world" TEXT段
代码段 code(只读) TEXT段
0x0;
#include <stdio.h>
int b = 100; //主函数体外,可看成是全局变量,存放位置离mian的空间较近
int fun()
{
static int a = 100;
return a++;
}
int main()
{
static int a;
unsigned char *p;
a = 0x10;
printf("the a is %p\n",&a);
printf("the main is %p\n",main);
p = (unsigned char *)main;
printf("the p[0] is %x\n",p[0]);
p[0] = 0x12; //操作这样属性的区域,会报错:segmentation fault
printf("+++++ the p[0] is %x\n",p[0]);
return 0;
};
// E:\temp>cd "e:\temp\" && gcc 2.c -o 2 && "e:\temp\"2
// the a is 000000000040C030
// the main is 0000000000401519
// the p[0] is 55
// 无显示
示例代码:
#include <stdio.h>
int b = 100; //主函数体外,可看成是全局变量,存放位置离mian的空间较近
int fun()
{
static int a = 100;
return a++;
}
int main()
{
static int a;
unsigned char *p;
char *p1 = "helao world";
a = 0x10;
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);
// printf("the a is %p\n",&a);
// printf("the main is %p\n",main);
// p = (unsigned char *)main;
// printf("the p[0] is %x\n",p[0]);
// p[0] = 0x12; //操作这样属性的区域,会报错:segmentation fault
// printf("+++++ the p[0] is %x\n",p[0]);
return 0;
};
// E:\temp>cd "e:\temp\" && gcc 2.c -o 2 && "e:\temp\"2
// the p1 is helao world
// the string address is 0000000000409020
// 无显示
示例3
```C
#include <stdio.h>
// int b = 100; //主函数体外,可看成是全局变量,存放位置离mian的空间较近
int fun()
{
static int a = 100;
return a++;
};
int main()
{
static int a;
unsigned char *p;
//char *p1 = "helao world";
const int b = 0x12345678; //b只读变量
a = 0x10;
char *p1 = &b;
printf("the p1 is %x\n",p1);
printf("the string address is %p\n","helao world");
p1[3] = '0';
printf("the p1 is %x\n",p1);
return 0;
};
// E:\temp>cd "e:\temp\" && gcc 2.c -o 2 && "e:\temp\"2
// 2.c: In function 'main':
// 2.c:17:16: warning: initialization from incompatible pointer type [enabled by default]
// the p1 is 64fe24
// the string address is 000000000040902E
// the p1 is 64fe24
// E:\temp>size 2.exe
// text data bss dec hex filename
// 30936 2864 5136 38936 9818 2.exe
示例4:同样的字符串增加字符前后堆空间分布
#include <stdio.h>
// int b = 100; //主函数体外,可看成是全局变量,存放位置离mian的空间较近
int fun()
{
static int a = 100;
return a++;
};
int main()
{
static int a;
unsigned char *p;
char *p1 = "helao world";
const int b = 0x12345678; //b只读变量
a = 0x10;
printf("the p1 is %s\n",p1);
printf("12345678the string address is %p\n","helao world"); //对独一无二的字符串加上1234
p1[3] = 'l';
printf("the p1 is %s\n",p1);
return 0;
};
// text(代码) data(数据) bss(未初始化信息) dec hex filename
// E:\temp>cd "e:\temp\" && gcc 2.c -o 2 && "e:\temp\"2
// the p1 is helao world
// the string address is 0000000000409020
// E:\temp>size 2.exe
// text data bss dec hex filename
// 30952 2864 5136 38952 9828 2.exe
// E:\temp>cd "e:\temp\" && gcc 2.c -o 2 && "e:\temp\"2
// the p1 is helao world
// 1234the string address is 0000000000409020
// E:\temp>size 2.exe
// text data bss dec hex filename
// 30952 2864 5136 38952 9828 2.exe
// E:\temp>cd "e:\temp\" && gcc 2.c -o 2 && "e:\temp\"2
// the p1 is helao world
// 12345678the string address is 0000000000409020
// E:\temp>size 2.exe
// text data bss dec hex filename
// 30984 2864 5136 38984 9848 2.exe
示例分析
# E:\temp>size 2.exe
# text data bss dec hex filename
# 30984 2864 5136 38984 9848 2.exe
# E:\temp>strings 2.exe //显示双引号内的字符
# ffffff.
# ATUWVSH
# T$ E
# t5H9
# [^_]A\
# fff.
# D$ tv
# D$(H
# T$ H
# L$ H
# L$(H
# fffff.
# ATUWVSH
# [^_]A\
# ......
static int a; 放在bss空间中,而默认值是auto。