标签：sim eve 原理 com 软件 出现 的区别 组成 包含
| 原码 | 反码 | 补码 | |
|---|---|---|---|
| +7 | 00000111 | 00000111 | 00000111 |
| -7 | 10000111 | 11111000 | 11111001 |
| +0 | 00000000 | 00000000 | 00000000 |
| -0 | 10000000 | 11111111 | 00000000 |
| 数的取值范围 | -127-127 | -127-127 | -128-127 |
从上面的表格可以看出，正数的原码、反码和补码都相同，而负数的补码就是原码取反(最高位不变，其他位取反)后加1的结果。
而实际数据在计算机(手机、电脑、服务器)的内存中也是以补码的形式存储数据的，如下应用案例(Chapter2/datatype/datatype_radix_int.c)所示
#include <stdio.h>
#include <stdlib.h>
/*
原码、反码、补码的运算
@author tony ittimeline@163.com
@version 2018/11/24 20:21:07
*/
void main() {
//原码 10000111
//反码 11111000
//补码 1111 1001 F9
char ch = -7;
printf("ch的地址是%p\n", &ch);
printf("ch=%d\n", ch);
system("pause");
}
首先需要计算出-7的补码，然后转换为16进制的结果为F9,然后通过Visual Studio的调试功能查看内存的存储结果，如下图所示
C语言整数常量可以使用八进制，十进制和十六进制表示。
同时可以使用u后缀表示位无符号整数，使用l后缀表示long类型的整数，使用ll后缀表示为long long类型的整数，应用案例(Chapter2/datatype/int/int_type_raidx.c)如下所示
#include <stdio.h>
#include <stdlib.h>
/*
整数的三种进制类型
整数的三种后缀 无符号，长整数，长长整数
@author tony ittimeline@163.com
@version 2018/11/24 20:23:07
*/
void main() {
int a1 = 10;
int a2 = 010;
int a3 = 0x10;
int a4 = 101u; //无符号
int a5 = 102l;//long
int a6 = 103ll;//long long
printf("a1 = %d\ta2 = %d\ta3 = %d\ta4 = %d\ta5 = %d\ta6 = %d\t", a1, a2, a3, a4, a5, a6);
system("pause");
}
而且整数按照占据不同的字节大小可以分为short,int,long和long long 四种类型，它们默认是有符号(signed)类型用于存储正负数，而对应的无符号类型则用来存储非负数的整数，关于它们能够存储数据的极限以及占据内存的大小如下应用案例(Chapter2/datatype/int/int_limits.c)所示。
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
/*
C语言不同类型整数的极限
占据不同字节大小的整数极限也不一样
@author tony ittimeline@163.com
@version 2018/11/24 20:24:07
*/
void main() {
//16位(嵌入式系统) int和short是等价的
printf("short能存储的最大值是%d\tshort能存储的最小值是%d,占据的字节数量是%d\n", SHRT_MAX, SHRT_MIN, sizeof(short));
printf("unsigned short能存储的最大值是%d\n", USHRT_MAX);
//32位和64位系统 int和long是等价的
printf("int能存储的最大值是%d\tint能存储的最小值是%d,占据的字节数量是%d\n", INT_MAX, INT_MIN, sizeof(int));
printf("unsigned int能存储的最大值是%d\n", UINT_MAX);
//无符号的整数 最小值都是0 即不能表示负数
printf("long能存储的最大值是%d\tlong能存储的最小值是%d,占据的字节数量是%d\n", LONG_MAX, LONG_MIN, sizeof(long));
printf("long long能存储的最大值是%lld\tlong long能存储的最小值是%lld,占据的字节数量是%d\n", LLONG_MAX, LLONG_MIN, sizeof(long long));
printf("unsigned long long 能存储的最大值是%llu\n", ULLONG_MAX);
system("pause");
}
在应用开发时需要主要使用数据类型的极限，如果超越数据存储范围的极限，程序会出现Bug,例如想要存储QQ或者手机号就应该使用无符号的long long 类型，应用案例(Chapter2/datatype/int/long_long.c)如下所示
#include <stdio.h>
#include <stdlib.h>
/*
long long 的应用场景
@author tony ittimeline@163.com
@version 2018/11/24 20:23:07
*/
void main() {
unsigned long long mobilePhone = 18601767221;
printf("mobilePhone=%llu\n", mobilePhone);
unsigned long long qq = 1079351401;
printf(" qq = %llu", qq);
system("pause");
}
在使用整数参与运算时，需要考虑到数据范围对应的极限，否则会发生错误的结果，应用案例(Chapter2/datatype/int/int_over_flow.c)如下所示
#include <stdio.h>
#include <stdlib.h>
/*
整数的越界
@author tony ittimeline@163.com
@version 2018/11/24 20:26:07
*/
void main() {
//为了保证结果运算正确，必须在极限范围之内
unsigned short int shortnum = 65536;
printf("无符号short int所能存储的最大值是%d\n", USHRT_MAX);
printf("shortnum=%d", shortnum); //结果为0 因为chnum所能表示的最大值为255,这里发生了越界，结果错误
system("pause");
}
C语言是在使用标准库的前提下是可移植的，但是C语言的整数在不同的平台上，同样的数据类型占用的字节大小是不一样的。例如int在16位系统占据2个字节，在32位及其以上系统占据四个字节，long在Windows平台上，无论是32位还是64位都是占四个字节，而在64位ubuntu下却占据8个字节，应用案例如下所示
Linux版
#include <stdio.h>
/*
@author tony ittimeline@163.com
@version 2018/11/24 20:26:07
*/
int main(){
long num=100;
int size=sizeof(num);
printf("ubuntu 64位系统中 long占据的字节数量是%d",size);
return 0;
}
Windows版
#include <stdio.h>
/*
@author tony ittimeline@163.com
@version 2018/11/24 20:26:07
*/
void main() {
long val = 100;
printf("windows下long占据的字节数量是%d\n", sizeof(val));
getchar();
}
为了解决不同平台，相同的类型占据的大小不一致的问题，C语言标准委员会在C99标准中提出了跨平台的整数,在<stdint.h>头文件中定义，意味着同样的类型在不同的系统下的大小是一致的，应用案例如下所示
linux版
#include <stdio.h>
#include <stdint.h>
/*
跨平台的整数
@author tony ittimeline@163.com
@version 2018/11/24 20:26:07
*/
int main(){
long num=100;
int int_size=sizeof(num);
printf("ubuntu 64位系统中 long占据的字节数量是%d",int_size);
//在不同的平台下占据都是32字节
int32_t int_32_MAX_VALUE = INT32_MAX;
int int32_size=sizeof(int32_t);
printf("sizeof(int_32_MAX_VALUE ) = %d\n",int32_size);
printf("int_32_MAX_VALUE = %d\n", int_32_MAX_VALUE);
//在不同的平台下占据都是64字节
int64_t int_64_MAX_VALUE = INT64_MAX;
int int64_size=sizeof(int64_t);
printf("sizeof(int_64_MAX_VALUE ) = %d\n", int64_size);
printf("int_64_MAX_VALUE = %ld\n", int_64_MAX_VALUE);
return 0;
}
windows版(Chapter2/datatype/int/int_std.c)
#include <stdio.h>
#include <stdint.h>
/*
不同的平台，不同的编译器，同样的数据类型大小不一样。
例如int 16位的情况下是2个字节，32位系统是4个字节
long类型在windows上无论是32位还是64位都是4个字节，而在64位linux上long占据的是8个字节
为了解决这个问题,C语言标准组织在C99标准中提出了跨平台的整数，也就是着不同平台的整数占用的字节数量是一样的，VS2013+，GCC都支持该标准
*/
/*
跨平台的整数
@author tony ittimeline@163.com
@version 2018/11/24 20:26:07
*/
void main() {
long val = 100;
printf("windows下long占据的字节数量是%d\n", sizeof(val));
//在不同的平台下占据都是32字节
int32_t int_32_MAX_VALUE = INT32_MAX;
printf("sizeof(int_32_MAX_VALUE ) = %d\n", sizeof(int_32_MAX_VALUE));
printf("int_32_MAX_VALUE = %d\n", int_32_MAX_VALUE);
//在不同的平台下占据都是64字节
int64_t int_64_MAX_VALUE = INT64_MAX;
printf("sizeof(int_64_MAX_VALUE ) = %d\n", sizeof(int_64_MAX_VALUE));
printf("int_64_MAX_VALUE = %lld\n", int_64_MAX_VALUE);
getchar();
}
浮点数就是数学意义上的小数，C语言中分别使用float,double和long double表示，默认类型是double,浮点数的常量可以使用十进制的小数和科学计数法表示，科学计数法可以存储特大或者特小的数字，应用案例(Chapter2/datatype/float/float_const.c)如下所示
#include <stdio.h>
#include <stdlib.h>
/*
浮点数两种常量表示方法
@author tony ittimeline@163.com
@version 2018/11/24 20:27:07
*/
void main() {
//十进制
float flt = 12.0f; //小数后面加f表示float类型
double dbl = 12.0; //小数默认是double类型
//科学计数法
double db1 = 0.12e3;
//e之前必须有数字，指数必须为整数
double db2 = 12000.124e5; //e5表示10的5次方
//%f默认输出小数点后六位
printf("flt = %f \n", flt);
printf("db1 = %f \t db2 = %f\n", db1, db2);
getchar();
}
C语言在limits.h的头文件中使用常量定义了float和double的极限值,我们可以尝试使用printf函数输出该结果，分别保留 800和1500位小数,应用案例(Chapter2/datatype/float/float_limits.c)如下所示。
#include <stdio.h>
#include <float.h>
/*
浮点数极限
@author tony ittimeline@163.com
@version 2018/11/24 20:28:07
*/
void main() {
//float占据四个字节，double占据8个字节long double 大于等于double
printf("float占据的字节数量是%d\tdouble占据的字节数量是%d long double占据的字节数量是%d\n\n\n\n\n", sizeof(float), sizeof(double), sizeof(long double));
printf("float能存储的最大值是%.100f\tfloat能存储的最小值是%.100", FLT_MAX, FLT_MIN);
printf("\n\n\n\n\n\n\n\n");
printf("double能存储的最大值是%.1500f\n\n\n\n double能存储的最小值是%.1500f\n", DBL_MAX, DBL_MIN);
getchar();
}
在进行赋值运算时会发生自动类型转换，例如把一个double类型的常量10.5赋值给float类型的变量，它们占据的字节数量不同，但是能够赋值成功，因为发生了自动类型转换，应用案例(Chapter2/datatype/float/float_assignment_auto_convert.c)如下所示。
#include <stdio.h>
#include <stdlib.h>
/*
赋值运算会发生自动类型转换
@author tony ittimeline@163.com
@version 2018/11/24 20:29:07
*/
void main() {
float flt = 10.5;
//程序输出结果显示flt和10.5占据的字节数量不同，因为这里发生了数据类型转换
printf("flt占据的字节数量为%d\t 10.5占据的字节数量为%d", sizeof(flt), sizeof(10.5));
int num = 5 / 3;
printf(" num = %d\n", num);
int val = 3.2;
printf(" val =%d", val);
getchar();
}
float占据四个字节，提供的有效位是6-7位，而double占据八个字节，提供的有效位数是15-16位，如果在使用float或者double表示实数时超过有效数字，若拿来进行关系运算(例如等于)的话，会得到一个错误的结果，应用案例(Chapter2/datatype/float/float_equals.c)如下所示
/*
浮点数的相等性判断
如果实数超过有效范围，使用==判断会出错
@author tony ittimeline@163.com
@version 2018/11/24 20:30:07
*/
void main() {
float flt1 = 1.00000000001;
float flt2 = 1.00000000000000000001;
//因为float的有效数字是6-7位 这里超出有效数字 计算不准确
printf(" flt1 == flt2 ? %d\n", (flt1 == flt2)); // 输出结果1表示相等 0则表示不相等
//double精确的有效位数是15-16位，这里也超出了有效数字，计算不够正确
double db1 = 1.00000000000000000000000000000001;
double db2 = 1.000000000000000000000000000000000000000000000000000000000000000000000000000000001;
printf(" db1 == db2 ? %d\n", (db1 == db2)); // 输出结果1表示相等 0则表示不相等
system("pause");
}
int和float同样占据四个字节的内存，但是float所能表示的最大值比int大得多，其根本原因是浮点数在内存中是以指数的方式存储。
我们都知道在内存中，一个float类型的实数变量是占据32位，即32个二进制的0或者1组成
高位 低位
0000 0000 0000 0000 0000 0000 0000 0000
如上代码片段所示，从低位依次到高位叫第0位和第31位，这32位可以由三部分组成:
应用案例(Chapter2/datatype/float/float_storage.c)如下所示
#include <stdio.h>
#include <stdlib.h>
/*
浮点数在内存中的存储
@author tony ittimeline@163.com
@version 2018/11/24 20:32:07
*/
void main() {
//符号位(31位) 阶码(第30位-23位) 尾数(第22位-第0位)
float flt1 = 10.0; //4字节十六进制 41200000 二进制 0 100 00001 010 0000 0000 0000 0000 0000
float flt2 = -10.0;//4字节十六进制 c1200000 二进制 1 100 00010 010 0000 0000 0000 0000 0000
printf(" flt1的内存地址是%p\tflt2的内存地址是%p\n", &flt1, &flt2);
float flt3 = 20.0; // 字节十六进制 41a00000 二进制 0 100 0001 1010 0000 0000 0000 0000 0000
printf("变量flt3的地址是%p", &flt3);
getchar();
}
使用math.h头文件中的sqrt函数实现给定三角形三边的面积计算，应用案例
(Chapter2/datatype/float/float_triangle.c)如下所示
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
/*
根据给出的边长求面积
使用math.h文件中提供的开平方根函数
@author tony ittimeline@163.com
@version 2018/11/24 20:32:07
*/
void main() {
int a = 6;
int b = 8;
int c = 10;
int p = (a + b + c) / 2;
//sqrt返回float,这里使用赋值运算完成了类型转换
int s = sqrt(p * (p - a)*(p - b)*(p - c));
printf("s = %d", s);
printf("三角形的面积是%d", s);
printf("三角形的面积是%f", sqrt(p * (p - a)*(p - b)*(p - c)));
getchar();
}
使用math.h的pow函数实现中美GDP计算，并计算出中国GDP超过美国GDP的年份，应用案例
(Chapter2/datatype/float/float_gdp.c)如下所示
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
/*
使用math.h的pow函数实现中美GDP计算，并计算出中国GDP超过美国GDP的年份
@author tony ittimeline@163.com
@version 2018/11/24 20:29:07
*/
void main() {
double ch_current_gdp = 12.0;
double us_current_gdp = 19.70;
double ch_rate = 1.06;
double us_rate = 1.04;
double ch_gdp;
double us_gdp;
int year;
for (int i = 1; i <= 100; i++) {
ch_gdp = ch_current_gdp * pow(ch_rate, i);
us_gdp = us_current_gdp * pow(us_rate, i);
year = 2017 + i;
printf("%d年中国的GDP是%f\n", year, ch_gdp);
printf("%d年美国的GDP是%f\n", year, us_gdp);
if (ch_gdp > us_gdp) {
printf("在%d年，中国的GDP超越了美国的GDP", year);
break;
}
}
getchar();
}
字符和字符串是日常开发中经常打交道的数据类型，使用一对单引号(‘‘)包含起来的内容就是字符，C语言提供了putchar()和printf()函数输出字符(英文)，应用案例(Chapter2/datatype/char/char_io.c)如下所示
#include <stdio.h>
#include <stdlib.h>
/*
输出字符的两种方式
putchar()
printf("%c",char);
@author tony ittimeline@163.com
@version 2018/11/24 20:32:07
*/
void main() {
putchar(‘A‘);
//输出中文乱码。
putchar(‘刘‘);
printf("%c", ‘A‘);
system("pause");
}
而字符常量通常为了考虑兼容和扩展宽字符(即中文)，通常会占据4个字节，英文占据一个字节，中文占据两个字节，应用案例(Chapter2/datatype/char/char_sizeof.c)如下所示。
#include <stdio.h>
#include <stdlib.h>
/*
字符的大小
字符常量为了兼容扩展宽字符，占据的字节数量都是4个字节
而英文字符占据一个字节，中文字符(宽字符)占据两个字节
@author tony ittimeline@163.com
@version 2018/11/24 20:32:07
*/
void main() {
char chinese = ‘刘‘;
//char 占据一个字节，没办法存储中文
printf("chinese =%c ", chinese);
char ch = ‘A‘;
// sizeof()运算符求字符A的大小，这里为了兼容扩展宽字符，一般占据四个字节
printf(" ch占据的字节数量为%d\t ‘A‘占据的字节数量为%d\n", sizeof(ch), sizeof(‘A‘));
//宽字符 占据两个字节，可以存储中文
wchar_t wch = L‘我‘;
printf("宽字符占据的字节数量是%d\n", sizeof(wchar_t));
printf("字符常量我占据的字节数量是%d\n", sizeof(‘我‘));
}
如果要想输出中文字符，应用案例(Chapter2/datatype/wchar/chinese_char.c)如下所示
//引入本地化的头文件
#include <locale.h>
#include <stdio.h>
#include <stdlib.h>
/*
宽字符用于存储中文，但是如何输出中文呢？
@author tony ittimeline@163.com
@version 2018/11/24 20:33:07
*/
void main() {
//设置本地化
setlocale(LC_ALL, "chs");
//宽字符 占据两个字节，可以存储中文
wchar_t wch = L‘我‘;
//使用wprintf()函数输出中文
wprintf(L"%c\n", wch);
getchar();
}
字符在内存中是以数字的方式存储，而ASC||码表规定了字符对应的数字编号，当使用printf()函数以数字的输出方式打印字符时，便输出了字符对应的ASC||码表的数字编号，应用案例如下所示
字符1和整数1的区别(Chapter2/datatype/char/char_num_1.c):
/*
字符型数据存储
字符在内存中是以数字存储的，ASC||表规定了字符对应的数字编号
@author tony ittimeline@163.com
@version 2018/11/24 20:34:07
*/
void main() {
char ch = ‘1‘;
int num = 1;
//字符1和数字1的区别:占据的字节数量不一样
printf("字符1占据的字节数量是%d\t数字1占据的字节数量是%d\n", sizeof(ch), sizeof(num));
//字符1对应的数字是49，即求ASC码值
printf("字符1对应的ASC||码表的编号是%d\n", ch);
printf("ch=%c\n", ch);
printf("整数1对应的ASC||码表的字符是%c", num);
system("pause");
}
字符0，‘\0‘和整数0的区别(Chapter2/datatype/char/char_num_0.c)
#include <stdio.h>
#include <stdlib.h>
/*
字符0 对应的整数是48
整数0 对应的字符是空字符
\0对应的也是空字符，和整数0的效果一样
*/
void main() {
char ch_zero = ‘0‘;
char ch_num_zero = 0;
int num_zero = 0;
char ch = ‘\0‘;
printf("ch_zero占据的字节数量是%d\tnum_zero占据的字节数量是%d\tch占据的字节数量是%d\n", sizeof(ch_zero), sizeof(num_zero), sizeof(ch));
printf("字符0对应的整数编号是%d\n", ch_zero);//48
printf("整数0对应的字符是[%c]\n", num_zero);
printf("\\0对应的整数编号是[%d]\n", ch);//0
printf("\\0的意义是[%c]\n", ch);//空字符
getchar();
}
字符应用(Chapter2/datatype/char/char_convert.c):实现大写转小写
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
/*
通过ASC||码的规律实现大小写转换
@author tony ittimeline@163.com
@version 2018/11/24 20:58:07
*/
void main() {
char input = ‘\0‘;
printf("请输入一个字母\n");
scanf("%c", &input);
if (input >= ‘A‘&& input <= ‘Z‘) {
printf("你输入的是大写字母,转换为小写字母的结果是%c\n", (input + 32));
}
else if (input >= ‘a‘&&input <= ‘z‘) {
printf("你输入的是小写写字母,转换为小写字母的结果是%c\n", (input - 32));
}
system("pause");
}
字符串用于表示字符序列，也就是一串使用""包含起来的内容，接下来使用system函数调用系统命令理解下什么是字符串，应用案例(Chapter2/dateype/string/string_system_invoke.c)如下所示
#include <stdio.h>
#include <stdlib.h>
/*
字符串的应用场景
@author tony ittimeline@163.com
@version 2018/11/24 21:00:07
*/
void main() {
//改变窗口的颜色
system("color 4f");
//改变窗口的标题
system("title power by tony");
getchar();
}
C语言中的字符串以/0结尾，这也就是意味着即使双引号""中什么都没有也会占据一个字节，而中文字符串中的每个字符同样会占据两个字节，应用案例(Chapter2/datatype/string/string_const.c)如下所示
#include <stdio.h>
#include <stdlib.h>
/*
字符串常量
@author tony ittimeline@163.com
@version 2018/11/24 21:14:07
*/
void main() {
//字符串是以/0结尾，这里字符串A占据2个字节
printf("字符串A占据的字节数量是%d\n", sizeof("A"));
printf("\"\"占据的字节数量为%d\n", sizeof("")); //以\0结尾
//字符串单个中文占据两个字节
printf("字符串刘光磊占据的字节数量是%d", sizeof("刘光磊")); //每个中文占据两个字节，然后以\0结尾 因此是7个
system("pause");
}
字符串加密解密应用案例(Chapter2/datatype/string/string_encryption.c)的实现
#include <stdio.h>
#include <stdlib.h>
/*
字符串简单的加密
@author tony ittimeline@163.com
@version 2018/11/24 21:15:07
*/
void main() {
char str[5] = { ‘c‘,‘a‘,‘l‘,‘c‘,‘\0‘ };
system(str);
printf("加密之前str = %s\n", str);
for (int i = 0; i < 4; i++) {
str[i] += 1;
}
printf("加密之后str = %s\n", str);
for (int i = 0; i < 4; i++) {
str[i] -= 1;
}
printf("解密之后str = %s\n", str);
system("pause");
}
应用案例(Chapter2/datatype/string/string_sprintf_color.c):sprintf函数打印到字符串，然后借助color命令实现窗口变色
#include <stdio.h>
#include <stdlib.h>
/*
通过sprintf函数打印到字符串，然后借助color命令实现窗口变色
@author tony ittimeline@163.com
@version 2018/11/24 21:15:07
*/
void main() {
char str[20] = { 0 };
while (1) {
for (char ch = ‘0‘; ch <= ‘9‘; ch++) {
sprintf(str, "color %c%c", ch, ‘e‘);
system(str);
}
}
}
应用案例((Chapter2/datatype/string/string_sprintf_title.c)):通过sprintf函数实现整合字符串实现改变窗口标题
#include <stdio.h>
#include <stdlib.h>
/*
通过sprintf函数实现整合字符串实现改变窗口标题
@author tony ittimeline@163.com
@version 2018/11/24 21:52:07
*/
void main() {
char str[100] = { 0 };
sprintf(str, "title power by %s", "tony");
system(str);
}
bool类型只有两个值，即true和fasle,它们在内存中分别使用1和0表示，这样一个字节便可以存储bool类型的变量，应用案例(Chapter2/datatype/bool/bool_value.c)如下所示
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
/*
bool的使用
@author tony ittimeline@163.com
@version 2018/11/24 21:53:07
*/
void main() {
bool flag = true;
//占据的字节数量为1
printf("bool占据的字节数量是%d\n", sizeof(flag));
//成立的结果为1
printf("bool = %d\n", flag);
flag = false;
//不成立的结果为0
printf("bool = %d\n", flag);
system("pause");
}
bool的应用场景就是用来判断条件表达式是否成立，应用案例(Chapter2/datatype/bool/bool_expression.c)如下所示
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
/*
bool的应用场景就是用来判断表达式是否成立
@author tony ittimeline@163.com
@version 2018/11/24 21:55:07
*/
void main() {
bool flag = 5 > 30;
if (flag == true) {
printf("条件成立\n");
}
else {
printf("不成立\n");
}
getchar();
}
printf()函数在输出数据时，不会进行数据类型转换，如果想要获取预期的结果，就需要进行强转实现，应用案例(Chapter2/datatype/convert/convert_printf.c)如下所示
#include <stdio.h>
#include <stdlib.h>
/*
printf()函数与强制类型转换
@author tony ittimeline@163.com
@version 2018/11/24 21:56:07
*/
void main() {
//因为printf函数不会进行类型转换,所以这里得到一个错误的结果858993459
printf("%d\n", 12.1);
//12.1为浮点类型，这里使用强制类型转换实现转换为整数
printf("%d\n", (int)12.1);
printf("%f\n", 10); //整数按照浮点数解析，得到的结果就是0.000000
printf("%f\n", (float)10); //强制类型转换
getchar();
}
表示范围小的数据和表示范围大的数据在参与运算时，运算结果的类型会自动转换为表示范围大的类型,应用案例(Chapter2/datatype/convert/convert_auto.c)如下所示。
#include <stdio.h>
#include <stdlib.h>
/*
自动类型转换
在进行算术运算时，会发生自动类型转换 表示范围小的值自动转换为表示范围大的变量，保存精度
char->short>int->long->float->double->long double
@author tony ittimeline@163.com
@version 2018/11/24 21:57:07
*/
void main() {
char ch = ‘A‘;
printf("1.0占据的字节数量是%d\n", sizeof(1.0));
printf("字符变量ch+1的字节数量是%d\n", sizeof(ch + 1));
printf("字符变量ch+1.0的字节数量是%d\n", sizeof(ch + 1.0));
getchar();
}
在某些应用场景下需要使用到强制类型转换，例如银行账户的取整等等，强制类型转换的应用案例(Chapter2/datatype/convert/convert_force.c)如下所示
#include <stdio.h>
#include <stdlib.h>
/*
强制类型转换
@author tony ittimeline@163.com
@version 2018/11/24 22:00:07
*/
void main() {
float fl = 10.8;
float flt = 10.3;
int num = (int)fl + flt; //20.3 先把fl强制转换为int类型，然后再和flt相加
printf("num =%d\n", num);
num = (int)(fl + flt);//21 先把fl和flt相加后，强制转换为int
printf("num =%d\n", num);
getchar();
}
而需要注意的是强制类型转换则会损失原有数据的精度,应用案例(Chapter2/datatype/convert/convert_force_precision.c)如下所示
#include <stdio.h>
#include <stdlib.h>
/*
强制类型转换的案例
*/
void main() {
//这里发生了自动类型转换
double dbl = 3;
printf("dbl = %f\n",dbl);
//7.8默认是double类型，这里转换为int会损失精度
int num = 7.8;
//printf()函数没有进行数据类型转换
printf("num =%d\n",num);
getchar();
}
但是由于强制类型转换是由CPU的寄存器完成的，强制转换后不会影响原来的变量值，应用案例(Chapter2/datatype/convert/convert_force_value.c)如下所示
#include <stdio.h>
#include <stdlib.h>
/*
强制类型转换不会改变原有的值
@author tony ittimeline@163.com
@version 2018/11/24 22:02:07
*/
void main() {
double dbl = 4.5;
//赋值运算会执行类型转换，但是为了考虑到软件工程的规范，这里还是加上强制类型转换，增加代码的阅读性
int num = (int)dbl; //强制类型转换是在CPU内部的寄存器完成的
printf("dbl = %f\nnum =%d", dbl, num);
getchar();
}
在进行强制类型转换时要考虑数据的极限问题，不然会引发数据溢出，应用案例(Chapter2/datatype/conver/over_flow.c)如下所示。
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
/*
强制类型转换的溢出问题
*/
void main() {
int num = 256;
//无符号的char能存储的最大值为255，这里的256超过它的最大表示范围，因此发生数据溢出
unsigned char ch = num;
printf("num =%d \t ch = %u", num, ch);
getchar();
}
当在进行数据类型转换时，如果该数据是有符号的，在进行数据类型转换时按照符号位数来填充，如果是无符号则按照0来填充，应用案例(Chapter2/datatype/convert/convert.c)如下所示
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
/*
数据类型转换的内存原理
有符号 低字节转高字节按照符号位数填充
无符号 低字节转高字节按照0填充
@author tony ittimeline@163.com
@version 2018/11/24 21:57:07
*/
void main() {
//正数按照0填充
char ch = 1; // 二进制表示 0000 0001
int num = 1; // 二进制表示 0000 0000 0000 0000 0000 0000 0000 0001
//负数按照1填充
// 二进制表示 原码 1000 0001 反码 1111 1110 补码 1111 1111 ->ff
ch = -1;
// 二进制表示 原码 1000 0000 0000 0000 0000 0000 0000 00001
// 反码 1111 1111 1111 1111 1111 1111 1111 1110
// 补码 1111 1111 1111 1111 1111 1111 1111 1111 -> ffffffff
num = ch;
unsigned char data = 255 + 1; // 二进制补码 1 0000 0000 但是char只能占据8位，因此这里会截取8位即0000 0000，结果位0
printf("unsigned char data的地址是%p", &data);
printf("data = %d", data);
unsigned int u_num = -1; //赋值错误，能编译不意味着结果正确
// 1000 0000 0000 0000 0000 0000 0000 0000 0001
// 1111 1111 1111 1111 1111 1111 1111 1111 1110
// 1111 1111 1111 1111 1111 1111 1111 1111 1111 无符号解析结果为2的32次方即4294967295
for (int i = 0; i < u_num; i++) {
system("mspaint");
}
getchar();
}
应用案例(Chapter2/datatype/app/convert_get_money.c)
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
/*
实现偷钱程序
如果账户余额的分大于等于4分就不偷钱，小于等于3分就偷走
@author tony ittimeline@163.com
@version 2018/11/24 22:05:07
*/
void main() {
printf("请输入你的账户余额\n");
double balance = 0.0;
scanf("%lf", &balance);
// 12.34*10=123.4 123.4+0.6=124 124/10.0=12.4 12.4>12.34
double rest = (int)((balance * 10) + 0.6) / 10.0;
printf("rest = %f", rest);
if (rest < balance) {
//
printf("可以偷钱%.2f元", balance - rest);
}
getchar();
}
应用案例(Chapter2/datatype/app/convert_data.c)
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
/*
实现对小数点后三位实现四舍五入
@author tony ittimeline@163.com
@version 2018/11/24 22:03:07
*/
void main() {
printf("请输入四舍五入的三位小数\n");
double input = 0.0;
scanf("%lf", &input);
double val = 1.235;
//1.234*100=123.4 123.4+0.5=123 123/100.0=1.23
// 1.235*100=123.5 123.5+0.5=124 124/100=1.24
// 1.24>1.235
// 1.24-1.235=0.05
//1.235+0.05=1.24
double result = (int)(input * 100 + 0.5) / 100.0;
printf("result =%.2f", result);
getchar();
}
标签：sim eve 原理 com 软件 出现 的区别 组成 包含
原文地址：https://www.cnblogs.com/ittimeline/p/10015658.html
