嵌入式 C语言 补充

• 前言
• C语言结构体中__packed 和位段的理解
• • 1、__packed
  • • 对齐
  • 2、位段
• 结构体
• • 结构体内存对齐问题
• 共用体 union
• • • 作用：
  • 举个例子
• assert()
• • • assert() 的用法和机制
    • NDEBUG 宏
• C typedef
• • • 为基本数据类型定义新的类型名
    • 为自定义数据类型（结构体、共用体和枚举类型）定义简洁的类型名称
    • • 为了加深对 typedef 的理解，我们再来看一个结构体例子，如下面的代码所示：
    • 为数组定义简洁的类型名称
    • 为指针定义简洁的名称
    • 实际应用
• #define
• C 标准库 -

下面的内容很多都是做一些整理和搬运，借鉴了别人的文章，然后稍微整理、汇总一下，方便自己查看。

typedef __packed struct

typedef struct
{
    char a; //1byte
    int b;  //4byte
    char c[2]; //2byte
    double d;  //8byte
}

现代计算机中内存空间都是按照byte划分的，从理论上讲似乎对任何类型的变量的访问可以从任何地址开始，但实际情况是在访问特定类型变量的时候经常在特定的内存地址访问，这就需要各种类型数据按照一定的规则在空间上排列，而不是顺序的一个接一个的排放，这就是对齐。

比如8位机，那么上述结构体占用1+4+2+8=15byte。

在16位机里，变量就按照2字节对齐，比如成员a，虽然是char类型，地址在0x80000000本身只占1字节，但是下一个成员b却不能使用0x80000001这个地址，而必须使用而必须使用0x80000002，这就是按字长对齐，以上结构体占用的空间也就是2+4+2+8=16字节。

在32位机中，如果a在0x80000000的话，b只能放在0x80000004，因为这里的字长是4个字节。以上结构体占用空间4+4+4+8=20字节也就是说总有一些字节是浪费掉的，这样做的目的很简单，就是因为在大多数计算机体系结构中，对内存操作时按整字存取才能达到最高效率，相当于是以空间换取时间。

对齐的作用和原因：各个硬件平台对存储空间的处理上有很大的不同。一些平台对某些特定类型的数据只能从某些特定地址开始存取。比如有些架构的CPU在访问 一个没有进行对齐的变量的时候会发生错误，那么在这种架构下编程必须保证字节对齐。其他平台可能没有这种情况，但是最常见的是如果不按照适合其平台要求对数据存放进行对齐，会在存取效率上带来损失。

比如有些平台每次读都是从偶地址开始，如果一个int型（假设为32位系统）如果存放在偶地址开始的地方，那么一个读周期就可以读出这32bit，而如果存放在奇地址开始的地方，就需要2个读周期，并对两次读出的结果的高低字节进行拼凑才能得到该32bit数 据。显然在读取效率上下降很多。

#pragma pack(1)：使结构体按照1字节对齐

#pragma pack()：取消指定对齐，恢复缺省对齐

在MDK中加上__packed关键字，可以得到非字节对齐的紧凑结构，如果编译器不支持__packed关键字，可以将其定义为

#define __packed

参考文章

struct __packed data
{
    unsigned a : 2;
    unsigned b : 6;
    unsigned c : 4;
    unsigned d : 4;
    int i;
} data;

其中冒号表示啥意思？

C语言中，这叫 “位段”，C语言允许在一个结构体中以位为单位来指定其成员所占内存长度，这种以位为单位的成员称为“位段”或称“位域”( bit field) 。

利用位段能够用较少的位数存储数据， : 后面的数字用来限定成员变量占用的位数。

位域通过一个结构声明来建立：该结构声明为每个字段提供标签，并确定该字段的宽度。例如，下面的声明建立了个4个1位的字段：

struct
{
   unsigned int autfd : 1; //用来限定成员变量占用的位数
   unsigned int bldfc : 1;
   unsigned int undin : 1;
   unsigned int itals : 1;
}prnt;

根据该声明， prnt包含4个1位的字段。现在，可以通过普通的结构成员运算符(.)单独给这些字段赋值：

prnt.itals = 0:
prnt.undin = 1;

由于每个字段恰好为1位，所以只能为其赋值1或0。变量prnt被储存在int大小的内存单元中，但是在本例中只使用了其中的4位。

参考

先看一个结构体：

typedef struct Test
{
    char a1;
	int a2;
 	char a3;
 	short a4;
} Test_T;

在32位编译系统下这一个结构体的字节数是多少呢？是1+4+1+2=8字节吗？不是的，实际结果为12字节。为什么呢？因为编译器会对不足4字节的变量空间自动补齐为4个字节（这就是内存对齐），以提高CPU的寻址效率（32位CPU以4个字节步长寻址的）。

内存对齐是编译器的“管辖范围”。编译器为程序中的每个”数据单元“安排在适当的位置上，以便于能快速的找到每个“数据单元”。对于32bit的CPU，其寻址的步长为4个字节（即unsigned int 字节长度），这就是常说的“4字节对齐”。同理，对于64bit的CPU，就有“8字节对齐”。本文以32位的CPU为例。

请看下面代码：

#include 

typedef struct Test
{
	char a1;
 	int a2;
 	char a3;
 	short a4;
} Test_T;

int main(void)
{
 	Test_T T;
 
 	printf("nsizeof(T) = %dn", sizeof(T));
 	printf("a1地址：%dn", (unsigned int)&T.a1);
 	printf("a2地址：%dn", (unsigned int)&T.a2);
 	printf("a3地址：%dn", (unsigned int)&T.a3);
 	printf("a4地址：%dn", (unsigned int)&T.a4);
 
 	return 0;
}

运行结果为：

可见，正好印证了上述的说法，补齐之后结构体成员a1、a2、a3的地址之间正好相差4个字节，a3与a4之间相差两个字节也是因为在其中多留出了1个空白字节。该程序的运行结果可形象地描述为下图：

a1只占用一个字节，为了内存对齐保留了三个空白字节

a3和a4加起来共3字节，为了内存对齐保留了1个空白字节。这就是编译器存储变量时做的见不得人的”手脚“，以方便其雇主——CPU能更快地找到这些变量。

结构体和共用体的区别在于：结构体的各个成员会占用不同的内存，互相之间没有影响；而共用体的所有成员占用同一段内存，修改一个成员会影响其余所有成员。

• 为了方便看懂代码
  比如说想写一个3 * 3的矩阵，可以这样写：

  struct  Matrix
  {
      union
      {
          struct
          {
              float  _f11, _f12, _f13, _f21, _f22, _f23, _f31, _f32, _f33;
          };
          float  f[3][3];
      }_matrix;
  };
   
  struct  Matrix m;
  

  这两个东西共同使用相同的空间，所以没有空间浪费，在需要整体用矩阵的时候可以用m._matrix.f （比如说传参，或者是整体赋值等）；需要用其中的几个元素的时候可以用m._matrix._f11那样可以避免用m.f[0][0]（这样不大直观，而且容易出错）。

• 实现多种数据类型之间转换

• 测试大小端模式（大小端去百度）
  所谓的大端模式，是指数据的低位保存在内存的高地址中，而数据的高位，保存在内存的低地址中

  所谓的小端模式，是指数据的低位保存在内存的低地址中，而数据的高位，保存在内存的高地址中

• 寄存器的定义，实现整体的访问和单项的访问

  struct register
  {
      char a;
      char b;
      char c;
      char d;
  };
  
  union Register
  {
     struct register;
     int whole;
  };
  

  这样就能实现单项和整体的访问，特别是引入位域操作等相关结构以后，能够实现每一个bit的访问。

• 数据组合、拆分
  比如，可以方便直观的把0x12345678拆分成0x78、0x56、0x34、0x12

• 传输浮点数据

  union f_data 
  {
  	float f;
  	struct
  	{
  		unsigned char byte[4];
  	};
  }
  

  类似的，使用这样子的方法可以用于传输浮点数，更具体地不再展开，网络上有很多这一块的资料。感兴趣的朋友可以自己操作验证验证。

我们看一看TI的寄存器封装是怎么做的：

所有的寄存器被封装成联合体类型的，联合体里边的成员是一个32bit的整数及一个结构体，该结构体以位域的形式体现。这样就可以达到直接操控寄存器的某些位了。比如，我们要设置PA0引脚的GPAQSEL1寄存器的[1:0]两位都为1，则我们只操控两个bit就可以很方便的这么设置：

GpioCtrlRegs.GPAQSEL1.bit.GPIO0 = 3

或者直接操控整个寄存器：

GpioCtrlRegs.GPAQSEL1.all |=0x03 

如果不是工作于芯片原厂，寄存器的封装应该离我们很远。但我们可以学习使用这种方法，然后用于我们的实际应用开发中。

下面就看一种实际应用：管理一些状态变量。

示例代码：

union sys_status
{
   uint32 all_status;
   struct 
   {
      bool status1:  1; // FALSE / TRUE
      bool status2:  1; // 
      bool status3:  1; // 
      bool status4:  1; // 
      bool status5:  1; // 
      bool status6:  1; // 
      bool status7:  1; // 
      bool status8:  1; // 
      bool status9:  1; // 
      bool status10: 1; // 
   // ...
  }bit;
};

参考

– 宏函数

断言函数，用于在调试过程中捕捉程序的错误。

函数原型

void assert (int expression);

assert() 会对表达式expression进行检测：

• 如果expression的结果为 0（条件不成立），那么断言失败，表明程序出错，assert() 会向标准输出设备（一般是显示器）打印一条错误信息，并调用 abort() 函数终止程序的执行。
• 如果expression的结果为非 0（条件成立），那么断言成功，表明程序正确，assert() 不进行任何操作。

#include 
#include 
int main(){
    int m, n, result;
    scanf("%d %d", &m, &n);
    assert(n != 0);  //写作 assert(n) 更加简洁
    result = m / n;
    printf("result = %dn", result);
    return 0;
}

本例用来计算两个数相除的结果，由于被除数不能为 0，所以我们加入了 assert() 来检测错误。

#ifdef NDEBUG
#define assert(e) ((void)0)
#else
#define assert(e)  
    ((void) ((e) ? ((void)0) : __assert (#e, __FILE__, __LINE__)))
#endif

这意味着，一旦定义了NDEBUG宏，assert() 就无效了。

NDEBUG 是”No Debug“的意思，也即“非调试”。有的编译器（例如 Visual Studio）在发布（Release）模式下会定义 NDEBUG 宏，在调试（Debug）模式下不会定义定义这个宏；有的编译器（例如 Xcode）在发布模式和调试模式下都不会定义 NDEBUG 宏，这样当我们以发布模式编译程序时，就必须自己在编译参数中增加 NDEBUG 宏，或者在包含 头文件之前定义 NDEBUG 宏。

调试模式是程序员在测试代码期间使用的编译模式，发布模式是将程序提供给用户时使用的编译模式。在发布模式下，我们不应该再依赖 assert() 宏，因为程序一旦出错，assert() 会抛出一段用户看不懂的提示信息，并毫无预警地终止程序执行，这样会严重影响软件的用户体验，所以在发布模式下应该让 assert() 失效。

修改上面的代码，在包含 之前定义 NDEBUG 宏：

#define NDEBUG

#include 
#include 

int main()
{    
    int m, n, result;
    scanf("%d %d", &m, &n);
    assert(n);
    result = m / n;
    printf("result = %dn", result);
    return 0;
}

当以发布模式编译这段代码时，assert() 就会失效。如果希望继续以调试模式编译这段代码，去掉 NDEBUG 宏即可。

在代码中显式地增加 NDEBUG 宏比较麻烦，因为当以调试模式编译代码时还得再去掉它，更加科学的做法是在 IDE 的编译参数中添加 NDEBUG 宏。不同的 IDE 添加宏的方式不同，这里不再深入探讨。（可以去看看keil5里面怎么添加全局的宏）

也就是说，系统默认的所有基本类型都可以利用 typedef 关键字来重新定义类型名，示例代码如下所示：

typedef unsigned int COUNT;

这样做的好处就是我们在跨平台移植的时候只需要修改一下 typedef 就可以了

比如 size_t 在 VC++2010 的 crtdefs.h 文件中的定义如下所示：

#ifndef _SIZE_T_DEFINED
#ifdef  _WIN64
typedef unsigned __int64    size_t;
#else
typedef _W64 unsigned int   size_t;
#endif
#define _SIZE_T_DEFINED
#endif

以结构体为例，下面我们定义一个名为 Point 的结构体：

struct Point
{
    double x;
    double y;
    double z;
};

在调用这个结构体时，我们必须像下面的代码这样来调用这个结构体：

struct Point oPoint1 = {100，100，0};
struct Point oPoint2;

在这里，结构体 struct Point 为新的数据类型，在定义变量的时候均要向上面的调用方法一样有保留字 struct，而不能像 int 和 double 那样直接使用 Point 来定义变量。现在，我们利用 typedef 定义这个结构体，如下面的代码所示：

typedef struct tagPoint
{
    double x;
    double y;
    double z;
} Point;

在上面的代码中，实际上完成了两个操作：

1. 定义了一个新的结构类型
2. 使用 typedef 为这个新的结构起了一个别名，叫 Point

typedef struct tagNode
{
    char *pItem;
    pNode pNext;
} * pNode;

从表面上看，上面的示例代码与前面的定义方法相同，所以应该没有什么问题。但是编译器却报了一个错误，为什么呢？莫非 C 语言不允许在结构中包含指向它自己的指针？

其实问题并非在于 struct 定义的本身，大家应该都知道，C 语言是允许在结构中包含指向它自己的指针的，我们可以在建立链表等数据结构的实现上看到很多这类例子。那问题在哪里呢？其实，根本问题还是在于 typedef 的应用。

在上面的代码中，新结构建立的过程中遇到了 pNext 声明，其类型是 pNode。这里要特别注意的是，pNode 表示的是该结构体的新别名。于是问题出现了，在结构体类型本身还没有建立完成的时候，编译器根本就不认识 pNode，因为这个结构体类型的新别名还不存在，所以自然就会报错。因此，我们要做一些适当的调整，比如将结构体中的 pNext 声明修改成如下方式：

typedef struct tagNode
{
    char *pItem;
    struct tagNode *pNext;
} * pNode;

它的定义方法很简单，与为基本数据类型定义新的别名方法一样，示例代码如下所示：

typedef int INT_ARRAY_100[100];
INT_ARRAY_100 arr;

对于指针，我们同样可以使用下面的方式来定义一个新的别名：

typedef char* PCHAR;
PCHAR pa;

对于上面这种简单的变量声明，使用 typedef 来定义一个新的别名或许会感觉意义不大，但在比较复杂的变量声明中，typedef 的优势马上就体现出来了，如下面的示例代码所示：

int *(*a[5])(int, char *);

对于上面变量的声明，如果我们使用 typdef 来给它定义一个别名，这会非常有意义，如下面的代码所示：

// PFun是我们创建的一个类型别名
typedef int *(*PFun)(int,char*);
// 使用定义的新类型来声明对象，等价于int*(*a[5])(int,char*);
PFun a[5];

来自：typedef的用法，C语言typedef详解

在IAP编程当中，我们要用到跳转到应用程序段：

就用到了 typedef void (*app_func) (void);

typedef void (*app_func) (void);       //定义一个函数类型的参数

app_func application;
uint32_t app_address;

//跳转到应用程序段
//appxaddr:用户代码起始地址.
void iap_load_app(uint32_t appxaddr)
{
    //printf("%xrn", *(vu32 *)appxaddr);
    //printf("%xrn", *(vu32 *)0x08010000);

    //检测栈顶的地址是否合法，判断用户代码的堆栈地址是否落在0x2000000~0x2001ffff区间
    if (((*(vu32 *)appxaddr) & 0x2FFE0000U) == 0x20000000U)
    {
		app_address = *(__IO uint32_t*) (appxaddr + 4U); //ApplicationAddress + 4  对应的是app中断向量表的第二项，复位地址
		application = (app_func) app_address;// (iapfun) 把地址强转为函数指针

		
		__set_MSP(*(__IO uint32_t*) appxaddr);//设置主函数栈指针   将用户代码的栈顶地址设为栈顶指针

		
		application(); //跳转到APP 调用函数，实际失去app复位地址去执行复位操作---设置程序指针为复位地址
    }
}

用 #define 定义标识符的一般形式为：

#define 标识符 常量  //注意, 最后没有分号

#define 和 #include 一样，也是以“#”开头的。凡是以“#”开头的均为预处理指令，#define也不例外。

#define又称宏定义，标识符为所定义的宏名，简称宏。标识符的命名规则与前面讲的变量的命名规则是一样的。#define 的功能是将标识符定义为其后的常量。一经定义，程序中就可以直接用标识符来表示这个常量。是不是与定义变量类似？但是要区分开！变量名表示的是一个变量，但宏名表示的是一个常量。可以给变量赋值，但绝不能给常量赋值。

宏所表示的常量可以是数字、字符、字符串、表达式。其中最常用的是数字。

简单用法：

#define NQ_DEBUG_ON 1   //DEBUG开关

#define NQ_PRINTF(fmt, arg...)  
    do                          
    {                           
        if (NQ_DEBUG_ON)        
            printf(fmt, ##arg); 
    } while (0)

#define     __IO    volatile    

u8 test;
test = 1;
test = 2;
test = 3;

volatile u8 test;
test = 1;
test = 2;
test = 3;

char a = 'A'; // global variable
void msg()
{
    printf("Hellon");
}

int main(void)
{    
    extern char a;    // extern variable must be declared before use
    printf("%c ", a);
    (void)msg();
    return 0;
}

A Hello

const int n=5; int const n=5;

const char* str="fdsafdsa";

const int * n; int const * n;

int a=5; const int* n=&a; a=6;

int a=5; int b=6; const int* n=&a; n=&b;

int *const n;

int a=5; int *p=&a; int* const n=&a; *p=8;

void StringCopy(char *strDestination, const char *strSource);

void swap ( int *const p1 , int *const p2 )

const char *GetString(void);

char *str = GetString();

const char *str = GetString();

#include 
main()
{
    short int a = 65534, b, c, d;
    b = a + 1;
    c = a + 2;
    d = a + 3;
    printf("a=%dnb=%dnc=%dnd=%dn", a, b, c, d);
}

        //溢出位(实际上不存在)
a = -2  //      1111 1111 1111 1110
b = -1  //      1111 1111 1111 1111
c = 0   //0001  0000 0000 0000 0000
d = 1   //0001  0000 0000 0000 0001

[+1] = [0000 0001]原 = [0000 0001]反 = [0000 0001]补
[-1] = [1000 0001]原 = [1111 1110]反 = [1111 1111]补 

1 - 1 = 1 + (-1) = [00000001]原 + [10000001]原 = [10000010]原 = -2

1-1 = 1 + (-1) = [0000 0001]原 + [1000 0001]原 = [0000 0001]补 + [1111 1111]补 = [0000 0000]补=[0000 0000]原

#ifdef __cplusplus 
extern "C" { 
#endif 
 
//一段代码 
 
#ifdef __cplusplus 
} 
#endif