自学嵌入式第十七天：共用体和位运算

qsort()  

void qsort(
           void *base,    //要排序的数组的首地址 
           size_t nmemb,  //数组元素的个数 
           size_t size,   //单个元素的大小 
           int (*compar)(const void *, const void *) //比较函数 --- 提供比较依据
           );
功能:
    排序数组 
    
    
    int compar(const void *a, const void *b) 
    {  //比较函数 
       //形参 a 和 b 用来接收 要比较的两个数组元素 
       
    }
    for ()
    {
         for ()
         {
         
            if (compar(a[i],a[j]) //)
         }
    }

    //----------------------------------------------------------------------------
    
 
    int n;
    switch (n)
    {
       case 1:  
             //1 录入学生信息 
             break;
        ....     
    }
总结:
1.理解结构体概念及用途 
2.使用方法 
  a.自己构造出这个结构体类型
  b.有了类型
    定义变量
    定义数组
    定义指针
    做函数形参   //结构体类型指针 
    做函数返回值
3.考点 
  结构体类型的大小计算 
  1. 内存对齐 
  2. 为什么要内存对齐 
-------------------------------------------------
共用体:
   union  //
   
语法:
  union 共用体名
  {
     成员变量;
  };
   
   
eg:
  union demo
  {
     char a;
     short b;
     int c;
  };
  
  共用体:
       共用了一块内存空间 
       公用了最大成员的空间 
       
  注意:
  1.共用体初始化时，只能给一个值，默认时给到第一个成员的。
  2.共用体变量中的值，取决与最后一次给到的值，还要看能影响几个字节。
  
  对比 结构体
  1.结构体中各个成员 拥有自己独立空间
  2.共用体中，成员共用一块空间
  
  
  
  struct stu
  {
     ...
     float score;
  };
  
  struct teacher
  {
     ...
     float salary;
  };
  
  struct member
  {
     int no; 
     char name[]
     ...
     union
     {
       float score;
       float salary;       
     }d;
     
  };
  
  


枚举:
     枚举    //一个一个列举出来  
     "枚举" 是指将变量的值一一列举出来，变量的值只限于列举出来的值的范围内。
    
作用:
    1.为了提高代码可读性 
    2.提高代码的安全性 
    
    

    小火
    中火 
    大火 
    #define LITTLE_FIRE  1 
    #define MIDDILE_FIRE 2 
    #define LARGE_FIRE   3
    
    main()
    {
       //
       int n;
       scanf("%d",&n);
       switch(n)
       {
          //case 1:
          case LITTLE_FIRE: 
              printf("---little fire!---\n");
              break;
         // case 2:
         case MIDDILE_FIRE: 
              printf("---middile fire!---\n"); 
              break; 
         //case 3:
         case LARGE_FIRE:
              printf("---large fire!---\n"); 
              break;
        
       }
    }
    
    
    枚举类型:  //
    
    enum 枚举名
    {
       列举各种值  //枚举元素//枚举常量
    };
    
    注意:
        列举各种值，之间用逗号隔开，不需要写类型名 
    
    eg:
    enum fire 
    {
      LITTLE_FIRE,
      MIDDILE_FIRE, 
      LARGE_FIRE, 
    }; 
     
    
    注:
    1. 表示 定义了一种 枚举类型 
    2. 枚举中逐个列举的值，默认是从0开始  
       如果有给定的值，则后续没有给值的 枚举元素 依次 加1 
    3. 枚举类型的 本质 实际是一个int类型的数据 
    4. 枚举类型的变量 与 整型类型的变量通用的 
    5. 与 宏定义对比  
       区别:
           使用阶段不同 --- 宏定义 --- 预处理阶段 
                            枚举   --- 编译阶段 要检查语法 
                                       运行阶段 参与代码运行 
           可读性 
                 都提高了可读性 
                 枚举，更能说明有相关性的一些值间关系 
                 
 

   typedef  //type define  
            //本意 不是定义类型 
            //给类型起别名 
            
   
   int a; //定义了一个int型变量a 
   
   typedef int a; // 此时 a是 int类型的一个别名 
   
   
   
   struct stu 
   {
      
   };
   
   
   struct stu s;
   
   typedef struct stu stu_t; 
   
   
   stu_t s1; //
   
   //---------------------------------------- 
    typedef void (*sighandler_t)(int);
    //sighandler_t ==>void (*)(int)
    sighandler_t signal(int signum, sighandler_t handler);

    void (*)(int) signal(int signum, void (*)(int) handler);  
   void (*signal(int signum, void (*handler)(int) ))(int) ;
   
 ------------------------------------------------------------
 位运算:  //c语言特点 
       可以直接操作二进制位 
       
     
     
&  与运算  --- 位运算中    //清0  
   运算规则:
      一假则假    
  eg:
      0xaa 
      1010 1010 
      0011 0011 &
      ---------
      0010 0010 0x22 
|  或运算                 //置1 
    运算规则:
      一真则真 
         
   
      1010 1010   // 0xaa 
      0011 0011 & // 0x33 
      ---------
      1011 1011  //0xbb 
~ 取反
   运算规则:
     真假相对 
     
   ~0xaa 
     1010 1010   // 0xaa 
     0101 0101   //0x55
     
^ 异或 
  运算规则:
  相同为 0
  不同为 1 
  1010 1010   // 0xaa 
  0011 0011 ^ // 0x33 
  ---------
  1001 1001 //0x99
  
  
  加密 
  交换 
  
  
  
  int t;
  t = a;
  a = b;
  b = t;
  
  a = a + b; // 
  b = a - b; //b = a
  a = a - b; //
  
  a = a ^ b;
  b = a ^ b;
  a = a ^ b;
  
  
注意:
   1.浮点数不能做位运算
 
<<  左移 

写法:
  a<<n  //表示将 a这个数据 左移 n位 
        
        0000 0001 
        左移1位  相当于乘 2 
        0000 0001 
        0000 0010
        注:
           最低位 补0 
  
>>  右移
  
  a>>n   //表示将 a这个数据 右移 n位 
          0000 0001 
        右移1位  相当于除 2    
  1000     
  1100    
  
  算术右移 
          //看符号位 看数据类型 
          如果是有符号类型的数据，右移时，最高位补的是符号位 
         
           如果是无符号类型的数据，右移时，最高位补的0 
          
       

函数指针 指向函数类型的指针  //基类型为函数类型的指针 
指针函数 返回值为指针类型的函数    
  char *strcpy(char *dest,const char *src);
 
堆上的空间: 
   void *malloc(size_t size); 
   功能: 
       在堆上开辟一块空间 
   参数:
       size //表示申请的空间的大小，单位字节 
  返回值:
      成功 返回 申请到内存空间的地址
      失败 返回 NULL
   
   //释放函数 
   void free(void *ptr);
   释放之前申请的堆上的空间 
   参数:
       ptr 一定是之前申请到堆上空间的地址 
     
     free释放后的空间 
     1.一般不再使用 
     2.指向这块空间的指针 --- 是个野指针 
     3.free之后对应空间上的内容 ---也不要使用 
     
  注意:
     1. 成对出现 
     2. free只是释放了空间 --- 表示这块空间 又自由了 
        但是 这块空间上的数据 并不会清零
     3. 不要多次free