13518219792
计算机是如何给人类解决问题？
答：
问题域的数据保存起来，然后通过某些运算从而得到结果。
程序 = 算法 + 数据结构
首先考虑保存数据，在保存数据之前要先知道数据的大小、范围、属性等
即数据类型创新互联10多年企业网站设计服务;为您提供网站建设,网站制作,网页设计及高端网站定制服务,企业网站设计及推广,对成都广告推广等多个领域拥有多年建站经验的网站建设公司。
1.数据类型
typeof(x) =>求对象x的类型
typeof(3) =>int
typeof(3.0) =>double
#includeint main()
{
typeof(1) a; //int a
return 0;
} 在C语言中，有如下数据类型
整数：
(signed可省略) char/unsigned char 字符型 保存的时ASCII码值（即整数值）
short/unsigned short 短整型
int/unsigned int 整型
long/unsigned long 长整型
......
上面都是用来描述整数
区别：
a、signed/unsigned
有符号(signed):
符号位（最高位） + 数值位
1 -->负数
0 -->正数/0
无符号（unsigned）:
所有bit位全部都是数值位（直接参与运算）
整数用8bit来表示：
1111 1110
=>无符号：254
1111 1110
+1
----------
1111 1111
+1
----------
10000 0000
=>2^8 - 2
有符号：
负数 =>|负数| ==>取反+1 ==>负数补码
负数补码 ==>-1 ==>取反 ==>|负数| ==>负数
1111 1110
-1 : 1111 1101
~ : 0000 0010
|负数| : 2
负数 : -2
b、char/short/int/long/....
所占的内存的空间大小不一样
char ->8bits
取值范围：[-128,127]
1000 0000 -- 01111 1111
unsigned char ->8bits
取值范围：[0,255]
0000 0000 -- 1111 1111
short/unsigned int 在32bits机器下面，一般为32bits
在64bits机器下面，一般为32bits
long/unsigned long 在32bits机器下面，一般为32bits
在64bits机器下面，一般为64bits
c、在不同的编译器下面，同一类型的范围也不一样
如：
keil
int 16bits
unbuntu 18.04
int 32bits
sizeof(x) 求类型x的所占的字节数，默认长整型（%ld）
1Byte = 8bits
一般符号:
sizeof(long) >= sizeof(int) >= sizeof(short) >= sizeof(char)
d、在gcc编译器中，整数默认类型时 int
typeof(3) =>int
typeof(3 + 4) =>int
typeof(3 + 4.0) =>double小数(浮点数):
float :单精度浮点型
double :双精度浮点型
long double :长双精度浮点型
区别：
a、类型不同，所占空间不同，保存精度也不同
一般来说:
sizeof(float) =>4bits
sizeof(double) =>8bits
sizeof(long double) =>16bits(64bits机器下)
b、在gcc编译器中，浮点数默认类型为 double
typeof(2.0) ==>double
typeof(2.0f) ==>float
typeof(2) ==>int
typeof(2u) ==>unsigned int
typeof(2.0 + 3) ==>double数组：一组相同类型元素的数据集合。
eg：
int a[10]; //定义一个数组，数组名为a，含有10个int类型的元素
定义变量：变量类型 + 名字
定义一个像a一样类型的对象m：
typeof(a) m;
结构体
联合体（共用体）
枚举
指针类型
void类型
void在C语言中，有三个作用：
1. void*
通用指针，用来存放任何数据类型的引用（指针）
不清楚所需指针类型时使用
void*
char *
int *
short *
....
eg:
malloc(100); //与C++中new相同 返回void*类型指针，占空间用
2. void当作函数的参数
表示此函数没有参数，不需要传参。
eg:
int func(void){}
调用：
函数名（实参）
func(3,4) //ERROR
func(); //TRUE
3.void当多函数的返回值类型
表示函数没有返回值，不需要返回值
如：
void func(int m, int n)
{
return ; //退出函数
return 0; //ERROR 退出函数 并返回0
}在C语言中，数据分为两大类：
变量
常量
变量
什么是变量？
在程序运行期间，可以改变其值的数据对象
存储变脸会对应一个存储单元且存储单元是可写的
变量的定义
变量在使用之前必须定义
语法：
变量类型 变量名（= 初值）;
可赋值也可以不赋值
变量类型
基本类型、构造类型、指针类型
变量名
一个对象的名字，标识符（对象的名字，变量、数组、函数）
在C中，C语言标识符：只能由字母、下滑写、数字，数字不能开头
为什么数字不能开头？
int 2E3; //2E3 科学计数法2000
int a;
printf("%d\n", a) //打印随机值，由编译器决定
变量的属性
eg：
int a = 1024
int:变量类型
a:变量名
1024:变量值（存储空间中保存的内容）
&a:变量的地址
变量类型
变量名
变量值（保存到存储空间中的内容）
变量的存储空间里面的内容，不管是否初始化或赋值，空间中一定会有一个值，因为存储空间中所有的bit位都有值（0/1）
变量的地址：
在程序运行时，系统会为每一个变量分配一个存储空间，用来保存这个变量的值，且这个存储空间一定会有一个唯一的编号，那么这个编号就是变量的地址。
变量的访问（read/write）
eg:
int b, a = 5;
a = 1024; // 把1024写到变量a所对应的地址中 将数值写到a的地址 ---- （1）
b = a*5; //把a的值乘5，赋值到b 读取变量a的值 ---- （2）
读（read）:从变量的存储单元中读取存储单元中的内容 读变量的值
写（write）:把一个值写到变量所对应的存储单元中 赋值
在c语言中，任何变量有且只有两层含义：
1. 变量的地址
lvalue：
localtion value 可寻址（可写）的值
left value 左值
2. 变量的值
rvalue：
readable value 可读的值
right value 右值
一般情况：
变量的左值：
变量的地址，"="的左边
变量的右值：
变量的值，"="的右边整数
在计算机中整数是以其补码形式进行保存
正数/0：
整数的补码就是原码本身
原码：就是相对应的数值转换位二进制形式
eg:
13: int 32bits
13 = 8 + 4 + 1
000000000 00000000 000000000 00001101<- 13
int a = 13;
a:
000000000 00000000 000000000 00001101
负数：
负数的补码 其原码的绝对值 取反 +1
负数 =>|负数| =>取反 =>+1 =>负数补码
eg:
-13: int 32bits
|-13|:000000000 00000000 000000000 00001101
取反：11111111 11111111 11111111 11110010
+1：11111111 11111111 11111111 11110011
-13补码：11111111 11111111 11111111 11110011
8bits 存储：
-2：1111 1110
254：1111 1110
-3：1111 1101
253：1111 1101
-4：1111 1100
252：1111 1100
......
一个负数会和一个正整数的补码形式一样即存放形式相同
=>-x 和 （2^n - x）相同 n表示用n个bits存储一个整数
n=32
-1 和 2^32 -1 相同
CPU内无符号位，对CPU来说，所有的bit位都是数值位参与运算。
eg：
int a = -13
//a在计算机中的存放形式为
//11111111 11111111 11111111 11110011
printf("%d\n", a); //-13
%d: 有符号数
符号位：1
负数补码：11111111 11111111 11111111 11110011
-1：11111111 11111111 11111111 11110010
取反：00000000 00000000 00000000 00001101
|-13|：00000000 00000000 00000000 00001101
负数：-13
printf("%u\n", a); //2^32 - 13
%u:无符号数
正数/0
11111111 11111111 11111111 11110011
即是补码，也是原码
=>2^32 - 13
unsigned int a = -1u;
-1u:
111111111 111111111 111111111 111111111
a:
111111111 111111111 111111111 111111111
printf("%d\n", a); //-1
printf("%u\n", a); //2^32-1
insigned int a = 1<< 31;
1<< 31 左移31位 10000000 00000000 00000000 00000000
printf("%d\n", a);//-2^31
%d: 有符号数
符号位：1 负数
-1:011111111 11111111 11111111 11111111
取反：10000000 00000000 00000000 00000000
|-2^31|
-2^31
printf("%u\n", a);//2^32-2^31=2^31
GNU有一个标准头文件 stdint.h
/user/include/stdint.h
整数之间赋值
char a = 127;
int b = 1024;
a = b; //不会报错，会出错
在C语言中，允许不同类型之间整数相互赋值，不同类型的整数，存储空间大小不同
char 8bits
short 16bits
int 32bits
C标准建议：
1.长 ->短
低字节直接拷贝，高字节部分全部舍弃discard，无法保存
int ->short
....
2.短 ->长
低字节直接拷贝
高字节：如果短的是无符号数，高位全部补0
如果短的是有符号数，高位补符号位
从右往左运算
char a = 127; //0000000 00000000 00000100 00000000
int b = 1024; //00000000
a = b; //00000000
=>a:32bits
00000000 00000000 00000000 000000000
printf("%d\n", a); //0
printf("%u\n", a); //0
char a = 250;
char d;
d = a + 8;
250: 00000000 00000000 00000000 11111010
a: 11111010 //即表示-6也表示250 char-128~127 此处a值位-6
a+8: typeof(a) =>char + int =>int
a int 短变长
a：11111111 11111111 11111111 11111010
+8：00000000 00000000 00000000 00001000
---------------------------------------
100000000 00000000 00000000 00000010
d:00000010
printf("%d\n", d); //2
%d: int
%d : int
char d =>int
00000000 00000000 00000000 00000010<- 最终在计算机中的存放形式
符号位: 0 - 正数
=>2
printf("%u\n", d); //2
%u : unsigned int
char d =>unsigned int
00000000 00000000 00000000 00000010<- 最终在计算机中的存放形式
无符号的数: 所有位数值位
直接运算 =>2
unsigned char a = 250;
char d;
d = a + 8;
250: 00000000 00000000 00000000 11111010
a ：11111010
a + 8 : typeof(a) =>unsigned char + int =>int
a ->int : 短 ->长
a : 00000000 00000000 00000000 11111010
+8: 00000000 00000000 00000000 00001000
-----------------------------------------
100000000 00000000 00000001 00000010
d : 00000010
printf("%d\n", d); //2
printf("%u\n", d); //2
char a = 250;
int d;
d = a + 8;
250: 00000000 00000000 00000000 11111010
a ：11111010
a + 8 : typeof(a) =>char + int =>int
a ->int : 短 ->长
a : 11111111 11111111 11111111 11111010
+8: 00000000 00000000 00000000 00001000
-----------------------------------------
100000000 00000000 00000000 00000010
d : 00000000 00000000 00000000 00000010<- d在计算机中的存放形式
printf("%d\n", d); //2
printf("%u\n", d); //2
unsigned char a = 250;
int d;
d = a + 8;
250: 00000000 00000000 00000000 11111010
a ：11111010
a + 8 : typeof(a) =>unsigned char + int =>int
a ->int : 短 ->长
a : 00000000 00000000 00000000 11111010
+8: 00000000 00000000 00000000 00001000
-----------------------------------------
00000000 00000000 00000001 00000010
d： 00000000 00000000 00000001 00000010<- d在计算机中的存放形式
printf("%d\n", d); //258
printf("%u\n", d); //258
3.常量
常量是指在程序运行期间，值不能改变
1.整型常量
代表整数的常量值。
八进制常量：以0开头，后接多个0-7字符组成
0[0-7]+ 正则表达式
eg：
0000
0123
0923 //ERROR
int a = 0123;
printf("%d\n", a); //8进制转换10进制
十六进制常量：以0x和0X开头，后面接多个或者一个0-9，a-f，A-F字符
0[x/X][0-9,a-f,A-F]+
eg：
0xF
012F//ERROR
int a = 0xf3
printf("%d\n", a);\\8进制转16进制 253
十进制常量:
[0-9]+
2.字符常量
字符常量是用单引号引起来的一个或多个字符的序列
eg：
'a'
'Z'
......
'\n' 换行
'\r' 回车
'\t' 制表
......
'\0' ASCII为0 对应的字符
在计算机中，保存一个字符，保存的是字符对应的ASCII码值
ASCII：
American Standard Code for Information Interchange
美国把每个字符给一个唯一的整数值来标识，这个整数值就是ASCII码。由于美国使用字符不超过256个，所有只需要8bits就可以保存
命令：
man ASCII 可查看相关信息
Oct: 八进制数
Dec: 十进制数
Hex: 十六进制数
Char: 字符
"A" - "Z" : 65 - 90
"a" - "z" : 97 - 122
"0" - "9" : 48 -57
int a = 'A';<=>int a = 0101;<=>int a = 0x41;<=>int a = 65;<=>int a = '\101'<=>int a = '\0x41'
字符分为两类:
a、普通字符
可以打印的字符，有形状的字符
b、特殊字符（转义字符）
不可以打印的字符
如：
'\n': 换行符
'\r': 回车符
'\t': 制表符
....
'\000':由\后面接1或2或3个八进制的数字组成,这些八进制数字用来指定所期望的字符的ASCII码值。
如：
'\101'<=>65<=>0101<=>0x41<=>'A'
'\x00':由\x后面接1或2个十六进制数字组成。十六进制数字用来指定所期望的字符的ASCII码值。
3.浮点常量
由整数部分、小数点、小鼠部分、一个e/E、一个可选的带符号的整数指数 和 一个可选的标识类型的后缀(f/F/l/L)组成
f/F：float
l/L：long double
没有后缀：double
整数部分：可省略
小数部分：可省略
但是小数部分 和 整数部分 不能同时省略
如：
float f = 2.3E3; // 2.3*10^3
float f = .3E3; // 0.3*10^3
float f = 5E-5; //5.0*10^-5
float f = E5; //ERROR 小数和整数部分不能同时省略（与变量无法区分）
4.枚举常量（结构体）
5.符号常量
宏
语法：
#define 宏名 替换对象
eg：
#define PI 3.14总结
基本类型
整数 char/int/short/long dif
浮点数 float/double/long double
构造类型
数组
结构体
联合体
枚举
指针类型
void
void*
函数参数
函数返回值变量定义 变量类型 变量名 = 初值
变量属性 变量类型 变量名 变量值 变量地址
变量访问 lvalue/rvalue3.整数
整数存储问题
补码 =>逆运算
结论1：-x = 2^n - x
结论2：CPU没有符号概念
4.不同类型的整数之间的赋值
长->短
短->长5.常量
整数常量
字符常量
'a' - 'z' 97 - 122
'A' - 'Z' 65 - 90
'0' - '9' 48 - 57
'\0' =>0
'\000':0标识一个八进制位
'\x00':0标识一个十六进制位
浮点常量
符号常量(类型) : 类型的强制转换
eg:
(char)3 : 将int类型的3强制转换为char
3 =>int你是否还在寻找稳定的海外服务器提供商？创新互联www.cdcxhl.cn海外机房具备T级流量清洗系统配攻击溯源，准确流量调度确保服务器高可用性，企业级服务器适合批量采购，新人活动首月15元起，快前往官网查看详情吧
