总结一下C语言采坑之路

string.c

  1. #include <stdio.h>
  2. #include <stdlib.h>
  4. /* 将字符串src_拼接到dst_后,将回拼接的串地址 */
  5. char *strcat(char *dst_, const char *src_)
  6. {
  7.     char *str = dst_;
  8.     while (*str++);
  9.     --str; // 别看错了，--str是独立的一句，并不是while的循环体
  11.     while (*src_)
  12.     {
  13.         // 内联汇编和下面C语言代码等价
  14.         asm volatile("movl %0,%%ebx;/* 将src_的内存地址传送到基址寄存器ebx */ \
  15.                       movb (%%ebx),%%al;/* 从基址寄存器ebx为基址寻址，得到src_内存地址处的值，传送到8位通用寄存器al */ \
  16.                       movl %1,%%ebx;/* 将str的内存地址传送到基址寄存器ebx */ \
  17.                       movb %%al,(%%ebx); /* 将8位通用寄存器al存储的值，传送到以基址寄存器ebx为基址寻址，得到str的内存地址处 */"
  18.                      :
  19.                      : "m"(src_), "m"(str)
  20.                      : "memory", "al", "ebx");
  22.         // 与下面代码等价
  24.         // char temp= *src_;
  25.         // *str = temp; // 汇编寻址(*str)传送
  26.         str++;
  27.         src_++;
  28.     }
  29.     return dst_;
  30. }
  32. int main(int argc, char const *argv[])
  33. {
  34.     /* code */
  35.     // 正确用法
  36.     char a[] = "123";
  37.     char b[] = "456";
  38.     char *c[] = {b}; // 指针数组
  39.     printf("c:%s\n", *c);
  40.     // 错误用法
  41.     // char *a = "123";
  42.     // char *b = "456";
  43.     printf("a:%p\n", a); // 字符串与数组本身就是指针(头指针)
  44.     printf("b:%p\n", b);
  45.     strcat(a, b);
  46.     printf("%s\n", a);
  48.     system("pause");
  49.     return 0;
  50. }

bitmap_1.c

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <stdbool.h>
  4. #include <string.h>
  5. //定义每个Byte中有8个Bit位
  6. #include <memory.h>
  7. #define BYTESIZE 8
  8. void SetBit(char *p, int posi)
  9. {
  10.     p = p + (posi / BYTESIZE);
  11.     *p = *p | (0x01 << (posi % BYTESIZE)); //将该Bit位赋值1，或操作会保留，位为1的二进制位
  12.     return;
  13. }
  15. void BitMapSortDemo()
  16. {
  17.     //为了简单起见，我们不考虑负数
  18.     int num[] = {3, 5, 2, 10, 6, 12, 8, 14, 9};
  20.     //BufferLen这个值是根据待排序的数据中最大值确定的
  21.     //待排序中的最大值是14，因此只需要2个Bytes(16个Bit)
  22.     //就可以了。
  23.     const int BufferLen = 2;
  24.     char p[BufferLen];
  25.     char *pBuffer = p;
  27.     //要将所有的Bit位置为0，否则结果不可预知。
  28.     memset(pBuffer, 0, BufferLen);
  29.     for (int i = 0; i < 9; i++)
  30.     {
  31.         //首先将相应Bit位上置为1
  32.         SetBit(pBuffer, num[i]);
  33.     }
  35.     //输出排序结果
  36.     for (int i = 0; i < BufferLen; i++) //每次处理一个字节(Byte)
  37.     {
  38.         for (int j = 0; j < BYTESIZE; j++) //处理该字节中的每个Bit位
  39.         {
  40.             //判断该位上是否是1，进行输出，这里的判断比较笨。
  41.             //首先得到该第j位的掩码（0x01＜＜j），将内存区中的
  42.             //位和此掩码作与操作。最后判断掩码是否和处理后的
  43.             //结果相同
  44.             printf("%c\n", *pBuffer);
  45.             printf("%d\n", (*pBuffer & (0x01 << j)));
  46.             // printf("\n");
  47.             printf("%d\n", (0x01 << j));
  48.             printf("\n");
  49.             if ((*pBuffer & (0x01 << j)) == (0x01 << j))
  50.             {
  51.                 printf("%d ", i * BYTESIZE + j);
  52.             }
  53.         }
  54.         pBuffer++;
  55.     }
  56. }
  58. int main(int argc, char const *argv[])
  59. {
  60.     BitMapSortDemo();
  61.     system("pause");
  62.     return 0;
  63. }

bitmap_2.c

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <stdbool.h>
  4. #include <string.h>
  5. //定义每个Byte中有8个Bit位
  6. #include <memory.h>
  7. #define BYTESIZE 8
  9. #ifndef _LIB_STDINT_H
  10. #define _LIB_STDINT_H
  12. typedef signed char int8_t;
  13. typedef signed short int int16_t;
  14. typedef signed int int32_t;
  15. typedef signed long long int int64_t;
  17. typedef unsigned char uint8_t;
  18. typedef unsigned short int uint16_t;
  19. typedef unsigned int uint32_t;
  20. typedef unsigned long long int uint64_t;
  22. #endif
  24. /*
  25. https://github.com/julycoding/The-Art-Of-Programming-By-July/blob/master/ebook/zh/06.07.md
  26. */
  28. #define BITMAP_MASK 1 // 宏BITMAP_MASK其值为1，用来在位图中逐位判断，主要就是通过按位与‘&’来判断相应位是否为1。
  30. // struct bitmap中只定义了两个成员：位图的指针bits和位图的字节长度btmp_bytes_len。
  31. struct bitmap
  32. {
  33.     uint32_t btmp_bytes_len;
  34.     /* 在遍历位图时,整体上以字节为单位,细节上是以位为单位,所以此处位图的指针必须是单字节 */
  35.     uint8_t *bits; // *指针就是内存地址，这里声明的意思是指针的类型是uint8_t，仍然是内存地址。不同指针类型，在地址处取值时(*指针)的方法和长度不同而已
  36. };
  38. void SetBit(char *p, int posi);
  39. bool bitmap_scan_test(struct bitmap *btmp, uint32_t bit_idx);
  40. void printbit(char *pBuffer);
  41. void BitMapSortDemo(void);
  42. void BitMapSortDemo1(void);
  44. /* 判断bit_idx位是否为1,若为1则返回true，否则返回false */
  45. // bitmap_scan_test函数接受两个参数，分别是位图指针btmp和位索引bit_idx。其功能是判断位图btmp中的第bit_idx位是否为1，若为1，则返回true，否则返回false。
  46. // 如果bit_idx为10的话，byte_idx为1，bit_odd为2，字节索引1中的位1
  47. bool bitmap_scan_test(struct bitmap *btmp, uint32_t bit_idx)
  48. {
  49.     uint32_t byte_idx = bit_idx / 8; // 向下取整用于索引数组下标
  50.     uint32_t bit_odd = bit_idx % 8;  // 取余用于索引数组内的位
  51.     uint8_t *bb = btmp->bits;
  52.     printf("%c\n", *bb);
  53.     uint8_t cc = btmp->bits[byte_idx];
  54.     printf("%c\n", cc);
  55.     int adds = btmp->bits[byte_idx];
  56.     char *dds = (char *)&adds; // 先转成int*，然后转换为char* 指针也有类型，主要是为了从内存中取值用做依据
  57.     printbit(dds);
  58.     uint32_t left = btmp->bits[byte_idx];
  59.     uint32_t right = (BITMAP_MASK << (8 - bit_odd - 1));
  60.     printbit((char *)&left);
  61.     printbit((char *)&right);
  62.     printf("left: %d,right: %d\n", left, right);
  63.     return (left & right);
  64. }
  66. // 打印一字节二进制
  67. void printbit(char *pBuffer)
  68. {
  69.     int res = *pBuffer;
  70.     int count = 7;
  71.     printf("byte:");
  72.     for (int i = 0; i < 8; i++)
  73.     {
  74.         printf("%d", (res & (0x01 << count)) == 0 ? 0 : 1);
  75.         count--;
  76.     }
  77.     printf("\n");
  78. }
  80. void SetBit(char *p, int posi)
  81. {
  82.     p = p + (posi / BYTESIZE);
  83.     *p = *p | (0x01 << (posi % BYTESIZE)); //将该Bit位赋值1，或操作会保留，位为1的二进制位
  84.     return;
  85. }
  87. void BitMapSortDemo(void)
  88. {
  89.     //为了简单起见，我们不考虑负数
  90.     int num[] = {4, 7, 2, 5, 3};
  92.     //BufferLen这个值是根据待排序的数据中最大值确定的
  93.     //待排序中的最大值是14，因此只需要2个Bytes(16个Bit)
  94.     //就可以了。
  95.     const int BufferLen = 1;
  96.     char p[BufferLen];
  97.     char *pBuffer = p;
  99.     //要将所有的Bit位置为0，否则结果不可预知。
  100.     memset(pBuffer, 0, BufferLen);
  101.     for (int i = 0; i < 5; i++)
  102.     {
  103.         //首先将相应Bit位上置为1
  104.         SetBit(pBuffer, num[i]);
  105.     }
  107.     uint8_t *u = (uint8_t *)pBuffer;
  109.     struct bitmap map = {
  110.         1,
  111.         u};
  113.     bool r = bitmap_scan_test(&map, 6);
  114.     printf("%d\n", r);
  115.     // 0b10111100
  116.     // 0b00000001
  118.     //输出排序结果
  119.     for (int i = 0; i < BufferLen; i++) //每次处理一个字节(Byte)
  120.     {
  121.         printbit(pBuffer);
  122.         for (int j = 0; j < BYTESIZE; j++) //处理该字节中的每个Bit位
  123.         {
  124.             //判断该位上是否是1，进行输出，这里的判断比较笨。
  125.             //首先得到该第j位的掩码（0x01＜＜j），将内存区中的
  126.             //位和此掩码作与操作。最后判断掩码是否和处理后的
  127.             //结果相同
  128.             printf("*pBuffer:%c\n", *pBuffer);
  129.             printf("*pBuffer & (0x01 << j):%d\n", (*pBuffer & (0x01 << j)));
  130.             // printf("\n");
  131.             printf("(0x01 << j):%d\n", (0x01 << j));
  132.             printf("\n");
  133.             // 0b00000001 & 0b00000001 == 0b00000001
  135.             //  *pBuffer    0x01 << j     0x01 << j  j
  136.             // 0b10111100 & 0b00000001 == 0b00000001 0
  137.             // 0b10111100 & 0b00000010 == 0b00000010 1
  138.             // 0b10111100 & 0b00000100 == 0b00000100 2
  139.             // 0b10111100 & 0b00001000 == 0b00001000 3
  140.             if ((*pBuffer & (0x01 << j)) == (0x01 << j))
  141.             {
  142.                 printf("%d ", i * BYTESIZE + j);
  143.             }
  144.         }
  145.         pBuffer++;
  146.     }
  147. }
  149. void BitMapSortDemo1(void)
  150. {
  151.     //为了简单起见，我们不考虑负数
  152.     int num[] = {3, 5, 2, 10, 6, 12, 8, 14, 9};
  153.     int len = sizeof(num) / sizeof(num[0]);
  154.     printf("%d", len);
  156.     //BufferLen这个值是根据待排序的数据中最大值确定的
  157.     //待排序中的最大值是14，因此只需要2个Bytes(16个Bit)
  158.     //就可以了。
  159.     const int BufferLen = 2;
  160.     char p[BufferLen];
  161.     char *pBuffer = p;
  163.     //要将所有的Bit位置为0，否则结果不可预知。
  164.     memset(pBuffer, 0, BufferLen);
  165.     for (int i = 0; i < len; i++)
  166.     {
  167.         //首先将相应Bit位上置为1
  168.         SetBit(pBuffer, num[i]);
  169.     }
  171.     // uint8_t *u = (uint8_t *)pBuffer; // 指针也有类型，主要是为了从内存中取值用做依据
  172.     uint8_t *u = (uint8_t *)pBuffer;
  173.     printf("%p\n", u);
  174.     printf("%c\n", *u);
  176.     struct bitmap map = {
  177.         2,
  178.         u};
  180.     bool r = bitmap_scan_test(&map, 11);
  181.     printf("%d\n", r);
  182.     // 0b10111100
  183.     // 0b00000001
  185.     //输出排序结果
  186.     for (int i = 0; i < BufferLen; i++) //每次处理一个字节(Byte)
  187.     {
  188.         printbit(pBuffer);
  189.         for (int j = 0; j < BYTESIZE; j++) //处理该字节中的每个Bit位
  190.         {
  191.             //判断该位上是否是1，进行输出，这里的判断比较笨。
  192.             //首先得到该第j位的掩码（0x01＜＜j），将内存区中的
  193.             //位和此掩码作与操作。最后判断掩码是否和处理后的
  194.             //结果相同
  195.             printf("*pBuffer:%c\n", *pBuffer);
  196.             printf("*pBuffer & (0x01 << j):%d\n", (*pBuffer & (0x01 << j)));
  197.             // printf("\n");
  198.             printf("(0x01 << j):%d\n", (0x01 << j));
  199.             printf("\n");
  200.             // 0b00000001 & 0b00000001 == 0b00000001
  202.             //  *pBuffer    0x01 << j     0x01 << j  j
  203.             // 0b10111100 & 0b00000001 == 0b00000001 0
  204.             // 0b10111100 & 0b00000010 == 0b00000010 1
  205.             // 0b10111100 & 0b00000100 == 0b00000100 2
  206.             // 0b10111100 & 0b00001000 == 0b00001000 3
  207.             if ((*pBuffer & (0x01 << j)) == (0x01 << j))
  208.             {
  209.                 printf("---%d---\n", i * BYTESIZE + j);
  210.             }
  211.         }
  212.         pBuffer++;
  213.     }
  214. }
  216. int main(int argc, char const *argv[])
  217. {
  218.     (void) argc;
  219.     (void) argv;
  220.     // BitMapSortDemo1();
  221.     BitMapSortDemo();
  222.     system("pause");
  223.     return 0;
  224. }

struct.c

  1. #include <stdio.h>
  2. #include <stdlib.h>
  4. #include <memory.h>
  6. struct student generate(char name[], int age, int gender);
  7. void foo(void);
  8. struct student
  9. {
  10.     // 我指定的是32位，而非64位
  11.     char *name;          // name (指针4字节) 存储的是字符串指针也就是字符串的内存地址
  12.     unsigned int age;    // age (unsigned int 4字节)
  13.     unsigned int gender; // gender (unsigned int 4字节)
  14. };                       /*无论如何赋值结构体sizeof都是12字节*/
  16. struct student generate(char name[], int age, int gender)
  17. {
  18.     char *ming = name;
  19.     struct student xiaoming = {
  20.         ming,
  21.         age,
  22.         gender};
  24.     printf("%s %d\n", name, sizeof(xiaoming));
  25.     printf("%d\n", *(unsigned int *)((unsigned int)&xiaoming + 4)); // 骚操作，拆解
  26.     // 目的是取结构体的第二个结构变量
  27.     // 1. &xiaoming 取结构体的指针即内存地址，起始内存地址
  28.     // 2. (unsigned int)&xiaoming 类型转换，方便加步长来寻址，如同汇编
  29.     // 3. (unsigned int)&xiaoming + 4 加上步长来寻址，步长位字节。这里是加上4字节，因为第一个结构体变量长度就是4字节，加上这个长度步长，跳过第一个结构体变量。
  30.     // 4. (unsigned int *)((unsigned int)&xiaoming + 4)) 得到第二个结构体变量内存地址后，类型转换为(unsigned int *)的指针
  31.     // 5. *(unsigned int *)((unsigned int)&xiaoming + 4)) 最后取指针地址，得到第二个结构体变量
  32.     return xiaoming;
  33. }
  35. void foo(void)
  36. {
  37.     // char n[] = "哈哈";
  38.     generate("xiaoming", 16, 1);
  39.     generate("xiaoli", 18, 1);
  40.     generate("hahahahahahhahahahahahahahahahahahahahahhahaha", 20, 1);
  41.     generate("hello my name is xiaoliu", 120, 1);
  42. }
  44. int main(int argc, char const *argv[])
  45. {
  46.     (void)argc;
  47.     (void)argv;
  48.     printf("struct\n");
  49.     foo();
  50.     system("pause");
  51.     return 0;
  52. }

memory.c

  1. #include <stdio.h>
  2. #include <stdlib.h>
  4. #include <memory.h>
  5. #define PSGE_SIZE 4096
  7. struct student
  8. {
  9.     char *name;          // name
  10.     unsigned int age;    // age
  11.     unsigned int gender; // gender
  12. };
  14. void foo(void);
  16. void foo(void)
  17. {
  18.     void *p = malloc(PSGE_SIZE);
  19.     printf("0x%x\n", PSGE_SIZE);
  20.     memset(p, 0, PSGE_SIZE);
  22.     for (int i = 0; i < 13; i++)
  23.     {
  24.         printf("0x%x\n", *(int *)((unsigned int)p + i));
  25.     }
  27.     struct student *s = (struct student *)p;
  29.     printf("%x\n", sizeof(*s));
  30. }
  32. int main(int argc, char const *argv[])
  33. {
  34.     (void)argc;
  35.     (void)argv;
  36.     printf("struct\n");
  37.     foo();
  38.     system("pause");
  39.     return 0;
  40. }