编译连接过程

image.png
image.png

union 联合体

在数据解析中的应用
typedef union {
uint8_t buffer [PACKET_SIZE];
struct {
uint8_t size;
uint8_t CMD;
uint8_t payload[PAYLOAD_SIZE];
uint8_t crc;
} fields;
} PACKET_t;

  1. // 函数调用方法：packet_builder(packet.buffer,new_data)
  2. // 将新数据存到 buffer 的时候，还需要一些额外的操作
  3. // 比如应该将 size 存放 buffer[0]中
  4. // 将 cmd 存放到 buffer[1] 中，依次类推
  5. void packet_builder(uint8_t *buffer,uint8_t data)
  6. {
  7. static uint8_t received_bytes = 0;
  8. buffer[received_bytes++] = data;
  9. }

  11. void packet_handler(PACKET_t *packet)
  12. {
  13. if (packet->fields.size > TOO_BIG)
  14. {
  15. //错误
  16. }
  17. if (packet->fields.cmd == CMD)
  18. {
  19. //处理对应的数据
  20. }
  21. }

要理解这个数据解析过程，需要用到 union 中的成员存放在同一个地址这个特性，buffer[PACKET_SIZE]中的元素与 fields 中的元素是一一对应的，用一张图来表示就很清楚
image.jpeg
往 buffer 里写了数据，直接从 fileds 里面读出来就可以了。

链表

  1. https://www.cnblogs.com/skywang12345/p/3562146.html
  2. #define offset(type, member)  (size_t)(&((type *)0->member))
  3. #define container_of(ptr, type, member) (type *)((char *)ptr - offset(type, member))
  5. struct list_head {
  6.     struct list_head *pre;
  7.     struct list_head *next;    
  8. };
  10. #ifndef _LIST_HEAD_H
  11. #define _LIST_HEAD_H
  12. // 双向链表节点
  13. struct list_head {
  14.      struct list_head *next, *prev;
  15. };
  16.  // 初始化节点：设置name节点的前继节点和后继节点都是指向name本身。
  17. #define LIST_HEAD_INIT(name) { &(name), &(name) }
  18. // 定义表头(节点)：新建双向链表表头name，并设置name的前继节点和后继节点都是指向name本身。
  19. #define LIST_HEAD(name) \
  20.     struct list_head name = LIST_HEAD_INIT(name) 
  21. // 初始化节点：将list节点的前继节点和后继节点都是指向list本身。
  22. static inline void INIT_LIST_HEAD(struct list_head *list)
  23.  {
  24.      list->next = list;
  25.      list->prev = list;
  26.  }
  28.  // 添加节点：将new插入到prev和next之间。
  29.  static inline void __list_add(struct list_head *new,
  30.                    struct list_head *prev,
  31.                    struct list_head *next)
  32.  {
  33.       next->prev = new;
  34.       new->next = next;
  35.       new->prev = prev;
  36.       prev->next = new;
  37.   }
  39.   // 添加new节点：将new添加到head之后，是new称为head的后继节点。
  40.   static inline void list_add(struct list_head *new, struct list_head *head)
  41.   {
  42.       __list_add(new, head, head->next);
  43.   }
  45.   // 添加new节点：将new添加到head之前，即将new添加到双链表的末尾。
  46.   static inline void list_add_tail(struct list_head *new, struct list_head *head)
  47.   {
  48.       __list_add(new, head->prev, head);
  49.   }
  51.   // 从双链表中删除entry节点。
  52.   static inline void __list_del(struct list_head * prev, struct list_head * next)
  53.   {
  54.       next->prev = prev;
  55.       prev->next = next;
  56.   }
  58.   // 从双链表中删除entry节点。
  59.   static inline void list_del(struct list_head *entry)
  60.   {
  61.       __list_del(entry->prev, entry->next);
  62.   }
  64.   // 从双链表中删除entry节点。
  65.  static inline void __list_del_entry(struct list_head *entry)
  66.   {
  67.       __list_del(entry->prev, entry->next);
  68.   }
  70.   // 从双链表中删除entry节点，并将entry节点的前继节点和后继节点都指向entry本身。
  71.   static inline void list_del_init(struct list_head *entry)
  72.  {
  73.       __list_del_entry(entry);
  74.      INIT_LIST_HEAD(entry);
  75.  }
  77.   // 用new节点取代old节点
  78.   static inline void list_replace(struct list_head *old,
  79.                   struct list_head *new)
  80.   {
  81.       new->next = old->next;
  82.       new->next->prev = new;
  83.       new->prev = old->prev;
  84.       new->prev->next = new;
  85.   }
  87.   // 双链表是否为空
  88.   static inline int list_empty(const struct list_head *head)
  89.   {
  90.       return head->next == head;
  91.   }
  93. // 获取"MEMBER成员"在"结构体TYPE"中的位置偏移
  94. #define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
  96. // 根据"结构体(type)变量"中的"域成员变量(member)的指针(ptr)"来获取指向整个结构体变量的指针
  97. #define container_of(ptr, type, member) ({          \
  98.           const typeof( ((type *)0)->member ) *__mptr = (ptr);    \
  99.       (type *)( (char *)__mptr - offsetof(type,member) );})
  101. // 遍历双向链表
  102. #define list_for_each(pos, head) \
  103.       for (pos = (head)->next; pos != (head); pos = pos->next)
  105. #define list_for_each_safe(pos, n, head) \
  106.      for (pos = (head)->next, n = pos->next; pos != (head); \
  107.          pos = n, n = pos->next)
  109. #define list_entry(ptr, type, member) \
  110.      container_of(ptr, type, member)
  112. #endif
  115. //双向链表测试代码(test.c)
  116. #include <stdio.h> 
  117. #include <stdlib.h>
  118. #include <string.h>
  119. #include "list.h" 
  121.  struct person 
  122.  { 
  123.      int age; 
  124.      char name[20];
  125.      struct list_head list; 
  126.  };
  128.  void main(int argc, char* argv[]) 
  129.  { 
  130.      struct person *pperson; 
  131.      struct person person_head; 
  132.      struct list_head *pos, *next; 
  133.      int i;
  134.      // 初始化双链表的表头 
  135.      INIT_LIST_HEAD(&person_head.list); 
  137.      // 添加节点
  138.      for (i=0; i<5; i++)
  139.      {
  140.         pperson = (struct person*)malloc(sizeof(struct person));
  141.         pperson->age = (i+1)*10;
  142.         sprintf(pperson->name, "%d", i+1);
  143.          // 将节点链接到链表的末尾 
  144.          // 如果想把节点链接到链表的表头后面，则使用 list_add
  145.          list_add_tail(&(pperson->list), &(person_head.list));
  146.      }
  148.      // 遍历链表
  149.      printf("==== 1st iterator d-link ====\n"); 
  150.      list_for_each(pos, &person_head.list) 
  151.      { 
  152.          pperson = list_entry(pos, struct person, list); 
  153.          printf("name:%-2s, age:%d\n", pperson->name, pperson->age); 
  154.      } 
  156.      // 删除节点age为20的节点
  157.      printf("==== delete node(age:20) ====\n");
  158.      list_for_each_safe(pos, next, &person_head.list)
  159.      {
  160.          pperson = list_entry(pos, struct person, list);
  161.          if(pperson->age == 20)
  162.          {
  163.              list_del_init(pos);
  164.              free(pperson);
  165.          }
  166.      }
  168.      // 再次遍历链表
  169.      printf("==== 2nd iterator d-link ====\n");
  170.      list_for_each(pos, &person_head.list)
  171.      {
  172.          pperson = list_entry(pos, struct person, list);
  173.          printf("name:%-2s, age:%d\n", pperson->name, pperson->age);
  174.      }
  176.      // 释放资源
  177.      list_for_each_safe(pos, next, &person_head.list)
  178.      {
  179.          pperson = list_entry(pos, struct person, list); 
  180.          list_del_init(pos); 
  181.          free(pperson); 
  182.      }      
  183.  }

链表节点定义

首节点：存放第一个有效数据
尾节点：存放最后一个有效数据
头节点：头节点和首节点的数据类型一致，但并不存放有效数据
头节点是首节点前面的那个节点
设置头结点的目的是为了方便对链表操作

头指针：存放头节点的地址

  1. #include<stdio.h>
  2. #include<malloc.h>
  3. #include<stdbool.h>
  6. /**
  7. **链表节点的定义
  8. */
  9. typedef struct Node{
  10.     int data;            //数据域
  11.     struct Node * PNext;//指针域，存放下一个节点的地址
  12. } Node ,*PNode ;
  14. /**
  15. **创建链表
  16. */
  17. PNode create_list()
  18. {
  19.     int len,i;
  20.     printf("请输入链表的长度：len=\n");
  21.     scanf("%d",&len);
  22.     PNode PHead=malloc(sizeof(Node));
  23.     PHead->PNext=NULL;
  24.     PNode PTail=PHead;//PTail是永远指向尾节点的指针
  25.     for(i=0;i<len;i++)
  26.     {
  27.         int val;
  28.         printf("请输入第 %d 个元素的值：", i+1);
  29.         scanf("%d",&val);
  30.         PNode PNew=malloc(sizeof(Node));
  31.         PNew->data=val;
  32.         PNew->PNext=NULL;
  33.         PTail->PNext=PNew;
  34.         PTail=PNew;
  35.     }
  36.     return PHead;
  38. }
  40. /**
  41. **对链表进行遍历
  42. */
  43. void traverse(PNode pHead)
  44. {
  45.    PNode p=pHead->PNext;
  46.    while(p!=NULL)
  47.    {
  48.        printf("%d    ",p->data);
  49.        p=p->PNext;
  50.    }
  51.    printf("\n");
  52. }
  54. /**
  55. *判断链表是否为空
  56. */
  57. bool isempty(PNode pHead)
  58. {
  59.     if(NULL==pHead->PNext)
  60.     {
  61.             return true;
  62.     }else{
  63.     return false;
  64.     }
  65. }
  67. /**
  68. **获取链表的长度
  69. */
  70. int list_num (PNode pHead)
  71. {
  72.   int num=0;
  73.   PNode p=pHead->PNext;
  74.   while(p!=NULL)
  75.   {
  76.       num++;
  77.       p=p->PNext;
  78.   }
  79.   return  num;
  80. }
  82. /**
  83. *向链表中插入元素
  84. */
  85. bool insert_list(PNode pHead,int val ,int pos){
  86. //需要找到第pos个位置，并且需要判断这个位置pos是否合法
  87.  //i是p所指节点的位置，所以从一开始，为什么要pos-
  88. //1呢，因为用的是while 当i=pos-1时跳出循环
  89.  int i=0;
  90.  PNode p=pHead;
  91.  while(NULL!=p&&i<pos-1)
  92.  {
  93.      i++;
  94.      p=p->PNext;
  95.  }
  96. //如果插入位置过大，那么P=NULL,
  97. //如果插入的位置是0或者负数，那么i>pos-1
  98. if(i>pos-1||NULL==p)
  99.  {
  100.      printf("插入位置不合法\n");
  101.      return false;
  102.  }
  103. PNode PNew=malloc(sizeof(PNode));
  104. PNew->data=val;
  105. PNode temp=p->PNext;
  106. p->PNext=PNew;
  107. PNew->PNext=temp;
  108. return true;
  109. }
  111. /**
  112. **在链表中删除节点
  113. */
  114. delete (PNode PHead,int pos , int * pval)
  115. {
  116.     int i=0;
  117.     PNode p=PHead;
  118.     //我们要删除p后面的节点，所以p不能指向最后一个节点 
  119. p->next!=NULL
  120.     while(p->PNext!=NULL&&i<pos-1){
  122.         p=p->PNext;
  123.         i++;
  124.     }
  125.     if(i>pos-1||p->PNext==NULL)
  126.     {
  127.         printf("删除位置不合法\n");
  128.      return false;
  129.     }
  130.    PNode temp=p->PNext;
  131.    p->PNext=temp->PNext;
  132.    free(temp);
  134. }
  135. int main()
  136. {
  138.     PNode PHead = create_list();
  139.     if(isempty(PHead))
  140.     printf("链表为空\n");
  141.     printf("链表的长度为：%d\n",list_num(PHead));
  142.     traverse(PHead);
  143.     //insert_list(PHead,55,1);
  144.     int val;
  145.     delete(PHead,6,&val);
  146.     traverse(PHead);
  147.     return 0;
  148. }

===============================================

  1. #include <stdio.h>
  2. #include <string.h>
  3. #include <stdlib.h>
  4. #include <stdint.h>
  8. typedef struct name {
  9.     char *name;
  10.     struct name *pre;
  11.     struct name *next;
  12. } t_name, *pt_name;
  15. static pt_name g_pt_name_head = NULL;
  18. int32_t add_name(pt_name pt_new)
  19. {
  20.     pt_name pt_cur;    
  22.     if (!g_pt_name_head){
  23.         g_pt_name_head = pt_new;
  24.     } else {
  25.         pt_cur = g_pt_name_head;
  26.         while (pt_cur->next){
  27.             pt_cur = pt_cur->next;
  28.         }
  29.         pt_cur->next = pt_new;
  30.         pt_new->pre = pt_cur;
  31.     }
  32.     return 0;    
  33. }
  35. int32_t add_one_name(void)
  36. {
  37.     pt_name pt_new;
  38.     char *str;
  39.     char name[32];
  41.     printf("enter the name:");
  42.     scanf("%s", name);    
  44.     str = malloc(strlen(name)+1);
  45.     strcpy(str,name);
  47.     pt_new = malloc(sizeof(t_name));
  49.     pt_new->name = str;
  50.     pt_new->pre = NULL;
  51.     pt_new->next = NULL;
  53.     return add_name(pt_new);
  54. }
  56. pt_name find_name(char *name)
  57. {
  58.     pt_name pt_cur;
  60.     if (!g_pt_name_head) 
  61.         return NULL;
  62.     else {
  63.         pt_cur = g_pt_name_head;
  65.         do {
  66.             if (strcmp(pt_cur->name, name) == 0){
  67.                 return pt_cur;
  68.             } else {
  69.                 pt_cur = pt_cur->next;
  70.             }
  71.         } while(pt_cur);
  72.     }
  73.     return NULL;
  74. }
  76. int32_t del_name(pt_name pt_del)
  77. {
  78.     pt_name pt_cur;
  79.     pt_name pt_pre;
  80.     pt_name pt_next;
  82.     if (g_pt_name_head == pt_del) 
  83.         g_pt_name_head = pt_del->next;
  85.         /* 释放 */
  87.     else {
  88.         pt_cur = g_pt_name_head->next;
  89.         while (pt_cur){
  90.             if (pt_cur == pt_del){
  91.                 /* 从链表中删除 */
  92.                 pt_pre = pt_cur->pre;
  93.                 pt_next = pt_cur->next;
  94.                 pt_pre->next = pt_next;
  95.                 if (pt_next){
  96.                     pt_next->pre = pt_pre;
  97.                 }
  98.             } else {
  99.                 pt_cur = pt_cur->next;
  100.             }
  101.         }
  102.     }
  103.     free(pt_del->name);
  104.     free(pt_del);
  106.     return 0;
  107. }
  109. int32_t del_one_name(void)
  110. {
  111.     pt_name pt_find;
  112.     char name[32];
  114.     printf("enter the name:");
  115.     scanf("%s", name);    
  117.     pt_find = find_name(name);
  118.     if(!pt_find) {
  119.         printf("No the name\n\n");
  120.         return -1;
  121.     }
  122.     return del_name(pt_find);
  123. }
  125. int32_t list_all_name(void)
  126. {
  127.     pt_name pt_cur;
  128.     int i = 0;
  129.     pt_cur = g_pt_name_head;
  131.     while (pt_cur){
  132.         i++;
  133.         printf("%02d : %s\r\n", i, pt_cur->name);
  134.         pt_cur = pt_cur->next;
  135.     }
  136.     printf("\n\n");
  137.     return 0;
  138. }
  140. int main(int argc, char **argv)
  141. {
  142.     char ch = ' ';
  144.     while (1) {
  145.         printf("<l> List all names\r\n");
  146.         printf("<a> add one name\r\n");
  147.         printf("<d> del one name\r\n");
  148.         printf("<x> exit\r\n");
  149.         printf("\r\n");
  151.         ch = getchar();
  152.         switch (ch){
  153.             case 'l': 
  154.                 list_all_name();
  155.             break;
  157.             case 'a': 
  158.                 add_one_name();
  159.             break;
  161.             case 'd': 
  162.                 del_one_name();
  163.                 break;
  165.             case 'x': 
  166.                 return 0;
  167.         }
  168.     }
  169.     return 0;
  170. }

结构体初始化

image.png

指针

image.png

浮点数比较

image.png
image.png
image.png
image.png

C-串复制

image.png

斐波那契数列

image.png
image.png