文章目录
一、作用域
-
局部/全局变量：
- 局部变量(也叫
auto自动变量，定义在函数或复合语句内)的作用域：定义处生效，本级大括号结束时失效 - 全局变量(定义在函数
外)的作用域：永久有效，可被本文件及其它文件中的函数所共用，若其它文件中的函数调用此变量，须用extern声明，不同文件的全局变量不可重名 - 多用局部变量，少用全局变量：因为全局变量一直占用着系统的内存，而且全局变量定义的多了，会影响程序的可读性；而局部变量用完后其内存就释放了
- 局部变量(也叫
-
静态局部/全局变量： 存储在静态区，内存位置在程序执行期间一直不改变
- 当用
static修饰变量时，该变量就不能够在别的文件中用extern声明和访问了，只能在本文件内可见，生命周期和程序运行周期一样，且 staitc 局部变量的值只会初始化一次（重复初始化无效），但可以多次赋值改变，离开作用域后内存也不会销毁，下次在作用域内仍能用到改变后的值（参见程序示例） - static 局部/全局变量的作用域在定义的
函数内/所定义的文件中有效，不同文件静态全局变量可以重名（作用域不冲突） - static 局部/全局变量若未赋以初值，则由系统自动赋值：数值型变量自动赋初值
0，字符型变量赋空字符
- 当用
-
全局函数和静态函数：
- 全局函数：在 C 语言中函数默认都是全局的，意味着所有函数都不能重名
- 静态函数：使用关键字
static可以将函数声明为静态，那么此函数就只能在当前文件中使用，在其他文件中不能调用，但不同的文件 static 函数名是可以相同的
-
动态分配对象的生存期与它们在哪里创建是无关的，只有当显式地被释放时，这些对象才会销毁
#include <stdio.h>
// 局部变量作用域
int main()
{
if(1)
{
// 在复合语句中定义，只在复合语句中有效
int b = 123; // b生效
} // 大括号结束时，b 已经失效
printf("%d \n", b); // 不可以访问一个已经失效的变量
return 0;
}
// static：静态局部变量
void fun1() {
int i = 0;
i++;
printf("i = %d\n", i);
}
void fun2() {
// 静态局部变量，没有赋值，系统赋值为 0，而且只会初始化一次（重复初始化无效）
static int a = 5;
a++;
printf("a = %d\n", a);
}
int main(void) {
fun1(); // i=1
fun1(); // i=1
fun2(); // a=6
fun2(); // a=7
fun2(); // a=8
return 0;
}
/******************************************************************/
#include <stdio.h>
#include <stdlib.h>
int e; // 全局未初始化变量，默认 0
int f = 10; // 全局初始化变量
static int g; // 静态全局未初始化变量，默认 0
static int h = 10; // 静态全局初始化变量
int main() {
int a; // 局部未初始化变量，默认随机值
int b = 10; // 局部初始化变量
static int c; // 静态局部未初始化变量，默认 0
static int d = 10; // 静态局部初始化变量
const char* i = "test"; // 只读数据(文字常量区)
char* k = NULL;
k = (char*) malloc(10); // 动态分配的内存
return 0;
}
二、内存布局
1、内存地址
- 将内存抽象为一个很大的
一维字符数组 - 编码：对内存的
每一个字节分配一个 32 位或 64 位的编号（与 32 位或者 64 位处理器相关），这个内存编号我们称之为内存地址 - 寻址：可以根据分配的号码找到相应的存储单元，完成数据的读写
2、内存分区
系统未把程序加载到内存前，可执行程序内部已经分好 3 段信息，分别为
代码区(text)、数据区(data)和未初始化数据区(bss)（ data 和 bss 合起来叫做静态区或全局区，主要包含全局变量区，静态变量区和常量区)系统把程序加载到内存运行时，除了根据可执行程序的信息分出
代码区(text)、数据区(data)和未初始化数据区(bss)之外（编译器分配），还额外增加了堆区(需用户自己分配与回收)、栈区(程序运行过程中系统自动分配与回收)数据交换流程：
CPU-->寄存器-->缓存-->内存-->硬盘Note：
- 未初始化数据区的数据在程序开始执行之前被内核初始化为 0 或者空(NULL)，代码区在程序运行期间是只读共享的
- 在 Linux 环境下，可以通过
ulimit -s来查看栈空间的大小(stack size)，一般为8M(8192KB)，Linux 默认给每一个用户进程栈分配 8MB 大小的空间；堆空间相对大得多，所以如果变量占用的内存较大，可以将其分配到堆空间- 栈的使用：尽量不要在函数内使用大数组， 如果确实需要大块内存， 则可以使用
calloc申请动态内存；函数的嵌套层数不宜过深；递归的层数不宜太深
3、内存操作函数
a、memset()
- 注意：
memset对于较大的内存区域会增加程序的耗时，这主要是因为memset需要逐字节地设置内存中的每个位置，这个过程的时间复杂度是线性的，即O(n)，其中n是要填充的字节数
#include <stdio.h>
#include <string.h>
int main() {
char a[6] = "HELLO";
memset(a, 'M', 3);
for (int i = 0; i < 6; i++)
{
printf("index is %d, char is %c\n", i, a[i]);
}
}
// 输出结果：
index is 0, char is M
index is 1, char is M
index is 2, char is M
index is 3, char is L
index is 4, char is O
index is 5, char is
b、memcpy()、memmove()
memmove()功能用法和memcpy()一样，区别在于dest和src所指的内存空间重叠时，memmove()仍然能处理，不过执行效率比memcpy()低些
#include <stdio.h>
#include <string.h>
int main() {
char a[6] = "HELLO";
char b[6] = {};
memcpy(b, a, 2); // memmove(b, a, 2)
for (int i = 0; i < 6; i++)
{
printf("index is %d, char is %c\n", i, b[i]);
}
}
// 输出结果：
index is 0, char is H
index is 1, char is E
index is 2, char is
index is 3, char is
index is 4, char is
index is 5, char is
c、memcmp()
#include <stdio.h>
#include <string.h>
int main() {
char a[] = "HELLO";
char b[] = "HIM";
int flag1 = memcmp(a, b, 1);
int flag2 = memcmp(a, b, 2);
int flag3 = memcmp(a, b, 3);
printf("flag1=%d \n", flag1); // 0
printf("flag2=%d \n", flag2); // -1024
printf("flag3=%d \n", flag3); // -1024，遇到第一个不同的后即停止比较
}
4、堆区内存分配与释放
- 堆是一个大容器，它的容量要远远大于栈，但没有
栈那样后进先出的顺序，用于动态内存分配- 堆在内存中位于 BSS 区和栈区之间，一般由程序员分配和释放，若程序员不释放，程序结束时由操作系统回收
fallocate预分配内存：fallocate -l bytes img.data // 512*512*3=786432 bytes- 广义上的内存泄漏：指系统频繁地进行内存申请和释放，
导致内存碎片越来越多，无法再申请一片连续的大块内存- 常见的内存错误：一般主要分为
内存越界、内存踩踏、多次释放、非法指针这几种类型- 发生段错误：根本原因在于
非法访问内存， 即访问了权限未许可的内存空间
a、malloc()/calloc()/realloc()/free()
- malloc 返回值类型：内存管理器不关心你拿这块内存来存储何种数据，所以返回万能指针类型
void*- 可以通过类型强制转换，将申请的内存的类型转为目标类型
- 只要是连续的内存空间，都能使用下标的方式访问内存
b、代码示例
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
int main() {
int n;
int cnt;
printf("请输入要申请数组元素的个数: ");
scanf("%d", &n);
// 应用程序在使用 malloc 时，要把返回值转换成目标类型
int size = sizeof(int) * n;
int *array = (int*) malloc(size); // 强制将返回值类型 void* 转换为 int*
// malloc 的返回值需要检测，因为此时可能没有闲置的内存可用
if (array == NULL) {
printf("申请空间失败!\n");
return -1;
}
// 将申请到空间赋初值 0
memset(array, 0, sizeof(int) * n);
for (cnt = 0; cnt < n; cnt++) // 给数组赋值（只要是连续的内存空间都可以使用下标的方式访问内存）
{
array[cnt] = cnt;
}
for (cnt = 0; cnt < n; cnt++) // 打印数组元素
{
printf("%2d", array[cnt]);
}
free(array); // 只需知道 malloc 申请的这块内存的首地址即可
return 0;
}
// 输出结果
请输入要申请数组元素的个数: 5
0 1 2 3 4
c、C++ 中的内存管理函数 new/delete
// 申请一个int型内存，系统会自动分配内存大小
// new 的返回值直接就是**该类型的对象指针**，不用像 malloc 那样还要强制转换一下类型
int* p = new int;
// new 的时候可以同时初始化这块内存中存放的值
int* p = new int(123); // 此时 *p = 123;
// delete 释放内存
delete p;
---------------------------------------------------------------------------------------------
// 申请多个 int 型对象大小的内存，例如，申请 1024 个 int 型对象大小的内存:
int* p = new int [1024] ;
delete [] p; // 用[]指定对象个数，如果 new 的时候用了[]，则释放的时候必须使用 delete [] 操作符
---------------------------------------------------------------------------------------------
// 对于class类型，必须用new/delete来创建、销毁。malloc/free是无法胜任的(因为new/delete会自动调用构造函数/析构函数)
// 使用 new 函数动态创建一个对象：首先申请一块内存，然后在内部调用构造函数
// 使用 delete 函数释放这个对象：首先调用了析构函数，然后释放内存
// new 一个对象的时候，可以传参，内部会调用构造函数
Circle* c = new Circle();
Circle* c = new Circle(1,1,4);
delete c;
// new 多个对象（数组）的时候，不能传参数，要求该类必须有**默认构造函数**
Circle* c = new Circle [4];
delete [] c;
5、内存分区代码分析
// 1、返回栈区地址 & 返回 data 区地址
#include <stdio.h>
int *fun1() {
int a = 10;
return &a; // 函数调用完毕, a 释放
}
int *fun2()
{
static int b = 10;
return &b; //函数调用完毕, b 不释放
}
int main(int argc, char *argv[]) {
int *p1 = NULL;
int *p2 = NULL;
p1 = fun1();
p2 = fun2();
*p1 = 100; // 操作野指针指向的内存,err
*p2 = 200;
printf("*p1 = %d\n", *p1);
printf("*p2 = %d\n", *p2);
return 0;
}
// 2、值传递
#include <stdio.h>
#include <stdlib.h>
void fun1(int *tmp) {
tmp = (int *) malloc(sizeof(int));
*tmp = 100;
}
void fun2(int *tmp)
{
*tmp = 100;
}
int main(int argc, char *argv[]) {
int *p1 = NULL;
int *p2 = NULL;
fun1(p1); // 值传递(NULL), 形参修改不会影响实参
printf("*p1 = %d\n", *p1);// err, 操作空指针指向的内存
p2 = (int *)malloc(sizeof(int));
fun2(p2); // 值传递(指针/堆区内存首地址)
printf("*p2 = %d\n", *p2); // ok, *p2 为 100
return 0;
}
// 3、返回堆区地址
#include <stdio.h>
#include <stdlib.h>
int *fun() {
int *tmp = (int *) malloc(sizeof(int));
*tmp = 100;
return tmp; // 返回堆区地址, 函数调用完毕,不释放
}
int main(int argc, char *argv[]) {
int *p = NULL;
p = fun();
printf("*p = %d\n", *p); // ok
// 堆区空间,使用完毕,手动释放
if (p != NULL) {
free(p);
p = NULL;
}
return 0;
}
// 4、堆区内存控制及传递
#include <stdio.h>
#include <stdlib.h>
typedef struct tagArea {
int h;
int w;
int area;
} TArea;
void open(void **pvHandle) {
TArea *obj = calloc(1, sizeof(TArea));
obj->h = 10;
obj->w = 20;
*pvHandle = obj; // 需要把算法句柄地址传给 pvHandle，所以参数要为指向指针的指针
}
void process(void *pvHandle) {
TArea *obj = (TArea *) pvHandle;
obj->area = obj->h * obj->w;
}
int main(int argc, char *argv[]) {
void *handle = NULL;
open(&handle); // handle 指向了堆区 obj 的首地址，相当于 handle = obj
// h = 10 w = 20 area = 0
printf("h = %d w = %d area = %d \n", ((TArea *) handle)->h, ((TArea *) handle)->w, ((TArea *) handle)->area);
// h = 10 w = 20 area = 200
process(handle); // handle 指向了堆区 obj 的首地址，相当于 handle = obj
printf("h = %d w = %d area = %d \n", ((TArea *) handle)->h, ((TArea *) handle)->w, ((TArea *) handle)->area);
// 堆区空间,使用完毕,手动释放
if (handle != NULL) {
free(handle);
handle = NULL;
}
return 0;
}
三、内存对齐
1、内存对齐的意义
- 内存对齐是指变量的地址必须是它自身所占字节的整数倍；是操作系统为了提高数据读取效率和存储器访问的连续性，以空间换时间的策略
- 在访问内存的时候，它会以特定的字节大小（例如 1 字节、2 字节、4 字节等，一般是操作系统默认的对齐数，或者默认对齐数的整数倍）进行操作；
- 在非自然对齐的情况下，CPU 需要进行多次内存操作才能获取完整的数据，每次读取一定长度
- 在自然对齐的情况下，变量的地址就是它自身所占字节的整数倍，这样，CPU可以一次性读取所有字节，无需进行额外的内存访问
- 为了快速访问内存首地址或跨行访问数据， 对所有平台申请内存的首地址及宽度进行了
32字节对齐（注意申请内存的数据类型，比如Float32==4Bytes，那么就是 8 的整数倍个 f32） - 海思 MMZ 的对齐：
- 海思很多模块和操作对 MMZ 的 stride 有对齐要求（不同平台要求不一致），比如要求 16 对齐，那么 44 ∗ 96 44*96 44∗96 的图像就必须申请 48 ∗ 96 48*96 48∗96 的 MMZ，这样处理起来更高效
- 平时在用 opencv 等工具读写图像数据时，并没有 stride 这样的信息，只需要关注长宽即可，这是因为 CPU 底层自动做了对齐，导致上层用户无感知，所以我们自己进行图像操作时，一定要注意进行字节对齐
2、如何进行内存对齐？
一般来说，结构体的对齐规则是先按
数据类型自身进行对齐，然后再按整个结构体进行对齐，对齐值必须是 2 的幂，比如 1，2， 4， 8， 16。如果一个类型按 n 字节对齐，那么该类型的变量起始地址必须是 n 的倍数。比如 int 按四字节对齐，那么 int 类型的变量起始地址一定是 4 的倍数，比如0x0012ff60，0x0012ff48等
- 普通数据类型内存对齐：
- 对于标准数据类型，它的地址只要是它长度的整数倍即可
- 对于非标准数据类型，比如结构体，要遵循一下对齐原则：
- 数据成员对齐规则：第一个成员应该放在 offset 为 0 的地方；以后每个成员应该从
min(当前成员的大小，#pragma pack(n)) 整数倍的地方开始 - 结构体总的大小：即 sizeof 的结果，必须是
min(最大成员的大小，#pragma pack(n)) 的整数倍，不足要补齐 - 手动设置对齐数
#pragma pack(n): 指定packing的数值，以字节为单位，缺省数值是 8，合法的数值分别是1, 2, 4, 8, 16 - 书写结构体的建议: 按照数据类型由小到大的顺序进行书写，这样可以占用最小内存
- 数据成员对齐规则：第一个成员应该放在 offset 为 0 的地方；以后每个成员应该从
- 图像数据内存对齐：
- 绝大多数图像处理库，会对每行数据进行自动填充(为了加快存储和读取)
- stride/pitch（步长/间距）：存储一行像素所需的字节数（
对齐后），如果图像的宽度是内存对齐长度的整数倍，那么间距就会等于图像的宽度。eg： 32 字节对齐，那么宽度为 720 像素的图像，一行就不满足 32 对齐的要求，那就要填充到 736 像素 - skip（跨度）： 跨行读取数据时， 每行的跨度（单位，字节）为：
间距(pitch)*交织通道数(channel)*数据类型(sizeof(type)) - 32 字节对齐：
#define align_pitch(x) ((x) + (32 - (x) % 32) % 32)
#pragma pack(4)
// 成员对齐：Student 内部成员对齐后总的大小为 20
// 整体对齐：为 min(最大成员的大小，#pargama pack(n))的整数倍， 也就是 4 的整数倍
struct Student{
int a; // 0-3
char b; // 4-7
double c; // 8-15
float d; // 16-19
};
#pragma message("Compile Android SDK 2.0...") // 用于自定义编译消息
#pragma once // 通常用于头文件，保证只被编译一次， 比通过宏定义的方式高效一些
#pragma pack(show) // 显示当前默认对齐字节数(一般 64 位系统默认 8 字节)
// eg：结构体数据成员顺序不同，占用内存大小示例
#include <stdio.h>
#pragma pack(show) // 32 位系统，默认是 8
typedef struct TagTest1 {
int i; // 0-7 （0-3，由于 d 占用 8 个字节，从 8 开始，所以 i 补齐缺的四个字节 3-7）
double d; // 8-15
char c; // 16-23（16，由于整体结构体大小要是 8 的倍数，所以 c 补齐缺的七个字节 17-23）
} TTest1;
typedef struct TagTest2 {
char c; // 0-3（0，由于 i 占用 4 个字节，从 4 开始，所以 i 补齐缺的三个字节 1-3）
int i; // 4-7
double d; // 8-15
} TTest2;
int main() {
printf("size of TTest1 is %d\n", sizeof(TTest1)); // size of TTest1 is 24
printf("size of TTest2 is %d\n", sizeof(TTest2)); // size of TTest2 is 16
return (0);
}
- 常用内存格式:
C*H*W：有C个平面（每个平面上的数据无交织），(C*H) * W，其中 W 要进行对齐align(W)，若输出数据类型为 f32，32 字节对齐，则 W 要是 8 的整数倍（f32==4bytes）H*W*C：有1个平面（每一行数据都是交织存储的），H * (W*C)，其中 C 要进行对齐align(C)，若输出数据类型为 f32，32 字节对齐，则 W 要是 8 的整数倍（f32==4bytes）
typedef enum
{
// U8：表示数据类型
// C：表示使用几个平面来表示该数据
// 注释标示的 W,H 仅表示数据存储排列方式，不代表实际通道的图像宽高
//---------------RGB24----------------
// 8bit 无符号 RGB 格式 (HWC)，RGB 交织 Plane[0]: RGB[W*3, H]
MEM_FORMAT_RGB_U8C1,
// 8bit 无符号 BGR 格式 (HWC)，BGR 交织 Plane[0]: BGR[W*3, H]
MEM_FORMAT_BGR_U8C1,
// 8bit 无符号 RGB 格式 (CHW)，RGB 无交织 Plane[0]: R[W, H] Plane[1]: G[W, H] Plane[2]: B[W, H])
MEM_FORMAT_RGB_U8C3,
// 8bit 无符号 BGR 格式 (CHW)，BGR 无交织 Plane[0]: B[W, H] Plane[1]: G[W, H] Plane[2]: R[W, H]
MEM_FORMAT_BGR_U8C3,
//---------------GRAY----------------
// Plane[0]: Y[W, H]
MEM_FORMAT_GRAY_U8C1,
//---------------YUV420----------------
// I420 UV 无交织 Plane[0]: Y[W, H] Plane[1]: U[W, H/4] Plane[2]: V[W, H/4]
MEM_FORMAT_YU12_U8C3,
// YUV420P UV 无交织 Plane[0]: Y[W, H] Plane[1]: V[W, H/4] Plane[2]: U[W, H/4]
MEM_FORMAT_YV12_U8C3,
// YUV420SP UV 交织 Plane[0]: Y[W, H] Plane[1]: UV[W, H/2]
MEM_FORMAT_NV12_U8C2,
// YUV420SP VU 交织 Plane[0]: Y[W, H] Plane[1]: VU[W, H/2]
MEM_FORMAT_NV21_U8C2,
//---------------YUV422----------------
// Plane[0]: UYVY[W, H*2]
MEM_FORMAT_UYVY_U8C1,
// Plane[0]: YUYV[W, H*2]
MEM_FORMAT_YUYV_U8C1,
// Plane[0]: YVYU[W, H*2]
MEM_FORMAT_YVYU_U8C1,
//---------------YUV444----------------
// Plane[0]: Y[W,H] Plane[1]: U[W,H] Plane[2]: V[W,H]
MEM_FORMAT_YUV444_U8C3,
//-------------U16/U32/U64-------------
// Plane[0]: [W,H]
MEM_FORMAT_U16C1,
// Plane[0]: [W,H]
MEM_FORMAT_U32C1,
// Plane[0]: [W,H]
MEM_FORMAT_U64C1,
//---------------RGB32----------------
// RGBA交织 Plane[0]: RGBA[W*4,H]
MEM_FORMAT_RGBA_U8C1,
// BGRA交织 Plane[0]: RGBA[W*4,H]
MEM_FORMAT_BGRA_U8C1,
// Plane[0]: R[W,H] Plane[1]: G[W,H] Plane[2]: B[W,H] Plane[3]: A[W,H]
MEM_FORMAT_RGBA_U8C4,
// Plane[0]: B[W,H] Plane[1]: G[W,H] Plane[2]: R[W,H] Plane[3]: A[W,H]
MEM_FORMAT_BGRA_U8C4,
//-----------------RAW-----------------
// RAW12
MEM_FORMAT_RAW12_RGGB,
// RAW12
MEM_FORMAT_RAW12_GBRG,
// RAW12
MEM_FORMAT_RAW12_BGGR,
// RAW12
MEM_FORMAT_RAW12_GRBG,
// RAW16
MEM_FORMAT_RAW16_RGGB,
// RAW16
MEM_FORMAT_RAW16_GBRG,
// RAW16
MEM_FORMAT_RAW16_BGGR,
// RAW16
MEM_FORMAT_RAW16_GRBG,
}TMemFormat;
四、计算机中数据的存储形式
-
当前的计算机系统使用的基本上是二进制系统，
数据在计算机中主要是以补码的形式存储的，主要原因是：- 统一了零的编码 ，将符号位和其它位统一处理
- 将减法运算转变为加法运算 ，不需要由于加数的符号性不同而采用多个底层加法电路，这样便可减轻电路设计的负担，另一方面也可以降低 CPU 的物理尺寸
- 两个用补码表示的数相加时，如果最高位(符号位)有进位，则进位被舍弃
-
有符号数据的原码、反码和补码：
- 原码：最高位为符号位，0 表示正数，1 表示负数；其它位数即为数值本身绝对值的二进制数
- 反码：对于正数，反码与原码相同；对于负数，原码符号位不变，其它部分取反
- 补码：对于正数，补码与原码相同；对于负数，原码符号位不变，其它部分取反，然后加 1（即为反码 +1）
- 1 个字节大小的数据的原码、反码及补码表示如下：
十进制数 原码 反码 补码 +15 00001111 00001111 00001111 -15 10001111 11110000 11110001 +0 00000000 00000000 00000000 -0 10000000 11111111 00000000 -
无符号数最高位不是符号位，而就是数的一部分，无符号数不可能是负数（其原码与补码相同）
-
补码转换为原码数值计算示例：
-
注意变量类型的隐式转换：因为计算机在看待数据时，并不会区分其符号性，而
符号性的差异仅体现在计算机指令操作数据时的具体使用方式上
#include <stdio.h>
int main(void) {
int x = -10;
unsigned int y = 1;
// 程序逻辑在真正进入到条件语句之前，变量 x 的类型会首先被隐式转换为 unsigned int ，即无符号整型。
// 而根据数据类型的解释规则，原先存放有 -10 补码的位模式会被解释为一个十分庞大的正整数，而这个数则远远大于 1
if (x < y) {
printf("x is smaller than y.");
} else {
printf("x is bigger than y."); // this branch is picked!
}
return 0;
}
五、计算机中数据的表示
扫一扫
2189
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
