C语言中的类型转换 |
您所在的位置：网站首页 › 数数歌二胡独奏 › C语言中的类型转换 |
C语言中的类型转换
在编码过程中，我们肯定会遇到一些类型相互转化的问题。这一节当中，我们就来讨论类型的相互转化。 1. 判断数据类型的小技巧在开始之前，先介绍一个小技巧，用于判断某一个数据对象的类型。 #include int main() { // 一个整型指针变量p int* p; // 各式各样的类型 char c; short s; int n; long l; float f; double d; // 将整型赋值给指针类型 p = c; p = s; p = n; p = l; p = f; p = d; return 0; }首先，我们定义一个整型指针变量p。注意，这里的int后面加了一个*，说明它是一个整型指针变量。我们先不管什么是指针变量，大家只要知道，指针变量和整型、浮点这些数据类型是不能相互赋值的。 由于它们无法相互赋值，所以编译器会提示报错信息。  从上到下，依次是赋值运算符无法将char、short、int、long、float、double转化为整型指针变量int *。 错误提示与我们定义的变量类型一致，说明这个提示是准确的。好的，那下面我们就可以通过这个小技巧来研究一下，类型与类型之间进行运算，到底会发生什么样的变化呢？ 2. 同类型之间进行运算我们将一步一步探究运算会怎样改变数据对象的类型。首先，我们先了解同类型之间的数据对象进行运算，将会产生怎样的结果。 2.1 有符号整型同类型#include int main() { // 一个整型指针变量p int* p; // 各式各样的类型 char c; short s; int n; long l; p = c + c; // char + char = int p = s + s; // short + short = int p = n + n; // int + int = int p = l + l; // long + long = long return 0; } c + c，char同类型运算，结果是一个int类型。 s + s，short同类型运算，结果是一个int类型。 n + n，int同类型运算，结果是一个int类型。 l + l，long同类型运算，结果是一个long类型。 在C语言中，高级别的数据类型能表示的数据范围大于或等于低级的数据类型。 类型级别： char < short < int < long 有符号整型类型同类型运算中： 比int低级的类型，都会转换成int，比int高级的类型不变。  2.2 无符号整型同类型#include
int main()
{
// 一个整型指针变量p
int* p;
// 各式各样的类型
unsigned char uc;
unsigned short us;
unsigned int un;
unsigned long ul;
p = uc + uc; // unsigned char + unsigned char = int
p = us + us; // unsigned short + unsigned short = int
p = un + un; // unsigned int + unsigned int = unsigned int
p = ul + ul; // unsigned long + unsigned long = unsigned long
return 0;
} uc + uc，unsigned char同类型运算，结果是一个int类型。 us + us，unsigned short同类型运算，结果是一个int类型。 un + un，unsigned int同类型运算，结果是一个unsigned int类型。 ul + ul，unsigned long同类型运算，结果是一个unsigned long类型。 类型级别： int < unsigned int < unsigned long 无符号整型类型同类型运算中： 比int低级的类型，都会转换成int，比int高级的类型不变。  2.3 浮点同类型#include
int main()
{
// 一个整型指针变量p
int* p;
// 各式各样的类型
float f;
double df;
p = f + f; // float + float = float
p = df + df; // double + double = double
return 0;
} f + f，float同类型运算，结果是一个float类型。 df + df，double同类型运算，结果是一个double类型。 类型级别： float < double 浮点类型同类型运算中： 类型不变  2.4 同类型运算的结果上面探究了同类型之间运算结果的类型。 对于整型，级别低于int的类型会转换成int。而比int高级的类型则不发生变化。 对于浮点，不发生变化。 3.不类型之间进行运算3.1 有符号整型不同类型#include int main() { // 一个整型指针变量p int* p; // 各式各样的类型 char c; short s; int n; long l; p = c + s; // char + short = int p = c + n; // char + int = int p = c + l; // char + long = long p = n + l; // int + long = long return 0; }c + s，char类型与short类型运算，结果是一个int类型。 c + n，char类型与int类型运算，结果是一个int类型。 c + l，char类型与long类型运算，结果是一个long类型。 n + l，char类型与long类型运算，结果是一个long类型。 类型级别： char < short < int < long 有符号整型不同类型运算中： 若运算符两边类型均低于int或等于int，那么结果为int。 若有高于int的，那么结果为高于int的等级最高的类型。  3.2 无符号整型不同类型#include
int main()
{
// 一个整型指针变量p
int* p;
// 各式各样的类型
unsigned char uc;
unsigned short us;
unsigned int un;
unsigned long ul;
p = uc + us; // unsigned char + unsigned short = int
p = uc + un; // unsigned char + unsigned int = unsigned int
p = uc + ul; // unsigned char + unsigned long = unsigned long
p = un + ul; // unsigned int + unsigned long = unsigned long
return 0;
}uc + us，unsigned char类型与unsigned short类型运算，结果是一个int类型。 uc + un，unsigned char类型与unsigned int类型运算，结果是一个unsigned int类型。 uc + ul，unsigned char类型与unsigned long类型运算，结果是一个unsigned long类型。 un + ul，unsigned int类型与unsigned long类型运算，结果是一个unsigned long类型。 类型级别： int < unsigned int < unsigned long 无符号整型不同类型运算中：（同上） 若运算符两边类型均低于int或等于int，那么结果为int。 若有高于int的，那么结果为高于int的等级最高的类型。 3.3 混合整型类型#include
int main()
{
// 一个整型指针变量p
int* p;
// 各式各样的类型
char c;
short s;
int n;
long l;
unsigned char uc;
unsigned short us;
unsigned int un;
unsigned long ul;
p = c + uc; // char + unsigned char = int
p = s + us; // short + unsigned short = int
p = c + n; // char + int = int
p = c + un; // char + unsigned int = unsigned int
p = n + un; // int + unsigned int = unsigned int
p = n + ul; // int + unsigned long = unsigned long
return 0;
}c + uc，char类型与unsigned char类型运算，结果是一个int类型。 s + us，short类型与unsigned short类型运算，结果是一个int类型。 c + n，char类型与int类型运算，结果是一个int类型。 c + un，char类型与unsigned int类型运算，结果是一个unsigned int类型。 n + un，int类型与unsigned int类型运算，结果是一个unsigned int类型。 n + ul，int类型与unsigned long类型运算，结果是一个unsigned long类型。 类型级别： int < unsigned int < long < unsigned long 混合整型类型运算中：（同上） 若运算符两边类型均低于int或等于int，那么结果为int。 若有高于int的，那么结果为高于int的等级最高的类型。 从结果看来，同一种类型的无符号等级要高于有符号等级。 3.4 浮点不同类型#include int main() { // 一个整型指针变量p int* p; // 各式各样的类型 float f; double df; p = f + df; return 0; }f + df，float类型与double类型运算，结果是一个double类型。 类型级别： loat < double 浮点不同类型运算中： 结果为运算符两边级别最高的类型。 3.5 浮点整型混合#include int main() { // 一个整型指针变量p int* p; // 各式各样的类型 char c; short s; int n; long l; unsigned char uc; unsigned short us; unsigned int un; unsigned long ul; float f; double df; p = c + f; // char + float = float p = s + f; // short + float = float p = n + f; // int + float = float p = l + f; // long + float = float p = uc + f; // unsigned char + float = float p = us + f; // unsigned short + float = float p = un + f; // unsigned int + float = float p = ul + f; // unsigned long + float = float p = c + df; // char + double = double p = s + df; // short + double = double p = n + df; // int + double = double p = l + df; // long + double = double p = uc + df; // char + double = double p = us + df; // short + double = double p = un + df; // int + double = double p = ul + df; // long + double = double return 0; }类型级别： 整型类型 < float < double 浮点与整型类型混合运算中： 结果为运算符两边等级最高的类型。 4. 自动类型转换上面的代码，让我们看到了类型经过运算后，结果的变化。那么造成这种变化的原因是什么呢？ 这个原因，我们称之为自动类型转换。C语言会将运算符两边的类型，先经过自动类型转换后，再进行运算。 那么为什么有时候转换为int，有时候又是long，有时候是float，又有时候是double了呢？ 我们总结一下上面观察到的各种转换现象： 有符号整型同类型比int低级的类型，都会转换成int，比int高级的类型不变无符号整型同类型比int低级的类型，都会转换成int，比int高级的类型不变浮点同类型类型不变有符号整型不同类型若运算符两边类型均低于int或等于int，那么结果为int。若有高于int的，那么结果为高于int的等级最高的类型。无符号整型不同类型若运算符两边类型均低于int或等于int，那么结果为int。若有高于int的，那么结果为高于int的等级最高的类型。混合整型不同类型若运算符两边类型均低于int或等于int，那么结果为int。若有高于int的，那么结果为高于int的等级最高的类型。浮点不同类型结果为运算符两边级别最高的类型浮点整型混合结果为运算符两边级别最高的类型综合所有情形，我们可以得到以下结论： 整型之间进行运算：若运算符两边类型均低于int或等于int，那么结果为int。若有高于int的，那么结果为高于int的等级最高的类型。 整型与浮点进行运算：结果为运算符两边等级最高的类型。  类型级别从低到高依次为： int < unsigned int < long < unsigned long < float < double char，short，unsigned char，unsigned short总是会被转换为int。 5. 整型运算符的注意点整型与整型运算，是不会出现浮点类型的。也就是说，运算结果将丢失小数部分。 #include int main() { int n1, n2; n1 = 5; n2 = 2; printf("%d\n", n1 / n2); } 除号运算符两边均为int，int与int运算，结果是int。那我们必须在运算符两边，设置一个浮点型才行，float和double都可以。根据上面的转换规则，运算符两边均会转换为浮点型进行运算，结果也是一个浮点型。这样就能保留小数部分了。 #include int main() { int n; float f; n = 5; f = 2; printf("%f\n", n / f); } 那我们再思考一下，对于字面常量来说，是不是也存在这种问题呢？ #include int main() { printf("%d\n", 5 / 2); // int与int运算，结果为int printf("%f\n", 5 / 2.0); // int与double运算，结果为double printf("%f\n", 5.0 / 2.0); // double与double运算，结果为double }5 / 2，int与int运算，结果为int 5 / 2.0，int与double运算，结果为double 5.0 / 2.0，double与double运算，结果为double 确实如此，字面常量也有这个问题。至于字面常量是什么类型，我们可以用上面的小技巧判断一下。一般来说，不带小数的整数字面常量，是int。带小数的字面常量，是double类型。 6. 强制类型转换如果我不想修改上面代码，依旧保持n1或n2为整型，但是计算结果想要得到浮点型怎么办？ 好像以目前我们了解的知识，是无法解答的。因为整型与整型运算是无法得到浮点型的。因此，我们引入一个新的知识点，强制类型转换。 使用公式： (类型)需要转换的数据对象 #include int main() { int n1, n2; n1 = 5; n2 = 2; printf("%f\n", (float)n1 / n2); printf("%f\n", (double)n1 / n2); return 0; } 在上面的代码中，我们把n1先强制转换为了float型，float再除以int。那么结果就是float类型了。n2先转换为double，再与int运算，结果为double。 请注意，强制类型转换，并不能影响n1和n2变量原本的类型。它们只是改变了运算时的临时数据对象的类型。 7. 赋值造成的类型转换#include int main() { int n; char c = 123; n = c; printf("%d %d", c, n); return 0; } 上面的代码中，n是int型，c是字符型。我们把char型变量c值给了int型变量n，结果正常。 #include int main() { int n = 123456; char c; c = n; printf("%d %d", c, n); return 0; } 如果反过来，把整型赋值给字符型呢？结果是整型变量n存储的数值遭到了丢失。毕竟，字符型的最大范围是-128到127。 小的整型类型可以赋值给大的，大的整型类型请勿赋值给小的。 除非你有这种特殊需求。 - THE END -点击以下链接获取更多课程： 01. 课程介绍 02. VS开发环境的搭建 03. 第一个C语言程序 04. 基本的C语言语法知识 05. 整型数据类型 06. 浮点数据类型 07. 变量与常量 08. 字符常量及字符变量 09. printf函数详细解析 10. printf函数深入讨论 11. scanf函数 12. 运算符与表达式 13. 类型转换 14. 关系运算符与逻辑运算符 15. 分支结构 16. 循环结构 17. 循环辅助 18. 多重选择 19. 初识数组 20. 多维数组 21. 字符串与字符数组 22. 输入输出缓存 23. 函数 24. 函数递归 25. 调试代码 26. 初识指针 27. 指针运算 28. 指针与数组 29. 指针作为参数传递 后续更多课程 |
【本文地址】
今日新闻 |
点击排行 |
|
推荐新闻 |
图片新闻 |
|
专题文章 |