C语言第三弹---数据类型和变量

✨个人主页： 熬夜学编程的小林

💗系列专栏： 【C语言详解】 【数据结构详解】

数据类型和变量

• 1、数据类型介绍
• • 1.1、整型
  • 1.2、浮点型
  • 1.3、字符型
  • 1.4、布尔类型
  • 1.5、各种数据类型的长度
  • • 1.5.1、sizeof操作符
    • 1.5.2、数据类型的长度
    • 1.5.3、sizeof中表达式不计算
    • 2、signed和unsigned
    • 3、数据类型和取值范围
    • 4、变量
    • • 4.1、变量的创建
      • 4.2、变量的分类
      • 5、算术操作符：+、-、*、/、%
      • • 5.1、+ 和 -
        • 5.2、*
        • 5.3、/
        • 5.4、%
        • 6、赋值操作符：= 和复合赋值
        • • 6.1 连续赋值
          • 6.2 复合赋值符
          • 7、单目操作符：++、--、+、-
          • • 7.1 ++和--
            • • 7.1.1 前置++
              • 7.1.2 后置++
              • 7.1.3 前置--
              • 7.1.4 后置--
              • 7.2 + 和 -
              • 8、强制类型转换
              • 总结

                1、数据类型介绍

                C语言提供了丰富的数据类型来描述生活中的各种数据。使用整型类型来描述整数，使用字符类型来描述字符，使用浮点型类型来描述小数。

                所谓“类型”，就是相似的数据所拥有的共同特征，编译器只有知道了数据的类型，才知道怎么操作数据。

                下面盘点⼀下C语言提供的各种数据类型，本节主要探讨内置数据类型。

                

                基本类型又称内置类型，是C语言标准指定，内置于编译器中。

                1.1、整型

                //短整型
                short [int]
                [signed] short [int]//有符号
                unsigned short [int]//无符号
                //整型
                int
                [signed] int//有符号
                unsigned int//无符号
                //⻓整型
                long [int]
                [signed] long [int]
                unsigned long [int]
                //更⻓的整型
                //C99中引⼊
                long long [int]
                [signed] long long [int]
                unsigned long long [int]
                

                1.2、浮点型

                float        //单精度
                double       //双精度
                long double  //长精度
                

                1.3、字符型

                char          //字符型
                [signed] char //有符号的字符型
                unsigned char //⽆符号的字符型
                

                1.4、布尔类型

                C语言原来并没有为布尔值单独设置⼀个类型，而是使用整数 0 表示假，非零值表示真。

                在 C99 中也引入了 布尔类型 ，是专门表示真假的。

                _Bool
                

                布尔类型的使用得包含头文件

                布尔类型变量的取值是： true 或者 false .

                #define bool _Bool //用_Bool代替bool类型
                #define false 0
                #define true 1
                

                代码演示

                _Bool flag = true;
                if (flag)//为真则执行
                printf("i like C\n");
                

                1.5、各种数据类型的长度

                每⼀种数据类型都有自己的长度，使用不同的数据类型，能够创建出长度不同的变量，变量长度的不同，存储的数据范围就有所差异。

                1.5.1、sizeof操作符

                sizeof 是⼀个关键字，也是操作符，专门是用来计算sizeof的操作符数的类型长度的，单位是字节。

                sizeof 操作符的操作数可以是类型，也可是变量或者表达式。

                sizeof( 类型 )
                sizeof 表达式
                

                sizeof 的操作数如果不是类型，是表达式的时候，可以省略掉后边的括号的。

                sizeof 后边的表达式是不真实参与运算的，根据表达式的类型来得出大小。

                sizeof 的计算结果是 size_t 类型的。

                测试

                

                此处的%zd为无符号整数的占位符。

                sizeof 运算符的返回值，C语言只规定是无符号整数，并没有规定具体的类型，而是留给系统自己去决定， sizeof 到底返回什么类型。不同的系统中，返回值的类型有可能是unsigned int ，也有可能是 unsigned long ，甚至是 unsigned long long ，

                对应的 printf() 占位符分别是 %u 、 %lu 和 %llu 。这样不利于程序的可移植性。

                C语言提供了⼀个解决方法，创造了⼀个类型别名 size_t ，用来统⼀表示 sizeof 的返回值类型。对应当前系统的 sizeof 的返回值类型，可能是 unsigned int ，也可能是unsigned long long。

                比如

                #include 
                int main()
                {
                int a = 10;
                printf("%zd\n", sizeof(a));
                printf("%zd\n", sizeof a);//a是变量的名字，可以省略掉sizeof后边的()
                printf("%zd\n", sizeof(int));
                printf("%zd\n", sizeof(3 + 3.5));
                return 0;
                }
                

                

                此处为默认的浮点数类型，默认的浮点数类型为double类型，所以为8字节。

                1.5.2、数据类型的长度

                #include 
                int main()
                {
                printf("%zd\n", sizeof(char));
                printf("%zd\n", sizeof(_Bool));
                printf("%zd\n", sizeof(short));
                printf("%zd\n", sizeof(int));
                printf("%zd\n", sizeof(long));
                printf("%zd\n", sizeof(long long));
                printf("%zd\n", sizeof(float));
                printf("%zd\n", sizeof(double));
                printf("%zd\n", sizeof(long double));
                return 0;
                }
                

                在VS2022X64配置下的输出：

                1 
                1 
                2 
                4 
                4 
                8 
                4 
                8 
                8
                

                1.5.3、sizeof中表达式不计算

                //测试：sizeof中表达式不计算 变量的表达式(运算会按照结果传入)
                #include 
                int main()
                {
                short s = 2;
                int b = 10;
                printf("%d\n", sizeof(s = b+1));
                printf("s = %d\n", s);
                return 0;
                }
                

                

                sizeof 在代码进行编译的时候，就根据表达式的类型确定了返回值，而表达式的执行却要在程序运行期间才能执行，在编译期间已经将sizeof处理掉了，所以在运行期间就不会执行表达式了。

                2、signed和unsigned

                C语言使用 signed 和 unsigned 关键字修饰字符型和整型类型的。

                signed 关键字，表示⼀个类型带有正负号，包含负值；

                unsigned 关键字，表示该类型不带有正负号，只能表示零和正整数。

                对于 int 类型，默认是带有正负号的，也就是说 int 等同于 signed int 。

                由于这是默认情况，关键字 signed ⼀般都省略不写，但是写了也不算错。

                signed int a;

                // 等同于int a;

                int 类型也可以不带正负号，只表示非负整数。这时就必须使用关键字 unsigned 声明变量。

                unsigned int a;

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

                比如，16位的 signed short int 的取值范围是：-32768 ~ 32767，最大是32767；而unsigned short int 的取值范围是：0~65535，最大值增大到了65,535。32位的 signed int 的取值范围可以参看 limits.h 中给出的定义。

                下面的定义是VS2022环境中，limits.h中相关定义。

                #define SHRT_MIN (-32768) //有符号16位整型的最⼩值
                #define SHRT_MAX 32767 //有符号16位整型的最⼤值
                #define USHRT_MAX 0xffff //⽆符号16位整型的最⼤值
                #define INT_MIN (-2147483647 - 1) //有符号整型的最⼩值
                #define INT_MAX 2147483647 //有符号整型的最⼤值
                

                unsigned int 里面的 int 可以省略，所以上面的变量声明也可以写成下面这样。

                unsigned a;

                字符类型 char 也可以设置 signed 和 unsigned 。

                signed char c; // 范围为 -128 到 127

                unsigned char c; // 范围为 0 到 255

                注意，C语言规定 char 类型默认是否带有正负号，由当前系统决定。

                这就是说， char 不等同于 signed char ，它有可能是 signed char ，也有可能是unsigned char 。

                这⼀点与 int 不同， int 就是等同于 signed int 。

                3、数据类型和取值范围

                上述的数据类型很多，尤其数整型类型就有short、int、long、long long四种，为什么呢？

                其实每⼀种数据类型有自己的取值范围，也就是存储的数值的最大值和最小值的区间，有了丰富的类型，我们就可以在适当的场景下去选择适合的类型。如果要查看当前系统上不同数据类型的极限值：

                limits.h 文件中说明了整型类型的取值范围。

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

                为了代码的可移植性，需要知道某种整数类型的极限值时，应该尽量使用这些常量。

                • SCHAR_MIN ， SCHAR_MAX ：signed char 的最小值和最大值。

                • SHRT_MIN ， SHRT_MAX ：short 的最小值和最大值。

                • INT_MIN ， INT_MAX ：int 的最小值和最大值。

                • LONG_MIN ， LONG_MAX ：long 的最小值和最大值。

                • LLONG_MIN ， LLONG_MAX ：long long 的最小值和最大值。

                • UCHAR_MAX ：unsigned char 的最大值。

                • USHRT_MAX ：unsigned short 的最大值。

                • UINT_MAX ：unsigned int 的最大值。

                • ULONG_MAX ：unsigned long 的最大值。

                • ULLONG_MAX ：unsigned long long 的最大值。

                4、变量

                4.1、变量的创建

                了解清楚了类型，我们使用类型做什么呢？类型是用来创建变量的。

                什么是变量呢？C语言中把经常变化的值称为变量，不变的值称为常量。

                变量创建的语法形式是这样的：

                //data_type name;
                    |     |
                    |     |
                //数据类型 变量名
                

                int age; //整型变量
                char ch; //字符变量
                double weight; //浮点型变量
                

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

                int age = 18;
                char ch = 'w';
                double weight = 48.0;
                unsigned int height = 100;
                

                4.2、变量的分类

                • 全局变量：在大括号外部定义的变量就是全局变量

                全局变量的使用范围更广，整个工程中想使用，都是有办法使用的。

                • 局部变量：在大括号内部定义的变量就是局部变量

                局部变量的使用范围是比较局限，只能在自己所在的局部范围内使用的。

                #include 
                int global = 2023;//全局变量
                int main()
                {
                int local = 2018;//局部变量
                printf("%d\n", local);
                printf("%d\n", global);
                return 0;
                }
                

                如果局部和全局变量，名字相同呢？

                #include 
                int n = 1000;
                int main()
                {
                int n = 10;
                printf("%d\n" n);//打印的结果是多少呢？
                return 0;
                }
                

                其实当局部变量和全局变量同名的时候，局部变量优先使用。

                全局变量和局部变量在内存中存储在哪里呢？

                ⼀般我们在学习C/C++语言的时候，我们会关注

                内存中的三个区域：栈区、堆区、静态区

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

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

                3. 堆区是用来动态内存管理的（后期会介绍)

                其实内存区域的划分会更加细致，以后在操作系统的相关知识的时候会介绍。

                

                5、算术操作符：+、-、*、/、%

                在写代码时候，⼀定会涉及到计算。

                C语言中为了方便运算，提供了⼀系列操作符，其中有⼀组操作符叫：算术操作符。分别是： + - * / % ，这些操作符都是双目操作符。

                注：操作符也被叫做：运算符，是不同的翻译，意思是⼀样的。

                5.1、+ 和 -

                • 和 - 用来完成加法和减法。
                • 和 - 都是有2个操作数的，位于操作符两端的就是它们的操作数，这种操作符也叫双目操作符。

                  #include 
                  int main()
                  {
                  int x = 4 + 22;
                  int y = 61 - 23;
                  printf("%d\n", x);//打印x的值 26
                  printf("%d\n", y);//打印y的值 38
                  return 0;
                  }
                  

                  

                  5.2、*

                  运算符 * 用来完成乘法。

                  #include 
                  int main()
                  {
                  int num = 5;
                  printf("%d\n", num * num); // 输出 25
                  return 0;
                  }
                  

                  

                  5.3、/

                  运算符 / 用来完成除法。

                  除号的两端如果是整数，执行的是整数除法，得到的结果也是整数。

                  #include 
                  int main()
                  {
                  float x = 6 / 4;
                  int y = 6 / 4;
                  printf("%f\n", x); // 输出 1.000000
                  printf("%d\n", y); // 输出 1
                  return 0;
                  }
                  

                  

                  上面示例中，尽管变量 x 的类型是 float （浮点数），但是 6 / 4 得到的结果是 1.0 ，而不是1.5 。原因就在于C语言里面的整数除法是整除，只会返回整数部分，丢弃小数部分。

                  如果希望得到浮点数的结果，两个运算数必须至少有⼀个浮点数 ，这时C语言就会进行浮点数除法。

                  #include 
                  int main()
                  {
                  float x = 6.0 / 4; // 或者写成 6 / 4.0
                  printf("%f\n", x); // 输出 1.500000
                  return 0;
                  }
                  

                  

                  上面示例中， 6.0 / 4 表示进行浮点数除法，得到的结果就是 1.5.

                  再看⼀个例⼦:

                  #include 
                  int main()
                  {
                  int score = 5;
                  score = (score / 20) * 100;
                  printf("%d\n", score);
                  return 0;
                  }
                  

                  

                  上⾯的代码，你可能觉得经过运算， score 会等于 25 ，但是实际上 score 等于 0 。这是因为score / 20 是整除，会得到⼀个整数值 0 ，所以乘以 100 后得到的也是 0 。

                  为了得到预想的结果，可以将除数 20 改成 20.0 ，让整除变成浮点数除法。

                  #include 
                  int main()
                  {
                  int score = 5;
                  score = (score / 20.0) * 100;//结果为25
                  printf("%d\n", score);
                  return 0;
                  }
                  

                  

                  5.4、%

                  运算符 % 表示求模运算，即返回两个整数相除的余值。这个运算符只能用于整数，不能用于浮点数。

                  #include 
                  int main()
                  {
                  int x = 6 % 4; // 2
                  printf("%d\n", x);
                  return 0;
                  }
                  

                  

                  负数求模的规则是，结果的正负号由第⼀个运算数的正负号决定。

                  #include 
                  int main()
                  {
                  printf("%d\n", 11 % -5); // 1
                  printf("%d\n",-11 % -5); // -1
                  printf("%d\n",-11 % 5); // -1
                  return 0;
                  }
                  

                  

                  上面示例中，第⼀个运算数的正负号（ 11 或 -11 ）决定了结果的正负号。

                  6、赋值操作符：= 和复合赋值

                  在变量创建的时候给⼀个初始值叫初始化，在变量创建好后，再给⼀个值，这叫赋值。

                  int a = 100;//初始化
                  a = 200;//赋值，这⾥使⽤的就是赋值操作符
                  

                  赋值操作符 = 是⼀个随时可以给变量赋值的操作符。

                  6.1 连续赋值

                  赋值操作符也可以连续赋值，如：

                  int a = 3;
                  int b = 5;
                  int c = 0;
                  c = b = a+3;//连续赋值，从右向左依次赋值的。
                  

                  C语言虽然支持这种连续赋值，但是写出的代码不容易理解，建议还是拆开来写，这样方便观察代码的执行细节。

                  int a = 3;
                  int b = 5;
                  int c = 0;
                  b = a+3;
                  c = b;
                  

                  这样写，在调试的是，每⼀次赋值的细节都是可以很方便的观察的.

                  注：调试是什么，后期会详细讲解 。

                  6.2 复合赋值符

                  在写代码时，我们经常可能对⼀个数进行自增、自减的操作，如下代码:

                  int a = 10;
                  a = a+3;
                  a = a-2;
                  

                  这样代码C语言给提供了更加方便的写法：

                  int a = 10;
                  a += 3;
                  a -= 2;
                  

                  C语言中提供了复合赋值符，方便我们编写代码，这些赋值符有：

                  += -= *= /= %=
                  //下⾯的操作符后期讲解
                  >>=