Linux C语言学习笔记

1、int    4字节
   long   8字节
   float  4字节
   double 8字节
   long double 16字节

2、一个字符变量只能存放一个字符、一个字节存放一个字节
   char c;
   c = 'a';    c = '/034'    c = '/n'
   c = '/x65'    c = 65        c = 0101
   c = 0x41

3、运算符操作
   -i++等价于-(i++)

   i = 2;
   j = -i++;
   运算结果i=3 j=-2

4、优先级
  !逻辑非 > 算术运算符 > 关系运算符 > &&逻辑与 > ||逻辑或
  a = 0; b = 1; c = 2; d = a++&&b++&&--c
  等价于
  a = 0; b = 1; c = 2; d = (a++) && (b++) && (--c)
  结果为
  a = 1; b = 1; c = 2; d = 0;

  a = 0; b = 1; c = 2; d = a++||b++||--c;
  等价于
  a = 0; b = 1; c = 2; d = (a++) || (b++) || (--c);
  结果为
  a = 1; b = 2; c = 2; d = 1;

5、复合赋值运算符
  a += b  相当于 a = a + b;
  a *= b + c 相当于 a = a * (b + c);
  a = 2; a += a *= a; 等价于 a += (a *= a); 最后a = 8；

  a = 5; b = 3;
  int max = --a == b++ ? a++ : b++;
  最后max = 4;

6、强制类型转换
  int a = 2;
  int b = 5;
  (float)b/a等于2.5
  (float)(b/a)等于2.0

7、字符串拷贝函数
   char *strcpy(char *dest, const char *src);
   函数功能：将字符串src复制到字符数组dest中，返回复制的字符串。
   src可以是字符数组名、常量或字符指针变量。
   dest可以是字符数组名或字符指针变量。若dest是字符指针变量，要注意给该指针变量赋初值。

   函数说明：
       字符数组1长度应大于等于字符串或字符数组2的长度；
       字符数组1应该写成数组名的形式

   例如：
   static char a[10] = "abcdefghi";
   char b[] = "happy";
   strcpy(a, b);
   printf("%s/n", a);
   结果为：happy

8、字符串连接函数
   函数原型：
   char *strcat(char *dest, const char *src);

   函数功能：
   删去字符串dest的结束标志'/0'，将字符串或字符数组src连同末尾的结束标志一起连接到
   字符数组dest尾部，返回连接以后的字符串。

   例如:
   static char a[20] = "My name is ";
   static char b[10] = "Li Ming";
   strcat(a, b);

9、计算字符串长度的函数
   函数原型：
   unsigned int strlen(const char *str);

   函数功能：
   求出字符串或字符数组中实际字符个数（不包括'/0'）

   实例：
   static char st[20] = {"hello/0abc/0abc/0"};
   print("%d/n", strlen(st));
   结果：5

10、字符串比较函数
   函数原型：
   int strcmp(const char *s1, const char *s2);

   函数功能：
   从左到右逐个比较两个字符串s1、s2中各个字符（用字符的ASCII比较），
   直到出现不同字符或遇到结束标记为止。

   函数返回值：
   0       当串1=串2
   负整数  当串1<串2
   正整数  当串1>串2

11、变量的存储特性
   1、变量按存在时间分：静态变量，动态变量
    静态存储变量：生命期为程序执行的整个过程，在该过程中占有固定的存储空间，也称永久存储
    动态存储变量：只生存在某一段时间内。
    例如：函数的形参、函数体或分程序中定义的变量，只有当程序进入该函数或分程序
          时菜分配存储空间，函数/分程序执行完后，变量的存储空间有被释放。

    2、自动型 auto
        有形式参数、函数内变量、分程序变量。
    进入程序自动分配内存，不长期占用内存。

    3、静态型 static
    局部静态变量 全局静态变量 都长期占有内存

    4、寄存器类型 register
        将使用频率高的变量定义为register型，可以提高运行速度。
        寄存器变量只限于整型、字符型、指针型的局部变量。
    寄存器变量是动态变量，仅允许说明两个寄存器变量。
    例如：
        register int d;
        register char c;

    5、引用型 extern
        如果某个模块文件中要用到另一个模块文件中的全局变量，要用extern说明。
    定义时分配内存，其他文件引用时不再分配内存。
    例如：
        程序模块file1.c中定义了全局变量
        int s;
        另一程序file2.c的函数fun1()需要使用这个变量s。
        在file2.c的fun1()对s进行外部变量说明：
        fun1()
        {
            extern int s; /*表明变量s是在其他文件定义的*/
            .....
        }

12、文件包含预处理（#include）
    #include <文件名>
        包含标准头文件(/usr/include下的)
    #include "文件名"
        包含自定义的头文件（在当前目录）

13、指针
    概念：一个变量的地址称为该变量的指针
        指针变量：专门用于存储其它变量地址的变量
    指针变量三要素：
        指针变量的类型：和其所指变量的类型一致。
          指针变量的值：另一个变量在内存的地址。
        指针变量的名字：起法同普通变量一样。

    int* p1, p2;其中p1是指针而p2不是指针是一般的整形变量

    两个运算符
    *：求其后内存地址中的内容。
    &：求变量的内存地址。
   
    例：
    1、若已经执行了"pointer_1 = &a"，则：
    "&*point_1"的含义是什么？
    答：相当于&a
    (*point_1)++相当于a++

    2、*&a的含义是什么？
    答：a

    指针的指针：指向指针变量的指针。
    定义形式：类型 **变量名；
    例如：  int i, *p, **q;
            i = 30;
        p = &i;
        q = &p;
        printf("%d, %d, %d/n", i, *p, **q);
    输出的结果式样的。

    #include <stdio.h>

    int main()
    {

            int a, b;
            int  *p1, *p2;
            void swap(int *pa, int *pb);

            scanf("%d%d", &a, &b);
            p1 = &a;
            p2 = &b;
            if (a < b)
            {
                       swap(p1, p2);
            }

            printf("/n%d, %d/n", a, b);

            return 0;
    }

    void swap(pa, pb)
    int *pa, *pb;
    {
              int *p;
            p = pa;
            pa = pb;
            pb = p;
    }

    指针函数
        返回值是指针类型的函数，称为指针函数。 
        例如：
        int *a(int x, float y) {...}

    指向函数的指针
       1、函数名代表函数的入口地址
       2、指向函数的指针的定义方式：
         类型 (*指针变量名)();
        例如：int (*p)()
              int max(...) {...}
              p = max;

    #include <stdio.h>

    int main()
    {
            int max();
            int (*p)();
            int a, b, c;

            p = max;
            scanf("%d%d", &a, &b);
            c = (*p)(a, b);
            printf("a = %d, b = %d, max = %d/n", a, b, c);

            return 0;
    }

    int max(a, b)
    int a, b;
    {
            return a > b ? a : b;
    }

    指针与数组
    指向一维数组的指针：int *p; int a[10]; p = a; 数组名的含义：就是数组的首地址

    若有数组及指针定义
    int a[5], *p = a;
    下标法：a[0]  a[1]  a[2]  a[3]  a[4] 
    指针法：*p   *(p+1)  *(p+2)  *(p+3)  *(p+4)
        p[0]  p[1]   p[2]    p[3]    p[4]
        *a    *(a+1) *(a+2)  *(a+3)  *(a+4)

    注意事项：
    例如有定义：int a[10], *p; p = a;
            p++;合法，但a++不合法（a是数组名，代表数组首地址，是常数地址。）
            要注意指针变量的当前值。

    注意指针变量的有关运算
        一下结论都在使指针指向数组a，即有p = a;前提下得出
        p++; (或p += 1) p将指向下一元素，即a[1]。
       
        x = *p++;
        *与++是同级运算符，等价于先计算*p，为x赋值a[0]；p再自增1，新的p指向a[1]。
        *(p++)是先取*p的值，后使p加1.
        *(++p)是先使p加1，后取*p的值。
        (*p)++表示p所指向的元素值加1（即a[0]++），而不是指针值p加1。

14、共用体
    概念：使几个不同的变量占用同一段内存空间的结构称为共用体。
    共用体类型的定义：
        union 共用体类型名
        {成员列表;};
    *共用体变量占用的内存空间，等于最长成员的长度，而不是个成员长度之和。

    特点：
    1、系统采用覆盖技术，实现共用变量各成员的内存共享，所以在某一时刻，
       存放的和起作用的是最后一次存放的成员值
        例如:执行un1.i = 1;un1.ch = 'c', un1.f = 3.14后，uni,f才是有效的成员。

    2、由于所有成员共享同一内存空间，故共用变量与其各成员的地址相同。
        例如：&un1 = &un1.i = &un1.ch = &un1.f
   
    3、不能对共用变量进行初始化；也不能将共用变量作为函数参数，以及使函数返回一个
       共用数据，但可以使用指向共用变量的指针。

    4、共用类型可以出现在结构类型定义中，反之亦然。

15、枚举型
    定义：enum 枚举类型名 {取值表};
          例如：enum weekdays {sun, mon, tue, wed, thu, fri, sat};
          变量定义：
            enum weekdays workday;
            enum weekdays {sun, mon, tue, wed, thu, fri, sat} workday;

    枚举元素作为常量是有值的：定义时的顺序号（从0开始），所以枚举元素可以进行比较，
    比较规则是：序号大者为大。sun = 0; mon = 1;....sat = 6,所以mon > sun、sat最大。

    枚举元素的值也是可以认为改变的：定义时由程序制定。
        例如：
        enum weekdays {sun = 7, mon = 1, tue, wed, thu, fri, sat};
        则sun = 7，mon = 1，从tue = 2开始，依次增1.

16、typedef与#define有相似之处，但二者是不同的：前者是由编译器在编译时处理的；后者是由
    编译预处理时处理的，而且只能作简单的字符串替换。

17、位段结构
    有时，存储1各信息不必占用1个字节，只需二进制的1个或多个位就够用。
    如果仍然使用结构类型，则造成内存空间的浪费。为此，c语言引入了位段类型。
   
    位段的概念与定义
    所谓位段类型，是一种特殊的结构类型，其所有成员均以二进制为单位定义长度，并称成员为位段。
    例如：cpu的状态寄存器，按位段类型定义如下：
    struct status
    {
        unsigned sign:         1; /*符号标志*/
        unsigned zero:       1; /*零标志*/
        unsigned carry:      1; /*进位标志*/
        unsigned parity:     1; /*奇偶/溢出标志*/
        unsigned half_carry: 1; /*半进位标志*/
        unsigned negative:   1; /*减标志*/
    }flags;