基础知识整理-数据类型和控制语句

• 基本说明

  • 每个程序必须只有一个main函数。
  • 每条语句使用分号’;’作为结束标记。
  • 注释使用/* */
  • #include < x.h > 引入系统头文件,#include “x.h” 引入当前目录下的头文件。
  • 允许一条语句中定义多个同一类型的变量,变量名之间使用逗号分隔’,’。
  • 变量要遵循先定义，后使用的原则。

• 标识符规则

  变量,方法名都属于标识符，必须以数字，英文字母，下划线组成，并且不能以数字开头。

• 数据类型

  • 整型

    分为十进制，八进制(0开头)，十六进制(0x开头)。示例如下:

    
    #十进制
    
    123 = 1*10^2 + 2*10^1 + 3*10^0
    
    #八进制
    
    0123 = 1*8^2 + 2*8^1 + 3*8^0
    
    #十六进制
    
    0x123 = 1*16^2 + 2*16^2 + 3*16^0

    • (无符号)短整型:(unsigned) short int
    • (无符号)整型:(unsigned) int
    • (无符号)长整型：(unsigned)long int

  • 浮点型

    • 单精度浮点：float
    • 双精度浮点: double

    对浮点型的变量进行”相等”判断时，正确的方式应该是计算两值得差值，当差值在一定的精度范围内，认为两数是相等的。因为在计算机内部浮点数实际存储的只是”近似值”。

  • 字符型

    • 单字符：char(unsigned char)，只能存放一个字符,例：’A’

      char变量实际保存的字符的ascii码值，减运算”-“操作得到的是对应ascii码值得差值。并且char可以转换成int类型，转换后的int类型的值就是char变量对应的ascii码值。

    • 字符串: “ABC”

      字符串常量返回的是指针(内存地址)。

  • 指针

    用于保存变量的内存地址，声明和使用方式如下：

    /*指针声明方式：基础类型 *变量名 = &变量名*/
    int m = 5;
    /*声明指针类型p同时将变量m的地址赋值给p*/
    int *p = &m;
    
    /*根据指针获取对应变量的值:*指针变量*/
    printf("%d\n",*p);

    指针在声明时要么初始化为null，要么初始化为变量的地址。指针变量的类型由其指向的变量的类型决定，这是因为指针变量除了记录变量的地址外，还需要记录变量的内存地址大小，这样在对指针变量进行加减运算的时候才能准确的知道应该前进或者后退多少字节。示例：

    char c[5] = "hello";
    int m[5] = {1,2,3,4,5};
    
    /*字符型指针*/
    char *cp = c;
    
    /*整型指针*/
    int *ip = m;
    
    /*输出结果为：h*/
    putchar(*cp);
    putchar('\n');
    /*将cp++，实际为将cp指向的地址向后移动1个字节(char占1byte)，将地址指向数组的第二个元素*/
    cp++;
    /*移动后输出结果为：e*/
    putchar(*cp);
    putchar('\n');
    printf("%s\n","---------");
    
    /*输出结果为：1*/
    printf("%d\n",*ip);
    /*由于指针类型为整型（占4byte）,ip++是将地址向后移动4个直接指向数组的第二个元素*/
    ip++;
    /*输出结果为:2*/
    printf("%d\n",*ip);

  • 复合类型

    • 结构体

      将多个类型的变量组合成一个新的数据类型。允许用户自定义新的数据类型,新类型所占的内存大小为结构体中使用的变量的内存总和。示例如下：

          struct People
          {
              char name[5];
              int age;
          };
      
      
          /*定义People变量类型*/
          struct People p;
          strcpy(p.name,"wang");
          p.age = 20;
      
          printf("name:%s\n",p.name);
          printf("age:%d\n",p.age);
      
          /*输出结果为*/
          name:wang
          age:20

    • 共用体

      将多个类型的变量组合成一个新的数据类型，但是与结构体不同的是，新的数据类型所占的内存大小为共用体中所占内存最大的变量的内存大小。示例如下：

      /*
       * char占1byte,int占4byte
       * 所以共用体所占内存为4byte
      */
      union val
      {
         char c;
         int age;
      };
      
      /*用法和结构体类似，只不过union中的变量只能互斥使用*/
      union val v;
      v.c = 'A';
      putchar(v.c);
      putchar('\n');
      printf("byte:%d\n",sizeof(v));
      
      v.age = 20;
      printf("age:%d\n",v.age);
      printf("byte:%d\n",sizeof(v));

• 运算符

  • 算术运算符(+,-,*,/,%,++,–)

    当多种类型变量进行混合运算时，会先将变量转换成同一类型然后再进行运算，转换的规则为char/short->int->float->double。

    /* %:取余数运算 */
    int m = 4%5;
    printf("m:%d\n",m);//4
    
    /*
     * /:整除运算
     * 如果操作数有浮点类型，则结果为浮点类型；
     * 如果操作数都为整型，则结果为整型。
    */
    int m = 4/5;//m=0
    float n = 4.0/5;//n=0.800000

  • 强制类型转换：()

    /*将int类型强制转换成double类型*/
    int i = 5;
    double d = (double)i;//此时i的类型仍然为int

  • 自增和自减运算

    /*自增运算*/
    int m = 5;
    /*
     * ++在后
     * 先将m的值复制给n，然后再将m的值增加1
     * 表达式执行后n=5;m=6
    */
    int n = m++;
    
    /*
     * ++在前
     * 先将m的值增加1，然后再将m的值复制给x。
     * 表达式执行后x=7;m=7
    */
    int x = ++m;

  • 赋值表达式和赋值运算符

    ‘=’ 作为赋值运算符时，表示的是将’=’右边的变量的值赋值给左边的变量。当作为赋值表达式时，将’=’右边的变量的值赋值给左边的变量，此时左边变量的值作为表达式的值返回。

    /*
     * 作为赋值运算符
     * 将5赋值给整型变量m
    */
    int m = 5;
    
    /*
     * 作为赋值表达式
     * 此时f=5表达式的值为5,即为真，所以会执行语句1
    */
    if(f=5)
    {
        //语句1
    } else {
        //语句2
    }

  • 逗号表达式

    使用逗号’,’将多个表达式组合成一个新的表达式，表达式形式为:

    表达式1,表达式2,...,表达式n

    分别计算表达式1,表达式2一直到表达式n的值，并将表达式n的值作为整个表达式的值。

• 控制结构

  • 顺序结构

    C语言中最基本的控制结构：有多条语句组成，按照语句的顺序次序执行。示例如下:

    /*按照语句1->语句2的次序执行*/
    语句1;
    语句2;

  • 选择结构

    根据逻辑表达式的结果选择一条分支语句执行；控制语句包括:if/else;switch。使用方式如下：

    /*
     * 当表达式为true时执行语句块1
     * 当表达式为false时执行语句块2
    */
    if(表达式)
    {
        语句块1;
    } else {
        语句块2;
    }
    
    /*
     * 当表达式1为true时执行语句块1，
     * 为false时再判断表达式2，如果所有的表达式都为false时执行else的语句块。
     * 
    */
    if(表达式1)
    {
        语句块1;
    } 
    else if(表达式2)
    {
        语句块2;
    }
    else
    {
        语句块3;
    }
    
    
    /*
     * var表达式的值必须为整型。
     * 当var值为m时执行语句块1;
     * 当var值为n时执行语句块2；
     * 所有case后面的值都不满足时，执行default后面的语句块，如果没有default语句块，则表示没有满足条件的可执行语句块。
    */
    switch(var)
    {
        case m:
            语句块1;
            break;
        case n:
            语句块2;
            break;
        default:
            语句块3;
            break;
    }
    
    /*
     * 如果多个分支条件执行相同的语句块时可以写成这种形式(类似于if/else if)
    */
    switch(var)
    {
        case m:
        case n:
            语句块;
            break;
        deafult:
            语句块;
            break;
    }

  • 循环结构

    当条件满足时，重复执行同一个语句块。控制语句包括:for;while;do while,使用方式如下:

    
    /*
     * for循环
     * 执行流程为：
     * 1：执行表达式1,只执行一次，一般会作为变量赋值的操作，也可以是空语句；
     * 2: 判断表达式2(一般为逻辑表达式)的值,为true时执行语句块，否则结束循环;
     * 3：执行表达式3;
     * 重复执行2,3步骤直到2中表达式值为false，则结束循环。
    */
    int i;
    for(表达式1;表达式2;表达式3)
    {
        语句块;
    }
    
    
    /*
     * while循环：先判断表达式的值再执行语句块。如果表达式值为false时,语句块一次也不会执行。
     * 执行流程:
     * 重复判断表达式值,为true时执行语句块代码，否则时结束循环。
    */
    while(表达式)
    {
        语句块;
    }
    
    /*
     * do while循环:先执行语句块再判断表达式值。无论表达式值是否为true,语句块至少会执行一次。
     * 执行流程:
     * 执行语句块，然后判断表达式值，如果为true则继续执行语句块，否则结束循环。
    */
    do
    {
        语句块;
    }
    while(表达式);
    

    break和continue可以用来控制循环的执行流程。break表示跳出当前循环，执行紧跟当前循环语句块后面的代码;continue表示停止当前循环的执行，跳转至下一次循环的开始。