二：数据类型和变量

1.数据类型的介绍：

​ 内置数据类型（C语言本身具有的）：字符 - char；整型 - int；浮点型 - float；布尔类型 - _Bool

​ 自定义数据类型（自己创建的类型）：数组；结构体 - struct；枚举 - enum；联合体 - union

（1）字符类型：字符类型分为三类

1. char //字符类型
2. signed char //有符号的字符类型
3. unsigned char //无符号的字符类型

（2）整型：整型分为四大类

//整型
1. int //整数类型
2. [signed] int //有符号的整型
3. unsigned [int] //无符号的整型
//短整型
1. short [int] //短整型
2. [signed] short [int] //有符号的短整型
3. unsigned short [int] //无符号的短整型
//长整型
1. long [int] //长整型
2. [signed] long [int] //有符号的长整型
3. [unsigned] long [int] //无符号的长整型
//更长的整型
1. long long [int] //长长整型
2. [signed] long long [int] //有符号的长长整型
3. unsigned long long [int] //无符号的长长整型

​ 注意：以上用 [ ] 包裹的内容，在编写代码时都可以省略不写

（3）浮点型（小数）：浮点型分为三类

1. float //单精度浮点型
2. double //双精度浮点型（精度比较高）
3. long double //精度更高的浮点型

（4）布尔类型：在C语言最开始的时候，用0来表示假，而非0则表示真，后来在 C99 标准中引入了布尔类型

​ 在使用布尔类型时还要包含头文件 <stdbool.h>

​ 布尔类型变量的取值只有两种：true或者false

1. _Bool //布尔类型

#include <stdio.h>
#include <stdbool.h>
int main()
{
   
    _Bool flag = true;
    if(flag)
        printf("I Like You\n");
    return 0;
}

2.signed 和 unsigned：

• ​ 在C语言中，signed 和 unsigned 两个关键字是用来修饰字符型和整型的
• ​ signed 关键字，表示一个类型带有正负号，包含负值
• ​ unsigned 关键字，表示该类型不带有正负号，只能表示0和正整数
• ​ 对于 int 类型，默认是带正负号的，也就是 int 等同于 signed int，所以 signed 可以省略不写

int main()
{
   
    signed int temperature1 = 30; //temperature表示温度，而温度会有负数的可能性，所以用signed修饰
    signed int temperature2 = -30;
    unsigned int age = 20; //age表示年龄，而年龄未来只有正数的可能性，所以用unsigned去修饰
    return 0；
}

​ 注意： 当表示非负整数时，这时必须使用 unsigned 去声明变量

​ 整数变量声明为 unsigned 的好处是，同样长度的内存能够表示最大的整数值增大了一倍

​ 整数类型的取值范围可以参考 limits.h 中给出的定义

//字符类型的取值范围
1. signed char a; //取值范围为 -128~127
2. unsigned char a; //取值范围为 0~255

​ 注意： C语言规定 char 类型是否带有正负号，由当前系统决定，也就是说 char 不等同于 signed char，它有可能是 signed char，也有可能是 unsigned char；这一点与 int 不同

3.数据类型的取值范围：

​ 每一种数据类型都有自己的取值范围，也就是存储数值的最大和最小值的区间

查看当前的系统上不同数据类型的取值：

​ limits.h 这个头文件中说明了整数类型的取值范围

​ float.h 这个头文件中说明了浮点类型的取值范围

​ 为了代码的可移植性，当需要知道某种数据类型的极限值时，尽量使用这些常量：

​ 注意： 在使用这些常量时记得包含头文件

操作符 sizeof()：计算的是类型创建的变量所占内存的大小，单位是字节

​ size_t 是专门为 sizeof() 设置的一个类型，size_t 的本质是 unsigned int

​ 注意： size_t 类型的数据在打印的时候格式应该使用 %zd

int main()
{
   
    printf("%zd\n",sizeof(char));
    printf("%zd\n",sizeof(short));
    printf("%zd\n",sizeof(int));
    printf("%zd\n",sizeof(long long));
    printf("%zd\n",sizeof(float));
    printf("%zd\n",sizeof(double));
    return 0;
}
//C语言标准规定：sizeof(long) >= sizeof(int)

注意：计算机中常见的单位：（由小到大排序）

​ bit -- 比特位 -- 当存储一个二进制位（1或0）的时候所需要的空间就是一个比特位

​ Byte -- 字节 -- 1Byte == 8bit

​ KB -- 1KB == 1024Byte

​ MB -- 1MB == 1024KB

​ GB -- 1GB == 1024MB

​ TB -- 1TB == 1024GB

​ PB -- 1PB == 1024TB

4.变量：

（1）变量的创建

​ C语言中把经常变化的值称为变量，不变的值称为常量，类型就是用来创建变量的

创建变量的语法格式：数据类型 变量名;

​ date_type name;

//变量的创建
#include <stdio.h>
int main()
{
   
    int age; //整型变量
    char str; //字符变量
    float heigh; //浮点型变量
    return 0;
}

​ 变量在创建的时候给一个初始值，就叫初始化

//变量的初始化
#include <stdio.h>
int main()
{
   
    int age = 18;
    char str = "你猜";
    float heigh = 3.14159; //编译器会自动把它识别成double类型的数字，容易出现警告
    float heigh = 3.14159f; //此时在值的后面加上一个f，编译器会自动把它识别成float类型的数字
    return 0;
}

（2）变量的分类

​ 全局变量：在大括号外部定义的变量就是全局变量，全局变量的使用范围广，在整个工程中想使用，都是有办法使用的

​ 局部变量：在大括号内部定义的变量就是局部变量，局部变量的使用范围比较局限，只能在自己所在的局部范围内使用

#include <stdio.h>
float a = 3.1234f; //全局变量，这个a可以在整个项目工程中使用
int main()
{
   
    int b = 10; //局部变量，这个b仅限于main()函数内部使用
    {
   
        char c = "你猜" //这个c仅限于这个小括号中使用
    }
    return 0;
}

​ 注意： 当全局变量与局部变量重名时，局部变量会优先使用

注意：

1.局部变量是放在内存的栈区

2.全局变量是放在内存的静态区

3.堆区是用来动态内存管理的

5.算术操作符：

​ 算术操作符，因为其操作符的左右两端都各有一个操作数，所以也叫做双目操作符，操作符也叫运算符

（1）加法 + 和减法 -

#include <stdio.h>
int main()
{
   
    int a = 34 + 78;
    float b = 45.7 - 30.3;
    int c = a + b; //变量之间也可以相加减
    printf("%d\n",a);
    printf("%d\n",b);
    printf("%d\n",c);
    reyurn 0;
}

（2）乘法 *

#include <stdio.h>
int main()
{
   
    int a = 23 * 78;
    printf("%d\n",a);
    return 0;
}

（3）除法（整数除法，只要整数不要余数) /

#include <stdio.h>
int main()
{
   
    int a = 7 / 2; //结果为3
    printf("%d\n",a);
    return 0;
}

注意：

除号两端如果都是整数，则执行整数除法，得到的结果也是整数，舍弃余数

除号两端只要有浮点数，此时则执行浮点数除法

#include <stdio.h>
int main()
{
   
    int a = 7.0f / 2;
    printf("%d\n",a);
    return 0;
}

（4）取模 %

#include <stdio.h>
int main()
{
   
    int a = 23 % 78;
    printf("%d\n",a);`
    return 0;
}

注意：

取模返回的是两个整数相除的余数，且取模只能用于整数，不能用于浮点数

当进行负数取模时，结果的正负号由第一个操作数的正负号决定

#include <stdio.h>
int main()
{
   
    int a = -23 % 78; //此时结果是负数
    int b = 8 % -2; //此时结果是正数
    printf("%d\n",a);
    printf("%d\n",b);
    return 0;
}

6.赋值操作符：

​ 在变量创建时，给一个值叫做初始化；在变量创建好后，再给一个值，这叫赋值，赋值符号：=

#include <stdio.h>
int main()
{
   
    int a = 20; //初始化
    a = 40; //赋值
    return 0;
}

（1）连续赋值：

#include <stdio.h>
int main()
{
   
    int a = 20; //初始化
    int b = 40;
    int c = 78;
    c = b = c + a + 4; //连续赋值，从右到左依次赋值
    printf("%d\n",c);
    return 0;
}

（2）复合赋值（自增；自减）：

#include <stdio.h>
int main()
{
   
    int a = 20; //初始化
    a = a + 3; //可以将其替换成 a += 3;
    a = a - 4; //可以将其替换成 a -= 2;
    printf("%d\n",a);
    return 0;
}

7.单目操作符：

​ 在C语言中一些操作符只有一个操作数，而这些操作符被称为单目操作符

（1）++和--

​ ++是一种自增1的操作符，又分为前置++和后置++

​ --是一种自减的1操作符，又分为前置--和后置--

//前置++或--：先++或--，后使用
#include <stdio.h>
int main()
{
   
    int a = 29;
    int b = ++a; //先 a = a + 1；再 b = a
    printf("%d\n",a); //结果为30
    printf("%d\n",b); //结果为30
    return 0;
}

#include <stdio.h>
int main()
{
   
    int a = 29;
    int b = --a; //先 a = a - 1；再 b = a
    printf("%d\n",a); //结果为28
    printf("%d\n",b); //结果为28
    return 0;
}

//后置++或--：先使用，再进行++或--
#include <stdio.h>
int main()
{
   
    int a = 29;
    int b = a++; //先 b = a；再 a = a + 1
    printf("%d\n",a); //结果为30
    printf("%d\n",b); //结果为29
    return 0;
}

#include <stdio.h>
int main()
{
   
    int a = 29;
    int b = a--; //先 b = a；再 a = a - 1
    printf("%d\n",a); //结果为28
    printf("%d\n",b); //结果为29
    return 0;
}

（2）+和-

​ 这里是正号和负号，都是单目操作符

​ 操作符 + 对正负值没有影响，是一个可以省略的符号；

​ 操作符 - 是用来改变一个值的正负，负数前加上 - 就会得到正数；正数前加上 - 会得到负数

#include <stdio.h>
int main()
{
   
    int a = +10; //等同于 int a = 10;
    int b = -20;
    int c = -b; //等同于 c = 20;
    printf("%d\n",c);
    return 0;
}

8.强制类型转换：

​ 强制类型转换是操作符中一种特殊的操作符

语法格式：(类型) -- 想强制转换成什么类型就在括号里写上什么类型

#include <stdio.h>
int main()
{
   
    int a = (int)3.1415; //结果为3，将double类型强制转换成int类型
    printf("%d\n",a);
    return 0;
}

​ 注意：强扭的瓜不甜