数据类型
什么是数据类型,为什么会有数据类型
数据类型是用于描述不同类型的数据存放在内存中的形式
**以睁眼(1)闭眼(0)形式描述,整数,那英文呢? **
数据类型分类:
1.整型(短整型,整型,长整型,长长整型,无符号短整型,无符号整型,无符号长整形,无符号长长整型)
2.
- 什么是数据?
- 有用的信息称为数据
- 数据如何存储在内存
1. 确认数据的类型 10 3.14 'a' '1' "10" "100" 'a'
2. 根据数据的类型在c语言中确认分配的数据类型 int char float double
3. 确认分配的空间是否满足数据的存放 char:1字节 short 2字节 int 4字节
- 字节(byte B):计算机存储容量的一种单位
- 比特位(bit) :二进制数,cpu计算的基本单位
- 二进制数 0 1
- 1字节 = 8位
- 1个千字节(KB) = 1024字节
- 1M = 1024KB
- 1G = 1024M
- 1T = 1024G
1.整型
-
概念:表达数据类型的数据
-
语法
int a = 123; // 定义一个专门用来存储整数的变量a int = 4个字节
-
需要注意的地方:
-
int 的本意是integer,即整数的意思
-
int a代表在内存中开辟一块区域,称为a,用来存放整数,a称为变量
-
-
变量a所占用的内存大小,在不同的系统中是不一样的,64位系统典型的大小是4字节。
- 变量a有固定的大小,因此也有取值范围,典型的范是:-2147483648到2147483647。
-
整型修饰符
-
short:用来缩短整型变量的尺寸,减少取值范围并节省内存,称为整型。
-
long:用来增长整型变量的尺寸,增大取值范围并占用更多的内存,称为长整型
-
long long:用来增长整型变量的尺寸,增大取值范围并占用更多的内存,称为长长整型
-
unsigned:用来去除整型变量的符号位,使得整型变量只能表达非负整数
short int a; // 短整型 %hd half long int b; // 长整型 %ld long long int c; // 长长整型 %lld unsigned int e; // 无符号整型 %u unsigned short int f; // 无符号短整型 %hu unsigned long int g; // 无符号长整型 %lu unsigned long long int h; // 无符号长长整型 %llu
-
-
使用整型修饰符后,关键字int可以省略:
short a; // 短整型
long b; // 长整型
long long c; // 长长整型
unsigned e; // 无符号整型
unsigned short f; // 无符号短整型
unsigned long g; // 无符号长整型
unsigned long long h; // 无符号长长整型
格式控制符
-
int 整型:%d -2^31 — + 2^31-1
-
short整型:%hd,h代表half,即一半的存储字节 printf(“xxxx”)—>log
-
long整型:%ld
-
long long整型:%lld
-
显示不同进制的前缀 : %#o、%#x
-
符号位:
- 有符号的整型数据,首位为符号位,0表示正数,1表示负数。
- 无符号的整型数据,没有符号位
练习:
定义以上类型的数据19,通过格式控制符输出
#include <stdio.h>
int main(int argc, char const *argv[])
{
// 1字节,8位,最高位为有效位,数据位7位
// 数据范围是 -128 - +127
char a = 10;
printf("%hhd\n",a);//half half
unsigned char a1 = 10;
printf("%hhu\n",a);//half half
char ch = 'a';
printf("%c\n",ch);
printf("%hhd\n",ch);
short b = 10; // short int
printf("%hd\n",b);
unsigned short b1 = 10; // unsigned short int
printf("%hu\n",b);
int c = 10;
printf("%d\n",c);
unsigned int c1 = 10;
printf("%u\n",c1);
long int d = 10;
printf("%ld\n",d);
long long d1 = 10;
printf("%lld\n",d1);
return 0;
}
- 数据类型的取值范围
unsigned char 0~255(1111 1111)
char -128... + 127(0111 1111)
short -32768~32767
unsigned short 0~65535(1111 1111 1111 1111) 2^16-1
unsigned int 0... 2^32-1 4294967295
-
编码形式:
- 原码:正数直接使用二进制来表达,比如a=100,在内存中是00…001100100
- 补码:负数用绝对值取反加一来表达,比如a=-3,在内存中是11…1111111101
-
注意负数的补码在取反加一的时候,符号位是不变的
总结
练习2 : short a = -15
1111 0001
1.当编译器以整型输出的时候%d,是以补码还原的方式解读 -1
2.当cpu将数据进行运算的时候,直接以内存中存放的方式来运行,也就是以补码的方式参与运算
3.%u输出的时候,值区域范围:0-4294967295(有符号转为无符号的时候)
4.%hhu方式打印,值域范围:0-255
(1)
unsigned char a = 255;// 0 - 255
char b = 255; // -128 - +127
printf("%d , %u\n",a,a);// 255 255
printf("%d , %u\n",b,b);// -1 4294967295
(2)
unsigned short a = -1;// 0-65535
int b = a;
printf("a = %d\n",a);//65535
printf("b = %u\n",b);//65535
(3)
unsigned char a = -1;// 0-255
unsigned int b = -1; // 0-4294967295
printf("a = %d,b = %u\n",a,b);//255,4294967295
(1)b
(2)a
-
溢出:
-
超出数据所能表达的范围,称为溢出,就像汽车里程表,最大值和最小值是相邻的
unsigned char a = 257; char b = 129; printf("a:%hhu\n",a);//half 1 // 练习 printf("b:%hhd\n",b);//-127 // 作业1 printf("b:%hhu\n",b); //129
-
-
进制:源码中可以使用八进制、十进制或者十六进制,但实际数据中一律是二进制
- 十进制(默认),比如1234 %d %u
- 八进制,比如013 %o
- 十六进制,比如0x6FF0A %x
-
进制转换
-
十进制–》二进制、八进制、十六进制
-
十进制转二进制除2取余数,倒序排序,高位补0
十进制转八进制
除8取余,倒叙排序
则12(10)=14(8).
在编程语言中,一般使用0开头来表示八进制,如上例中的十 进制数12就可以写成014。 -
-
二进制八进制十六进制转十进制
小数转二进制
使用最小二乘法
练习3:(自己总结的常考)
(179)10转2进制
(179)10转8进制
(179)10转16进制
(10011011)2 转十进制
(125)8转十进制
(B78)16转十进制
小数转二进制
2.浮点型
- 概念:用来表达实数(有理数和无理数)的数据类型
https://www.cnblogs.com/jack-ping/articles/12174949.html
博客园大佬的文章
[浮点数在内存中的存放方式][https://www.cnblogs.com/jack-ping/articles/12174949.html]
-
分类:
- 单精度浮点型(float),典型尺寸是4字节
- 双精度浮点型(double),典型尺寸是8字节
- 长双精度浮点型(long double),典型尺寸是16字节
- 占用内存越多,能表达的精度越高
float f1;//单精度 double f2;//双精度 long double f3;//长双精度
demo
double f1 = 3.1415926; // 8字节
// 默认是四舍五入保持小数点后6位
printf("%lf\n",f1);
// 输出小数点后2两位
printf("%.2lf\n",f1);
// 输出小数点后4位,保留四舍五入的特性
printf("%.4lf\n",f1);
printf("%.7lf\n",f1);
float f2 = 3.1415; // 4字节
printf("%.4f\n",f2);
// 32位系统,占用12字节
// 64位系统,占用16字节
printf("%ld\n",sizeof(long double));
// 因为32系统,适配不上long double 必须要使用64位系统
long double f3 = 3.1415926123;
printf("%.10Lf\n",f3);
「练习1」
指出下列常量的类型
'\b' 字符
1066 整型
99.44 浮点型
0XAA 十六进制的整型
2.0e30 2.0 *10^30
0x00EEABCDUL 十六进制的无符号长整形
3.字符
char ch1 = 'a'; // 'a'是字符常量,代表字母a
char ch2 = '\n'; // '\n'是不可见字符常量,代表回车
计算机中存储都是1和0,因此各种字符都必须被映射位某个数字才能存储到计算机中,这种映射关系形成的表称为ASCII码表。
字符本质上就是一个单字节的整型,支持整型所有的运算。比如:
char a = 'a';// 存储在内存中是97
char b = '1';// 存储在内存中是49
char c1 = 20;
char c2 = c1 + 'a'; // 等价于char c2 = 20+97;
printf("%c\n",c2); // 以字符形式输出117,即 'u'
printf("%d\n",c2); // 以整型形式输出117
// 小写字符转大写字符 ' ' = 32
char a7 = 'b'- ' ';
printf("%c\n",a7);
转义字符
转义字符,所有的ASCII码都可以用\加数字(一般是8进制数)来表示,而在C中
定义了一些字母前加\来表示常见的哪些不能显示ASCII字符,如\0,\t,\n称为转义字符,因为后面的字符,都不是它本来的ASCII字符意思
当编译器遇到转义字符的时候,会用特殊的方式进行处理,'\n'表示换行
'\b' : 表示退格符
printf("abcd\b");
printf("bcde\n");
'\a': 表示告警,主板蜂鸣器
'\t': tab键
'\ddd' ddd 表示八进制数,打印出来的是该数字对应的ascii码
格式为'\'后面有三个数,每个数的范围在 0 - 7
printf("%c\n",'\102');// 八进制
printf("%d\n",'\102');
'\xhh'hh 表示十六进制 打印出来的是该数字对应的ascii码
printf("%c\n",'\41');//A
4.字符串
- 定义
// 字符串的定义方式有两种:指针和数组
char *s1 = "abcd"; // 使用字符指针来表示字符串
char s2[5]= "abcd"; // 使用字符数组来表示字符串
// 注意,使用数组来定义字符串时,方括号[]里面的数字可以省略
// 不省略也可以,但必须必字符串实际占用的内存字节数要大,比如:
char s3[] = "apple";
-
在内存中的存储
- 在内存中实际上是多个连续字符的组合
- 任何字符串都以一个’\0’作为结束标记,例如:"funny story"的内存如下
字符串的内部存储细节
demo:
#include <stdio.h>
int main(int argc, char const *argv[])
{
char *s1 = "abcd";
s1 = "def";
// 输出s1与def的d的地址
printf("%p,%p,%c\n",s1,"def", *(s1+ 1));
//*(s1+1) = 'o'; // 错误的,不能修改常量的值
printf("%s\n",s1); // 输出字符串遇到'\0'结束
char s2[] = "def";
*(s2+1) = 'o';
printf("%s\n",s2); // 输出字符串遇到'\0'结束
return 0;
}
5.布尔类型数据
- 概念:布尔型数据只有真、假两种取值,非零为真,零为假。
- 语法:
bool a = 1; // 逻辑真,此处1可以取其他任何非零数值
bool b = 0; // 逻辑假 c
#include <stdio.h>
#include <stdbool.h>
int main(int argc, char const *argv[])
{
// bool类型表示0为假,非0为真
bool flage = true; // true 为1
flage = false; // false 为0
printf("%d\n",flage);
flage = -2;
printf("%d\n",flage);
return 0;
}
-
注意:
- 逻辑真除了 1 之外,其他任何非零数值都表示逻辑真,等价于 1。
- 使用布尔型 bool 定义变量时需要包含系统头文件 stdbool.h。
-
布尔型数据常用语逻辑判断、循环控制等场合。
6.常量与变量
- 概念:不可改变的内存称为常量,可以改变的内存称为变量
- 举例:
int a = 100; // a是变量,而100是整型常量
float f = 3.14; // f是变量,而3.14是浮点常量
char s[] = "abcd"; // s是变量,"abcd"是字符串常量
char ch = 'a';// ch是变量,'a'是字符常量
- 常量的类型
常量举例 | 说明 | 类型 |
---|---|---|
100 | 整型 | int |
100L | 长整型 | long |
100LL | 长长整型 | long long |
100ULL | 无符号长长整型 | unsigned long long |
3.14 | 双精度浮点型 | double |
3.14L | 长双精度浮点型 | long double |
‘a’ | 字符型 | char |
“abcd” | 字符指针(字符串) | char * |
#include <stdio.h>
int main(int argc, char const *argv[])
{
printf("%d\n",100);
printf("%ld\n",100L);
printf("%lld\n",100LL);
printf("%u\n",100U);
printf("%lu\n",100UL);
printf("%f\n",3.14);
printf("%Lf\n",3.14L);
return 0;
}
7.标准输入
- 概念:键盘是系统的标准输入设备,从键盘中输入数据被称为标准输入
- 相关函数:
scanf(); // 格式化输入函数
fgets(); // 字符串输入函数
int a;
float f;
scanf("%d", &a); // 从键盘输入一个整型,放入指定的内存地址 &a 中
scanf("%f", &f); // 从键盘输入一个浮点数,放入指定的内存地址 &f 中
// 从键盘依次输入一个整型和一个浮点型数据,用空白符隔开
scanf("%d%f", &a, &f);
char c;
char s[10];
// 从键盘输入一个字符,放入指定的内存地址 &f 中
scanf("%c", &c);
// 从键盘输入一个单词,放入指定的数组 s 中(注意不是&s)
scanf("%s", s );
fgets(s, 10, stdin); // 从键盘输入一行字符串,放入数组 s 中
- 注意1:
- scanf() 与 printf() 不同,scanf() 的格式控制串不可乱写,尤其是结尾处的 \n
- 用户必须完全按照 scanf() 中描述的输入格式控制串来输入数据,否则将出错。
- 示例:
// 此处输入时必须带逗号
scanf("%d,%d", &a, &b);
// 此处必须先输入a=,然后才能输入整数
scanf("a=%d", &a);
// 此处结束输入时按下的回车符将被scanf()误以为格式控制符,无法正常结束输入
scanf("%d\n", &a);
- 注意2:
- scanf() 的返回值,代表成功从键盘读取的数据的个数
- 无法匹配 scanf() 指定格式的数据,将被遗留在输入缓冲区中,不会消失
- 示例:
// scanf() 试图从键盘读取两个整数
// 返回值 n 代表成功读取的个数,比如:
// 输入100 200,则 n 将等于2
// 输入100 abc,则 n 将等于1
// 输入abc xyz,则 n 将等于0;输入abc 200,n也将等于0
int n = scanf("%d%d", &a, &b);
// 根据 scanf() 的返回值,判断用户是否输入了正确的格式
while(n != 2)
{
// 需要清空缓冲区并提示用户重新输入
char s[50];
fgets(s, 50, stdin);
printf("请重新输入两个整数\n");
n = scanf("%d%d", &a, &b);
}
「练习2」
编程实现如下功能:
- 如果用户输入大小写字母,则输出字母对应的ASCII码值。
- 如果用户输入ASCII码值,则输出对应的大小写字母。
#include <stdio.h>
int main(void)
{
char ch;
printf("请输入小写字母: ")
scanf("%c",&ch);
// 输出对应的大写字母
printf("%c\n",ch-' ');
//printf("%d\n",ch);
}
8.类型转换
- 概念:不一致但相互兼容的数据类型,在同一表达式中将会发生类型转换。
- 转换模式:
- 隐式转换:系统按照隐式规则自动进行的转换
- 强制转换:用户显式自定义进行的转换
- 隐式规则:从小类型向大类型转换,目的是保证不丢失表达式中数据的精度
隐式转换示例代码
char a = 'a';
int b = 12;
float c = 3.14;
float x = a + b - c; // 在该表达式中将发生隐式转换,所有操作数被提升为float
- 强制转换:用户强行将某类型的数据转换为另一种类型,此过程可能丢失精度
char a = 'a';
int b = 12;
float c = 3.14;
float x = a + b - (int)c; // 在该表达式中a隐式自动转换为int,c被强制转为int
不管是隐式转换,还是强制转换,变换的都是操作数在运算过程中的类型,是临时的,操作数本身的类型不会改变,也无法改变。
数据类型的本质
- 概念:各种不同的数据类型,本质上是用户与系统对某一块内存数据的解释方式的约定。
- 推论:
- 类型转换,实际上是对先前定义时候的约定,做了一个临时的打破。
- 理论上,可以对任意的数据做任意的类型转换,但转换之后的数据解释不一定有意义。
整型数据尺寸
- 概念:整型数据尺寸是指某种整型数据所占用内存空间的大小
- C语言标准并未规定整型数据的具体大小,只规定了相互之间的 “ 相对大小 ” ,比如:
- short 不可比 int 长
- long 不可比 int 短
- long 型数据长度等于系统字长
- 系统字长:CPU 一次处理的数据长度,称为字长。比如32位系统、64位系统。
- 典型尺寸:
- char 占用1个字节
- short 占用2个字节
- int 在16位系统中占用2个字节,在32位和64位系统中一般都占用4个字节
- long 的尺寸等于系统字长
- long long 在32位系统中一般占用4个字节,在64位系统中一般占用8个字节
- 存在问题:long int data = 2^63-1;
- 同样的代码,放在不同的系统中,可能会由于数据尺寸发生变化而无法正常运行。
- 因此,系统标准整型数据类型,是不可移植的,这个问题在底层代码中尤为突出。
可移植性整型
- 概念:不管放到什么系统,尺寸保持不变的整型数据,称为可移植性整型
- 关键:typedef
typedef int int32_t; // 将类型 int 取个别名,称为 int32_t
typedef long int64_t; // 将类型 long 取个别名,称为 int64_t
- 思路:
- 为所有的系统提供一组固定的、能反应数据尺寸的、统一的可移植性整型名称
- 在不同的系统中,为这些可移植性整型提供对应的 typedef 语句
- 系统预定义的可移植性整型:
int8_t
int16_t
int32_t
int64_t
uint8_t
uint16_t
uint32_t
uint64_t
练习:自定义以上数据类型
pid_t
time_t
size_t
... ...
demo:
#include <stdio.h>
// 可移植数据类型
typedef long long int long_32_t;
typedef long int long64_t;
// 系统自动切换
#if win64
typedef long64_t long;
#elif win32
typedef long_32_t long;
#endif
int main(int argc, char const *argv[])
{
// 问题:在32位系统中long占用4字节
// 在64位系统中long占用8字节
// 如果32位系统存放的数据大于4字节会导致内存泄漏
printf("%ld\n",sizeof(long int ));
printf("%ld\n",sizeof(long long int));
// 通过移植数据类型解决
//long_32_t data = 123456789;
long64_t data = 123456789; // 2^63-1
printf("%d\n",data);
return 0;
}
vi /usr/include/stdint.h
「练习3」
有时候我们需要使用 int32_t 类型变量代替 int 类型变量的原因是什么?
int类型是基本的数据类型,但是系统的字长不一致可能会导致使用int分配的空间大小不一致从而导致内存泄漏,不利于程序的可移植性,所以一般我们会使用系统给给我们重新定义的类型比如int_32_t,或者是我们自定的类型,一般linux系统会帮我们定义了一套根据系统的字长而确认的数据类型,一般在/usr/include/stdint.h