1、数据类型介绍

在前面我们已经学习了基本的内置类型(内置类型就是语言自身定义的类型)：

char                //字符数据类型

short               //短整型

int                   //整形

long                //长整形

long long        //更长的整形

float                //单精度浮点型

double            //双精度浮点型

//C语言有没有字符串类型呢？

答案是：C语言没有字符串类型，但是可以用字符数组或字符指针来表示。

以及他们所占存储空间的大小(sizeof-操作符-计算操作数的类型长度-单位字节)。

类型的意义：

1、使用这个类型开辟内存空间的大小（大小决定了使用范围）

2、如何看待内存空间的视角（如：int的内存空间存放整形，float的内存空间存放单精度浮点数）

总结：类型是用来创建变量的，在我们创建变量的时候，我们要选择合适的类型，合理的利用内存空间。

1.1 类型的基本归类：

整形家族：

char

       unsigned char

       signed char

short

       unsigned short [int]

       [signed] short [int]

int

       unsigned int

       [signed] int

long

       unsigned long [int]

       [signed] long [int]

long long

       unsigned long long [int]

       [signed] long long [int]

讲解：

1、char为什么属于整形家族？

答案是：字符在存储的时候存储的是ASCII码值，ASCII码值是整数，所以在归类的时候，字符属于整形家族。

2、signed和unsigned的介绍：

（1）signed和unsigned是用来修饰整形家族类型的(注：不能修饰浮点类型，因为他们带有符号)。

（2）signed：有符号的，二进制最高位为符号位，其它位为数据位，正负数均可正常存放。(最高位为1表示负数，最高位为0表示正数)

（3）unsigned：无符号的，自身所有二进制位都是数据位，存放正数。(所以无符号数的最大值要比有符号的大约一半，因为有符号数的最高位被用来做符号位)

（4）默认的short、int、long、long long为有符号数。(上方[]表示里面的内容可以省略)

（5）char本身到底是signed char还是unsigned char取决于编译器的实现。（常见的编译器char==signed char）

浮点数家族：

float        //单精度浮点型

double    //双精度浮点型

注：字面浮点数默认为双精度浮点型，所以在定义单精度浮点型时要强制类型转换。

如：float data = 3.14f;

构造类型：（自定义类型）

数组类型           //因为数组大小和元素类型，是我们根据需求自己定义的，所以属于构造类型

结构体类型        struct

枚举类型            enum

联合类型            union

指针类型：

（1）对指针的理解：指针变量前的第一个*与变量结合表示它是指针，再往前面所有东西表示这个指针所指向对象的类型。

（2）指针类型的意义：指针是有类型的，指针的类型决定了指针+-整数的步长，指针解引用操作的时候的权限。

int *pi;

char *pc;

float *pf;

void *pv;

空类型：

void表示空类型（无类型）

通常应用于函数的返回类型、函数的参数、指针类型。

图解：

2、整形在内存中的存储

以前我们知道一个变量的创建是要在内存中开辟空间的。空间的大小是根据不同的类型而决定的。

那接下来我们谈谈数据在所开辟内存到底是如何存储的？

2.1  原码、反码、补码

计算机中的整数有3种二进制表示方法，即原码、反码和补码。

三种表示方法均有符号位和数值位两部分，符号位都是用0表示“正”，用1表示“负”，而数值位——

正数的原、反、补码都相同。

负整数的三种表示方法各不相同。

原码：

       直接将数值按照正负数的形式翻译成二进制就可以得到原码。

反码：

       原码的符号位不变，其他位依次按位取反就可以得到反码。

补码：

       反码+1就得到补码。

对于整形数据来说：数据在内存中存储的是补码。

为什么是补码呢？

在计算机系统中，数值一律用补码来表示和存储。原因在于，使用补码，可以将符号位和数值域统一处理；

同时，加法和减法也可以统一处理（CPU只有加法器）此外，补码与原码相互转换，其运算过程 是相同的，不需要额外的硬件电路。

图示：

代码1：验证整形数值在内存中统一用补码存储

int main()
{
  int a = 1;
  int b = 1;
  int c = a - b;
  //c = 1 - 1
  //CPU只有加法器,所以转化成 1 + （-1）
  //如果我们使用原码来计算：
  //1的原码：00000000000000000000000000000001
  //-1的原码：10000000000000000000000000000001
  //1+（-1）的原码：10000000000000000000000000000010--->-2，err
  //我们使用补码计算：
  //1的补码：00000000000000000000000000000001
  //-1的补码：11111111111111111111111111111111
  //1+（-1）的补码：00000000000000000000000000000000--->0,turn
  //所以在计算机中对于整型数据：存放的是补码
  return 0;
}

代码2：观察数据在内存中的存储

a和b确实在内存中存储的是补码，但是我们发现顺序有点不对劲（倒着存放的）。

这又是为什么？

2.2  大小端介绍

什么是大端小端：

大端（存储）模式，是指数据的低位保存在内存的高地址中，而数据的高位，保存在内存的低地址中；

小端（存储）模式，是指数据的低位保存在内存的低地址中，而数据的高位,，保存在内存的高地址中

为什么有大端和小端呢？

答案是：因为计算机系统中，我们是以字节为单位的，每个地址单位都对应着一个字节，一个字节8bit。但是在C语言中除了8bit的char之外，其他类型所占空间都大于8bit，另外，对于位数大于8位 的处理器，例如16位或32位的处理器，由于寄存器宽度大于一个字节，那么必然存在着一个如何 将多个字节安排的问题。因此就导致了大端存储和小端存储模式。

如图解：

我们常用的 X86 结构是小端模式，而 KEIL C51 则为大端模式。很多的ARM，DSP都为小端模式。有些ARM处理器还可以由硬件来选择是大端模式还是小端模式。

百度2015年系统工程师笔试题：

请简述大端字节序和小端字节序的概念，设计一个小程序来判断当前机器的字节序。

分析： 大端字节序是把一个数据的低字节的内容存放在高地址处，高字节的内容存放在低地址处；小端字节与之相反。我们定义一个整形变量a赋值1(最简单)，取出它的第一位字节的内容，内容等于1则为小端，反之为大端。

图示：

代码：

#include<stdio.h>
//自定义函数——返回整数1的第一个字节的内容
int check_sys()
{
  int a = 1;
  return *(char*)&a;//把a的类型强制转换为char*,再解引用得到a第一个字节的内容
}
int main()
{
  //调用函数
  int ret = check_sys();
  //判断结果是否为1.为1则为小端，反之为大端
  if (1 == ret)
  {
    printf("小端\n");
  }
  else
  {
    printf("大端\n");
  }
  return 0;
}

运行结果：小端（VS2019是小端字节序存储）

2.3  练习

代码1：

#include <stdio.h>
int main()
{
  char a = -1;
  //-1是整数，32bit位
  //原码：10000000000000000000000000000001
  //反码：11111111111111111111111111111110
  //补码：11111111111111111111111111111111
  //因为a的类型是char(在VS2019默认为有符号的)，所以截断
  //a的补码：11111111
  signed char b = -1;
  //b和a一样
  unsigned char c = -1;
  //c的补码：11111111
  printf("a=%d,b=%d,c=%d", a, b, c);
  //%d是打印有符号的十进制整数（原码）
  //a和b的类型都为有符号的char,整形提升是按照变量的数据类型的符号位来提升的
  //a和b提升:11111111111111111111111111111111
  // 取反：10000000000000000000000000000000
  // 原码：10000000000000000000000000000001 -->-1
  //c的类型是无符号的char,整形提升直接高位补0
  //c的提升：00000000000000000000000011111111 -->255
  return 0;
}

代码2：

#include <stdio.h>
int main()
{
  char a = -128;
  //a的补码：10000000
  printf("%u\n", a);
  //%u是打印无符号的十进制整数(无符号-所有位都是数值位)
  //a的类型是有符号的char，整形提升是按照变量的数据类型的符号位来提升的
  //a提升：11111111111111111111111110000000 -->4294967168
  return 0;
}

代码3：

#include <stdio.h>
int main()
{
  char a = 128;
  //128的补码：00000000000000000000000010000000
  //a是char--截断：10000000
  printf("%u\n", a);
  //%u是打印无符号十进制整数(无符号--32bit位均为数值位)
  //a的类型是有符号的char，整形提升是按照变量的数据类型符号位来提升
  //a提升：11111111111111111111111110000000 -- 4294967168
  return 0;
}

char的取值范围：

代码4：

#include<stdio.h>
int main()
{
  int i = -20;
  //-20的原码：10000000000000000000000000010100
  //-20的反码：11111111111111111111111111101011
  //-20的补码：11111111111111111111111111101100
  unsigned int j = 10;
  //10的补码：00000000000000000000000000001010
  printf("%d\n", i + j);
  //虽然i+j的类型是无符号的，但是最后格式化成为有符号整数
  //①i+j的补码：11111111111111111111111111110110
  //取反：10000000000000000000000000001001
  //+1:   10000000000000000000000000001010 -->-10
  return 0;
}

代码5：

#include<stdio.h>
#include<windows.h>
int main()
{
  unsigned int i;
  for (i = 9; i >= 0; i--)//死循环，因为i是无符号类型的，它的最小取值都为0
  {
    printf("%u\n", i);
    Sleep(1000);//Sleep函数是实现睡眠，单位毫秒
  }
  return 0;
}

积累：当你使用无符号类型做循环变量时，一定要格外小心！

代码6：

#include<stdio.h>
#include<string.h>
int main()
{
  char a[1000];
  int i;
  for (i = 0; i < 1000; i++)
  {
    a[i] = -1 - i;//-1 -2 -3 …… -128 127 126 …… 2 1 0 -1 ……
  }
  //strlen是计算字符串的长度的，统计‘\0’(ASCII值0)之前的
  printf("%d", strlen(a));//128 + 127 = 255
  return 0;
}

3、浮点数在内存中的存储

常见的浮点数：

3.14159

1E10 //1.0*10^10

浮点数家族包括： float、double、long double 类型。

浮点数表示的范围：float.h中定义     //整形的取值范围可以在“limits.h”中查看

3.1  一个例子

浮点数存储的例子：

​
#include<stdio.h>
int main()
{
  int n = 9;
  float* pFloat = (float*)&n;
  printf("n的值为：%d\n", n);//%d是打印有符号的十进制整数
  printf("*pFloat的值为：%f\n", *pFloat);//%f是打印有符号的单精度浮点数
  *pFloat = 9.0;
  printf("num的值为：%d\n", n);//%d是打印有符号的十进制整数
  printf("*pFloat的值为：%f\n", *pFloat);//%f是打印有符号的单精度浮点数
  return 0;
}
​

运行结果是什么呢？

运行之后我们得到了很怪的结果，这是为什么呢？

答案是：整形和浮点型在内存中的存储方式是截然不同的，接下来我们来学习浮点型在内存中是怎么存储的。

3.2  浮点数存储规则

num 和 *pFloat 在内存中明明是同一个数，为什么浮点数和整数的解读结果会差别这么大？

要理解这个结果，一定要搞懂浮点数在计算机内部的表示方法。

解读：

根据国际标准IEEE（电气和电子工程协会）754，任意一个二进制浮点数V可以表示成下面的形

式：

V = (-1)^S * M * 2^E

(-1)^S表示符号位，当S=0，V为正数；当S=1，V为负数。

M表示有效数字，大于等于1，小于2。

2^E表示指数位。

图解：

IEEE  754规定：

对于32位的浮点数，最高的1位是符号位s，接着的8位是指数E，剩下的23位为有效数字M。

对于64位的浮点数，最高的1位是符号位S，接着的11位是指数E，剩下的52位为有效数字M。

那S，M，E，是怎么存储的呢？

（1）S的存储：

       S = 0，V为正数；S = 1，V为负数。M和E比较复杂，下面我们详细对其讲解。

IEEE 754对有效数字M和指数E，有一些特别的规定。

（2）M的存储：

前面说过， 1≤M<2 ，也就是说，M可以写成 1.xxxxxx 的形式，其中xxxxxx表示小数部分。

IEEE 754规定，在计算机内部保存M时，默认这个数的第一位总是1，因此可以被舍去，只保存后面的 xxxxxx部分（提高了浮点数的精度）。

（3）E的存储：

首先，E为一个无符号整数（unsigned int）

这意味着，如果E为8位，它的取值范围为0~255；如果E为11位，它的取值范围为0~2047。但是，我们知道，科学计数法中的E是可以出现负数的，所以IEEE 754规定，存入内存时E的真实值必须再加上一个中间数，对于8位的E，这个中间数是127；对于11位的E，这个中间数是1023。

然后，指数E从内存中取出还可以再分成三种情况：

①E不全为0或不全为1（即有0也有1）

这时，浮点数就采用下面的规则表示，即指数E的计算值减去127（或1023），得到真实值，再将有效数字M前加上第一位的1。

②E为全0

这时，浮点数的指数E等于1-127（或者1-1023）即为真实值 ，有效数字M不再加上第一位的1，而是还原为0.xxxxxx的小数。 这样做是为了表示±0，以及接近于0的很小的数字。

③E为全1

此时，指数E全为1，表示无穷大（正负取决于符号位S）。

现在我们来解释一下前面3.1的题目：

#include<stdio.h>
int main()
{
  int n = 9;
  //9的补码：00000000000000000000000000001001
  float* pFloat = (float*)&n;
  printf("n的值为：%d\n", n);
  //%d是打印有符号的十进制整数
  //00000000000000000000000000001001 ---9
  printf("*pFloat的值为：%f\n", *pFloat);
  //%f是打印有符号的单精度浮点数
  //0 00000000 00000000000000000001001
  //s = 0
  //m = 0.00000000000000000001001(e为全0，m不再加上1)
  //e = 1-127 = -126
  //v = (-1)^0 * 0.00000000000000000001001 * 2^-126 --->0.000000
  *pFloat = 9.0;//pfloat指向的是单精度浮点型的空间
  //1001.0
  // (-1)^0 * 1.0010 * 2^3
  //s = 0
  //m = 1.001
  //e = 3
  //9.0在内存中的存储：01000001000100000000000000000000
  printf("num的值为：%d\n", n);
  //%d是打印有符号的十进制整数
  //01000001000100000000000000000000 ---1091567616
  printf("*pFloat的值为：%f\n", *pFloat);
  //%f是打印有符号的单精度浮点数
  //9.000000
  return 0;
}

通过学习了数据在内存中的存储，我们对代码的理解层次更深。