【C语言的内置数据类型和变量】—内含部分操作符介绍、强制类型转换

---

前言

您好！本篇将为您详细介绍C语言数据类型和变量的相关知识，主要讲解内置数据类型、变量和部分操作符的知识，知识点讲解得清晰明了，内容稍有些多，希望您可以耐心看完，一定会学到知识的，希望您会喜欢。

---

1.数据类型介绍

c语言提供了丰富的数据类型来描述生活中的各种数据。
使用整型类型来描述整数，使用字符类型来描述字符，使用浮点型类型来描述小数。
所谓“类型”，就是相似的数据所拥有的共同特征，编译器只有知道了数据的类型，才知道怎么操作数据。
下面盘点一下C语言提供的各种数据类型，本篇主要讲解内置数据类型。

1.1字符型

char          //全称：character
[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 浮点型

其实，浮点型就是小数点可以移动的类型。比如：12.34=1.234×10。

float  //单精度浮点型
double //双精度浮点型
long double

1.4布尔类型

C语言原来并没有为布尔值单独设置一个类型，而是使用整数0表示假，非零值表示真。
在C99中也引入了布尔类型，是专门表示真假的。

_Bool

布尔类型的使用得包含头文件<stdbool.h>。
布尔类型变量的取值是：true或者false。
代码演示：

//布尔类型代码演示
#include <stdio.h>
#include <stdbool.h>

int main()
{
	_Bool flag = true;//也可以将true换成任意一个非零值
	if (flag)
		printf("hello C\n");
	else
		printf("I love C\n");
	return 0;
}

您可以自己试着将true换成false（0也可以），看看运行结果会不会不同。

2.各种数据类型的长度

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

2.1sizeof操作符

sizeof是一个关键字，也是操作符，专门用来计算sizeof的操作符数的类型长度，单位是字节。
sizeof操作符的操作数可以是类型，也可以是变量或者表达式。

sizeof(类型）
sizeof 表达式

sizeof的操作数如果不是类型，是表达式的时候，可以省略掉后面的括号。
sizeof后边的表达式是不真实参与运算的，根据表达式的类型来得出大小。
比如：

//sizeof操作符
#include <stdio.h>

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

运行结果：

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

sizeof运算符的返回值，C语言只规定是无符号整数（因为值一定大于>=0），并没有规定具体的类型，而是留给系统自己去决定，sizeof到底返回什么类型。不同的系统中返回值的类型可能是unsigned int，也有可能是unsigned long，甚至是unsigned long long，对应的printf()占位符分别是%u，%lu，%llu。这样不利于程序的可移植性。

代码演示：

//每一种数据类型有自己的打印格式。
#include <stdio.h>

int main()
{
	int a = -10;//有符号的整数
	unsigned int b = 10;
	unsigned long int c = 100;
	unsigned long long int d = 1000;

	printf("%d\n", a);//%d用来打印有符号的整数
	printf("%u\n", b);
	printf("%lu\n", c);
	printf("%llu\n", d);

	return 0;
}

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

#include<stdio.h>

int main()
{
	size_t n = sizeof(int);
	printf("%zd\n", n);
	return 0;
}

2.2各数据类型长度

直接用代码为您展示：

//各数据类型长度
#include <stdio.h>

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

	return 0;
}

结果：

2.3sizeof中表达式不计算

//测试：sizeof中表达式不计算，只会根据最终计算结果的类型得出结论
#include <stdio.h>

int main()
{
	short s = 2;
	int b = 10;
	printf("%d\n", sizeof(s = b + 1));
	printf("s=%d\n", s);

	return 0;
}

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

3.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，最大值增到了65535。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  //有符号整型的最大值 

以上结果，我们可以在VS2022上通过代码来求出最值，比如：

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。

4.数据类型的取值范围

上述的数据类型有很多，其中整型类型就有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语言中把经常变化的值称为变量，不变的值称为常量。
变量创建的语法形式是这样的：

例如：

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

变量在创建的时候就给一个初始值，就叫初始化。
例如：

int age = 19;
char ch = 'q';
double weight = 50.0;
unsigned int height = 100;

注意：

1. 变量名可以自己起，但尽量起的有意义。
2. 变量的组成只能是字母，数字，下划线，并且不能用数字开头。
3. 变量的名字不能是关键字。

4.2变量的分类

• 全局变量：在大括号外部定义的变量就是全局变量。 全局变量的适用范围更广，整个过程中想使用，都是可以使用的。
• 局部变量：在大括号内部定义的变量就是局部变量。 局部变量的适用范围是比较局限的，只能在自己所在的局部范围内使用。

//全局变量，局部变量代码演示
#include <stdio.h>

int b = 200;//全局变量
int main()
{
	int a = 100;//局部变量
	{
		int c = 20;//局部变量，其中c比a范围小
	}
	return 0;
}

那如果局部变量和全局变量相同呢？

//当局部变量与全局变量名字相同时：
#include <stdio.h>

int y = 200;//全局变量
int main()
{
	int y = 20;//局部变量
	printf("%d\n", y);
	return 0;
}

那结果会是多少呢？

其实当局部变量和全局变量同名的时候，局部变量优先使用。但还是尽量别同名的好。
电脑上有内存，内存是用来存放数据的，我们创建变量的本质实在内存中申请了一块空间。那全局变量和局部变量在内存中存储在哪里呢？
一般我们在学习C/C++语言的时候，我们会关注内存中的三个区域：栈区、堆区、静态区。

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

其实内存区域的划分会更加细致，后面在讲述操作系统的相关篇章时会介绍，还请您持续关注。

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

在写代码的时候，一定会涉及到计算。
C语言中为了方便计算，提供了一系列的操作符，其中有一组操作符叫：算术操作符。分别是：+ - * / %，这些操作符都是双目操作符。
提醒： 操作符也被叫做运算符，意思是一样的。

5.1+和-

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

//+和-
#include <stdio.h>

int main()
{
	int x = 4 + 12;
	int y = 25 - 13;
	printf("%d\n", x);
	printf("%d\n", y);
	return 0;
}

5.2 *

运算符*用来完成乘法。

//*
#include <stdio.h>

int main()
{
	int x = 5;
	int y = 6;

	printf("%d\n", x * y);//输出30

	return 0;
}

5.3 /

运算符/用来完成除法。
除号的两端如果是整数，执行的是整数除法，得到的结果也是整数。

//运算符/
#include <stdio.h>
int main()
{
	float x = 10/ 4;
	int y = 10 / 4;

	printf("%f\n", x);//输出2.000000
	printf("%d\n", y);//输出2

	return 0;
}

补充：
float——%f
double——%lf
%f和%lf打印的时候，小数点后都默认打印6位小数。
%.1f——小数点后保留一位
%.2lf——小数点后保留两位

上面代码中，尽管变量x的类型是float（浮点数)，但是9/4的结果是2.0，而不是2.5。原因在于C语言里面的整数除法是整除，只会返回整数部分，丢弃小数部分。
如果希望得到浮点数的结果，两个运算数必须至少有一个浮点数，这时C语言就会进行浮点数除法。

//浮点数/
#include <stdio.h>

int main()
{
	float x = 10.0 / 4;//或者写成10/4.0

	printf("%f\n", x);//输出2.500000

	return 0;
}

上面代码中，10.0/4表示进行浮点数除法，得到的结果就是2.5。

5.4 %

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

//运算符%
#include <stdio.h>

int main()
{
	int x = 10 % 4;
	printf("%d\n", x);//输出：2
	return 0;
}

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

//负数求模
#include <stdio.h>

int main()
{
	printf("%d\n", 13 % -6);//结果是1
	printf("%d\n", -13 % -6);//结果是-1
	printf("%d\n", -13 % 6);//结果是-1

	return 0;
}

上面代码中，第一个运算符的正负号（13或者-13）决定了结果的正负号。

6.赋值操作符和复合赋值符

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

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

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

6.1连续赋值

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

int a = 1;
int b = 0;
int c = 6;
c = b = a + 3;//连续赋值是从右至左依次赋值的

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

int a = 1;
int b = 0;
int c = 6;
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语言提供了复合赋值符，方便我们编写代码，这些赋值符有：

+=      -=      
*=      /=       %=
//还有下面的操作符，在后面的篇章会为您介绍，还请您持续关注。
>>=     <<=
&=      |=       ^=

7.单目操作符：++、- -、+、-

前面介绍的操作符都是双目操作符，有2个操作数。C语言中还有一些操作符只有1个操作数，被称为单目操作符。++、- -、+（正）、-（负）就是单目操作符。

7.1 ++和- -

++是一种自增的操作符，又分为前置++和后置++（不管是前置++还是后置++，都是+1）；- -是一种自减的操作符，也分为前置- -和后置- -。

7.1.1前置++

int a = 10;
int b = ++a;//++的操作数是a，放在a前面的就是前置++
printf("a=%d b=%d\n", a, b);

计算口诀：先+1，后使用
a原来是10，先+1，后a变成了11，再使用就是赋值给b，b得到的也是11，所以计算结束后，a和b都是11。

7.2后置++

int a = 10;
int b = a++;//++的操作数是a，放在a后面的就是后置++
printf("a=%d b=%d\n", a, b);

计算口诀：先使用，后+1
a原来是10.先使用，就是先赋值给b，b得到了10，然后再+1，然后a变成了11，所以直接结束后a是11，b是10。

7.1.3前置- -

如果您看懂了前置++，那前置- -是同理的，只是把加一换成了减一。
计算口诀：先-1，后使用

int a = 10;
int b = --a;//--的操作数是a，放在a前面的就是前置--
printf("a=%d b=%d\n", a, b);//输出的结果是：9 9

7.1.4后置- -

同理，后置- -类似于后置++，也是把加一换成了减一。
计算口诀：先使用，后-1

int a = 10;
int b = a--;//--的操作数是a，放在a后面的就是后置--
printf("a=%d b=%d\n", a, b);//输出的结果是：9 10

7.2+和-（正号和负号）

这里的+是正号，-是负号，都是单目操作符。
运算符+对正负值没有影响，是一个完全可以省略的运算符，当然写了也不算错。
int a =+ 10;等价于int a = 10;
运算符的-用来改变一个值的正负号，负数的前面加上-就会得到正数，正数的前面加上-会得到负数。

int a = 10;
int b = -a;
int c = -10;
printf("b=%d c=%d\n", b, c);//这里的b和c都是-10

int a = -10;
int b = -a;
printf("b=%d\n", b);//这里的b是10

8.强制类型转换

在操作符中还有一种特殊的操作符是强制类型转换，语法形式很简单，形式如下：
（类型）
请看代码：

int a = 3.14;
//a是int类型，3.14是double类型，两边的类型不一致，编译器会报警告

补充：
直接写出的字面浮点数，会被编译器直接识别为double类型

为了消除这个警告，我们可以使用强制类型转换：

int a = (int)3.14;//意思是将3.14强制类型转换为int类型，这种强制类型转换只取整数部分

俗话说，强扭的瓜不甜，我们使用强制类型转换都是万不得已的时候使用，如果不需要强制类型转换就能实现代码，这样更好。

---

总结

内容稍微有些多，您可以一次学习一部分，好好消化吸收一下，本篇内容一定对您有所帮助。后续还会写更多相关知识，都会很详细的，希望您持续关注哦！

                好啦，快乐的时光总是非常的短暂，本次我的分享就到这里啦。
    
                     感谢您的阅读，希望对您有所帮助，咱们下篇见！
                     
                           友友们别忘了点赞、关注哦！