C语言数据类型和变量

C语言数据类型和变量

C语言数据类型和变量

目录

1. 数据类型介绍
2. 变量
3. 操作符

1. 数据类型介绍

C语言提供了丰富的数据类型来描述生活中的各种数据。

所谓“类型”，就是相似的数据所拥有的共同特征编译器只有知道了数据的类型，才能知道怎么对数据进行处理。

💡

[] 中的内容可以省略

1.1 字符型

char
[signed] char
unsigned char

1.2 整型

//短整型
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.3 浮点型

float
double
long double

1.4 布尔类型

C语言中，用整数 0 表示假，非零值表示真。

在C99中引入了布尔类型，用来专门表示真假。

bool

布尔类型的使用得包含头文件 <stdbool.h>

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

//布尔类型的底层定义
#define bool  _Bool

#define false 0
#define true 1

#include<stdio.h>
#include<stdbool.h>
int main()
{
	bool flag = true;
	if (flag)
	{
		printf("hello");
	}
	return 0;
}

1.5 数据类型长度

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

1.5.1 sizeof 操作符

sizeof 是一个关键字，也是一种操作符，用于计算 sizeof 操作符数的类型长度的，单位是字节。

sizeof(类型)
sizeof(表达式)

sizeof的操作数是表达式时，可以省略括号。

比特：二进制中0/1所占内存的大小。

1字节（byte）=8比特（bit）

1KB = 1024byte

……

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

sizeof的计算结果为 size_t 类型。

sizeof 的返回值，C语言只规定是无符号整数，没有明确具体的类型，不同的系统中，返回值类型可能是 unsigned int、unsigned long、unsigned long long…

因此，C语言创建了一个类型名 size_t ，占位符为%zd ，用于统一表示 sizeof 的返回值类型。

#include <stdio.h>
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));//输出为 8（4+4）
	return 0;
}

1.5.2 数据类型长度

#include <stdio.h>
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;
}

在VS222配置下的输出：

在不同编译器中结果可能不同

1
1
2
4
4
8
4
8
8

1.5.3 sizeof中表达式不计算

#include <stdio.h>
int main()
{
  short s = 2;
  int b = 10;
  printf("%d\n", sizeof(s = b+1));//输出 2
  printf("s = %d\n", s);//输出 s=2
  return 0;
}

sizeof(s = b + 1) 的计算结果看 s 的数据类型。

其中 s = b + 1 不执行。

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

1.6 数据类型长度

1.6.1 signed 和 unsigned

C语言使用signed 和 unsigned 关键字修饰字符型和整形。（不包括浮点型）

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

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

整型变量声明为unsigned 的好处是，同样长度的内存能表示的最大整数值，增大了一倍。下面的定义是VS2022环境中， limit.h 部分相关的定义。

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

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

即 char 不等同于 signed char ，它可能是signed char ，也有可能是unsigned char 。

与 int不同， int 就是等同于 signed int 。

1.6.2 数据类型的取值范围

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 的最⼤值。

#include <stdio.h>
#include <limits.h>
int main()
{
   printf("The number of bits in a byte %d\n", CHAR_BIT);
   printf("The minimum value of SIGNED CHAR = %d\n", SCHAR_MIN);
   printf("The maximum value of SIGNED CHAR = %d\n", SCHAR_MAX);
   printf("The maximum value of UNSIGNED CHAR = %d\n", UCHAR_MAX);
   printf("The minimum value of SHORT INT = %d\n", SHRT_MIN);
   printf("The maximum value of SHORT INT = %d\n", SHRT_MAX);
   printf("The minimum value of INT = %d\n", INT_MIN);
   printf("The maximum value of INT = %d\n", INT_MAX);
   printf("The minimum value of CHAR = %d\n", CHAR_MIN);
   printf("The maximum value of CHAR = %d\n", CHAR_MAX);
   printf("The minimum value of LONG = %ld\n", LONG_MIN);
   printf("The maximum value of LONG = %ld\n", LONG_MAX);
   return 0;
}

输出结果为：

The number of bits in a byte 8
The minimum value of SIGNED CHAR = -128
The maximum value of SIGNED CHAR = 127
The maximum value of UNSIGNED CHAR = 255
The minimum value of SHORT INT = -32768
The maximum value of SHORT INT = 32767
The minimum value of INT = -2147483648
The maximum value of INT = 2147483647
The minimum value of CHAR = -128
The maximum value of CHAR = 127
The minimum value of LONG = -9223372036854775808
The maximum value of LONG = 9223372036854775807

2. 变量

2.1 变量的创建

类型是用来创建变量的。

C语言中把经常变化的值称为变量，不变的值称为常量。

int a = 1;//初始化
int a;
a = 1;//赋值

2.2 变量的分类

2.2.1 全局变量和局部变量

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

全局变量不初始化，默认值为0。

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

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

局部变量不初始化，值是随机的。

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

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

如果全局变量和局部变量重名，那么局部变量优先使用。

#include <stdio.h>
int n = 1000;
int main()
{
  int n = 10;
  printf("%d\n" n);//输出 10
  return 0;
}

2.2.2 作用域和生命周期

**作用域：**作用域（scope）是程序设计概念，通常来说，一段程序代码中所用到的名字并不总是有效/可用的，而限定这个名字的可用性的代码范围就是这个名字的作用域。

局部变量的作用域是变量所在的局部范围。

全局变量的作用域是整个工程。

**生命周期：**变量的生命周期指的是变量的创建到变量的销毁之间的一个时间段。

局部变量的生命周期是：进入作用域生命周期开始，出作用域生命周期结束。

全局变量的生命周期是：整个程序的生命周期。

2.2.3 全局变量和局部变量在内存中存储

学习C/C++语言的时候，我们会关注内存中的三个区域：栈区、堆区、静态区。

1. 局部变量是放在内存的栈区
2. 全局变量是放在内存的静态区
3. 堆区是用来动态内存管理的

3.操作符

操作符也被叫做：运算符。

3.1 算数操作符

算数操作符包括 + - * \ % 。

3.1.1 + 和 -

+ 和 - 用来完成加法和减法。

#include<stdio.h>
int main()
{  
	int a = 4 + 22;  
  int b = 61 - 23;  
  printf("%d\n%d\n", a, b);  
  return 0;
}

3.1.2 *

* 用来完成乘法。

#include<stdio.h>
int main()
{  
	int num = 5;    
	printf("%d", num * num);    
	return 0;
}

3.1.3 /

/ 用来完成除法。

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

#include<stdio.h>
int main()
{  
	int a = 6;    
	int b = 4;    
	int c = a / b;    
	printf("%d\n", c);//输出 1    
	printf("%f\n", c);//输出 1.000000    
	return 0;
}

C语言中 /执行的整数除法是整除，只会返回整数部分，丢弃小数部分。

如果想要得到浮点型的结果，两个运算数至少有一个浮点数，此时C语言会进行浮点数除法。

#include<stdio.h>
int main()
{  
  int a = 6;    
  float b = 4.0f;    
  float c = a / b;    
  printf("%f", c);//输出 1.500000    
  return 0;
}

printf 打印浮点数默认保留6位小数。

#include<stdio.h>
int main()
{    
	float a = 6.0 / 4;    
	printf("%f", a);    
	return 0;
}

直接在代码中写浮点数，默认为 double类型。
此处的6.0为 double 类型。

3.1.4 %

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

#include<stdio.h>
int main()
{  
	int x = 6 % 4;    
	printf("%d", x);//输出 2    
	return 0;
}

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

#include<stdio.h>
int main()
{    
	printf("%d\n", 11 % 5);//输出 1    
	printf("%d\n", 11 % -5);//输出 1    
	printf("%d\n", -11 % -5);//输出 -1    
	printf("%d\n", -11 % 5);//输出 -1   
	return 0;
}

在上述示例中， + - * / % 都是由有两个操作数的，位于操作符两端的就是它们的操作数，因此算术操作符也被称为双目操作符。

3.2 赋值操作符

3.2.1 =

在变量创建好的时候给一个初始值叫做初始化，在变量创建好后，再给一个值，称为赋值。

赋值语句的返回值是所赋的值。

int a = 3;//初始化
a = 5;//赋值

赋值操作符可以进行连续赋值。

int a = 3;
int b = 5;
int c = 0;
c = b = a + 3;//连续赋值，b = c = 6

连续赋值从右到左依次赋值。

C语言虽然支持连续赋值，但是连续赋值写出来的代码不容易理解。

3.2.2 复合赋值符

这些赋值符有：

1. +=     -=
2. *=     /=     %=
3. >>=    <<=
4. &=     |=     ^=

+= -= *= /= %=

写代码时用于简化对一个数进行自增，自减之类的操作。

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

3.3 单目操作符

单目操作符包括 ++ - - + -

3.3.1 ++和 - -

**前置：**先+/-1，后使用。

#include<stdio.h>
int main()
{  
  int a = 10;    
  int b = ++a;//++的操作数是a，放在a前面的，就是前置++    
  printf("%d\n%d", a, b);//输出结果为a=11，b=11    
  return 0;
}

a原来是10，先+1变成11，再给b赋值

**后置：**先使用，后+/-1

#include<stdio.h>
int main()
{
	int a = 10;   
	int b = a++;//++的操作数是a，放在a后面的，就是后置++  
  printf("%d\n%d", a, b);//输出结果为a=11，b=10  
  return 0;
}

a原来是10，先赋值给b，再+1变成11

3.3.2 +和-

这里的+是正号，-是负号。

+ 对正负值没有影响，是一个完全可以省略的操作符。

-用来改变一个值的正负号，负数的前面加上 -会得到正数，正数的前面加上 -就会得到负数。

#include<stdio.h>
int main()
{    
	int a = 1;
  int b = -1;
  printf("%d\n", +a);//输出 1
  printf("%d\n", +b);//输出 -1 
  printf("%d\n", -a);//输出 -1
  printf("%d\n", -b);//输出 1
  return 0;
 }

3.4 强制类型转换

语法形式： (类型)

int a = 3.14;
//a的类型为int，3.14为double类型
//两边类型不一致，编译器会报警告。
int a = (int)3.14;
//将3.14强制转换为int类型
//这种强制类型转换**只取整数部分**

不到万不得已，尽量不使用强制类型转换。