数据的储存(六千字详解)；

豆腐乾净找方规

已于 2022-08-21 15:56:14 修改

阅读量524

点赞数 2

文章标签： c语言 c++ 数据结构

于 2022-03-31 22:01:24 首次发布

本文链接：https://blog.csdn.net/m0_62976995/article/details/123864928

版权

重点

1. 数据类型详细介绍

2. 整形在内存中的存储：原码、反码、补码

3. 大小端字节序介绍及判断

4. 浮点型在内存中的存储解析

一.数据类型介绍

相信现在来看我的文章的朋友们，应该都已经学习过了基本的内置类型了

char // 字符数据类型

short // 短整型

int // 整形

long // 长整型

long long // 更长的整形

float // 单精度浮点数

double // 双精度浮点数

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

以及它们所占储存空间的大小

对于类型的意义：

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

2.如何看待内存空间的大小。

1.类型的基本归类

关于c语言的类型大概共有5类分别是：

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 ]

在这里可能会有同学疑惑了，char也是整型吗？

这里我们就要了解一下

char虽然是字符类型，但是字符类型存储的时候，存储是的字符的ASCII码z值，ASCII值是整数

对于上面的signed和unsigned的意义：

signed：有符号//只有正负的数据可以存放在有符号的变量中

unsigned：无符号//只有正数的数据可以存放在无符号的变量中

但是我们通常在写代码的时候我们会直接写char int.....而不会写unsigned int / signed int.....

这里就有个问题了，在我们没有直接标明unsigned 和 singned 的时候，各类本身是属于有符号的还是无符号的呢？

关于short

我们直接定义的时候：short s1;//在这里s1就是signed short s1的意思

即short等价于signed short

这就说明short在定义的时候定义的是有符号的变量

如果是有符号的数据，最高位是符号位

最高位是0，表示正数

最高位是1，表示负数

short - 2byte - 16bit

0000000000000000 如果对于无符号数来说最高位也是数据位

0000000000000001

0000000000000010

.........

011111111111111111

..........

111111111111111111

关于int

在c语言中规定

int n1;//n1就是有符号的，int等价于signed int

signed int n2;

unsigned int n3;

关于long

同样在c语言中规定

long n1=0;//long等价于signed long

signed long n2=0;

unsigned long =0;

对于char类型来说，我们放在最后来讲，char与其他类型不同

char c1；//char到底是有符号还是无符号的呢？

signed char c2;

unsigned char c3;

对于char的类似是不确定的，这是取决与编译器的实现

可能会有同学说char类型不是定义字符吗？哪来的正负呢随便一点不就行了吗！

但是我们在上方讲过

char虽然是字符类型，但是字符类型存储的时候，存储是的字符的ASCII码z值，ASCII值是整数

对于8个比特位也可以存负数，也可以存正数，且char不仅仅能存字符也可以存数值！！

在这里又有一个疑问了无符号数和有符号数在编写时弄反了怎么办

#include <stdio.h>
int mian()
{
	unsigned int ch = -10;
	//-10
	//10000000000000000000000000001010
	//11111111111111111111111111110101
	//11111111111111111111111111110110
	//
	printf("ch=%u\n", ch);//%u是打印无符号数，意思是你要我打印的一定是无符号，不是无符号数，我也认为是有符号数
	printf("ch=%d\n", ch);//%d是打印有符号数，意思是你要我打印的一都是有符号数，不是有符号数，我也认为是有符号数
	return 0;
}

其中这个4294967286并不是乱码！！

2.浮点数家族：

float

double

3.构造类型（自定义类型）

> 数组类型

> 结构体类型 struct

> 枚举类型 enum

> 联合类型 union

对于数组大家可能会有疑问，为什么数组类型也是自定义类型呢？

int arr[10];//arr的类型是去掉数组名后剩下的东西：int [10]

int arr[4];这时类型就发生了变化了：int [4]

char arr[4];同样也会发生变化:char [4]

个数和元素有一个发生变化,类型就发生变化

4.指针类型

int * pi ;

char * pc ;

float* pf ;

void* pv ;

指针变量是用来存放地址的！

不同的指针代表的意义是有所差异的！在上篇博客有讲：-）

5.空类型

void 表示空类型（无类型）

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

void* p;//这种指针的类型是void*的

二.整型在内存中的存储

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

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

比如：

int a = 20;
int b = -10;

定义a，b，在内存中看开辟空间来存放

我们知道为 a 分配四个字节的空间。

那如何存储？

下来了解下面的概念：

1.原码，反码，补码

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

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

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

#include <stdio.h>
//整数可以写出三种二进制表示形式
//原码：可以直接按照正负的形式翻译成二进制就行了
//反码：将原码的符号位不变，其他位依次按位取反就可以得到了
//补码：反码+1就能得到补码
// 正整数的原码，反码，补码相同
//负数的原码，反码，补码是需要计算的
//
int mian()
{
	int a = 10;//整型值
	//原码：00000000000000000000000000001010
	//反码：00000000000000000000000000001010
	//补码：00000000000000000000000000001010
	int b = -10;//整型值
	//原码：10000000000000000000000000001010
	//反码：11111111111111111111111111110101
	//补码：11111111111111111111111111110110
	return 0;
}

整数可以写出三种二进制表示形式
原码：可以直接按照正负的形式翻译成二进制就行了
反码：将原码的符号位不变，其他位依次按位取反就可以得到了
补码：反码+1就能得到补码
正整数的原码，反码，补码相同
负数的原码，反码，补码是需要计算的

!!!!:对于整形来说：数据存放内存中其实存放的是补码。

我们可以通过实践来看看是否存放的是补码：

#include <stdio.h>

int main()
{
	int a = 10;
	//原码：00000000000000000000000000001010
	//反码：00000000000000000000000000001010
	//补码：00000000000000000000000000001010
	int b = -10;
	//原码：10000000000000000000000000001010
	//反码：11111111111111111111111111110101
	//补码：11111111111111111111111111110110
	//      1111  1111  1111  1111  1111  0110
	//      F     F     F     F     F     6
	//0xff ff ff f6
	printf("%d", b);
	return 0;
}

大家有想过为什么在内存中存放的是补码呢？

#include <stdio.h>
int mian()
{
	1 - 1;
	//1-1
	//1*(-1)
	// 当我们用原码来计算时
	// 1->00000000000000000000000000000001
	// -1->10000000000000000000000000000001
	// 1+(-1)->10000000000000000000000000000010->-2
	// 我们可以看到最后得到的是-2，明显是错误的
	// 当我们使用补码的二进制计算
	// 1->00000000000000000000000000000001
	// -1->11111111111111111111111111111111
	// 1+(-1)->100000000000000000000000000000000
	// 可以看到我们得到了32位，此时要将前端的丢掉最后都得到的就是0了，正确结果
	//CPU只有加法器
	return 0;
}

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

一处理；

同时，加法和减法也可以统一处理（CPU只有加法器）此外，补码与原码相互转换，其运算过程

是相同的，不需要额外的硬件电路。

2.大小端的介绍

在上面我们看了&b在内存中存放的十六进制，但是我们可以发现它是逆序存放的，这是为什么呢？

什么大小端：

我们先定义应该十六进制数，我们可以想一想十六进制数在内存中是怎么存放的呢？

我们在上方给了三种存放方式 1.大端字节序存储 2.小端字节序存储 3.乱序存储

首先第三种方式我们可以直接排除在外，因为不可能会选择更为复杂的方式来存储的

所以我们只剩下（1）（2）两种

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

中；

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

什么是大小端：（网上资料）

为什么会有大小端模式之分呢？这是因为在计算机系统中，我们是以字节为单位的，每个地址单元

都对应着一个字节，一个字节为8
但是在C语言中除了8 bit的
char之外，还有16 bit的short型，32 bit的long型（要看具体的编

译器），另外，对于位数大于8位

的处理器，例如16位或者32位的处理器，由于寄存器宽度大于一个字节，那么必然存在着一个如

何将多个字节安排的问题。因此就

导致了大端存储模式和小端存储模式。

例如：一个 16bit 的 short 型 x ，在内存中的地址为 0x0010 ， x 的值为 0x1122 ，那么 0x11 为

高字节， 0x22 为低字节。对于大端

模式，就将 0x11 放在低地址中，即 0x0010 中， 0x22 放在高地址中，即 0x0011 中。小端模式，

刚好相反。我们常用的 X86 结构是

小端模式，而 KEIL C51 则为大端模式。很多的ARM，DSP都为小端模式。有些ARM处理器还可以

由硬件来选择是大端模式还是小端

模式。

对于大端，小端的选择是编译器本身的选择我们无法干涉，例如：vs就是选择小端字节序存储

我们这里有一道百度2015年系统工程师笔试题：

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

#include <stdio.h>
int check_sys()
{
	int i = 1;
	//00000000000000000000000000000001
	//0x 00 00 00 01
	//我们通过拿他的第一个字节来判断：大端00  小端01
	return (*(char*)&i);//（char*）强制类型转换&i，使之只能访问一个字节 然后*(char&)&i得到值
}
int main()
{
	int ret = check_sys();
	if (ret == 1)
	{
		printf("小端\n");
	}
	else
	{
		printf("大端\n");
	}
	return 0;
}

3.示例展示

理论的话我们已经看了很多了，让我们来实践一下，看看这些习题，会对数据的存储有更好的理解！！！！！！

//输出什么？
#include <stdio.h>
int main()
{
	char a = -1;
	//100000000000000000000001
	//111111111111111111111110
	//111111111111111111111111
	//
	//a打印时的补码，cher只有 一个字节，只存放八个比特位：11111111
	//但是%d打印是一个整型，
	//所以我们要对其整型提升——>无符号数补1；高位补原来变量的符号位
	//11111111111111111111111111111111//补码
	//原码：1000000000000000000000000000001
	signed char b = -1;
	//100000000000000000000001
	//111111111111111111111110
	//111111111111111111111111
	//signed 类型的打印有符号数，没有问题
	unsigned char c = -1;
	//100000000000000000000001
	//111111111111111111111110
	//111111111111111111111111
	//无符号数，打印正数，我们在上面说过%d是打印有符号数，意思是你要我打印的一都是有符号数，不是有符号数，我也认为是有符号数
	//c里面同样只能存8个比特位：11111111
	//整型提升
	//因为是unsigned 无符号类型，所以我们为高位为0
	//00000000000000000000000011111111->255
	printf("a=%d,b=%d,c=%d", a, b, c);
	//打印的是有符号数
	return 0;
}

int main()
{
	//char类型范围:-128~127
	char a = -128;
	//10000000000000000000000010000000
	//11111111111111111111111101111111
	//11111111111111111111111110000000
	//因为char只在内存中占一个字节即八个比特位；所以会发生截断！！
	// 10000000——a
	//%u——无符号整数
	// 所以要发生整型提升 
	// 1111111111111111111111110000000
	// 此时系统认为a是无符号整型，打印无符号数
  //关于在这里为什么要将8位提升到32个比特位呢？
  //主要还是因为%u是无符号"整型"，整型是32位的
	//
	printf("%u\n", a);
	
	return 0;
}

int main()
{
	int a = 128;
	//原:0000000000000000000000001000000
	//反:0000000000000000000000001000000
	//补:0000000000000000000000001000000
	//如上面那个代码一样，发生截断
	// a——10000000,我们会发现截断后和上面那个代码截断后一样
	// 进行整型提升
	// a——11111111111111111111111110000000
	//
	printf("%u\n", a);//我们会发现128和-128按%u输出的话得出的值是一样的
	return 0;
}

#include <stdio.h>
int main()
{
	unsigned int i;
	//i是无符号整型
	for (i = 9;i >= 0;i--)
	{
		printf("%d\n", i);//可以看到这里是%u
	}
	//i--到0后继续自减到1后二进制为
	//11111111 11111111 11111111 11111111
	//但是在unsigned 类型下，系统不会认为它是负数，只会认为是一个很大的正整数
	//最终形成‘死循环’
	return 0;
}

#include <stdio.h>
#include <string.h>
int main()
{
	char a[1000];
	int i;
	for (i = 0; i < 1000; i++)
	{
		a[i] = -1 - i;
	}
	printf("%d", strlen(a));

	//
	//strlen是求字符串长度，找的'\0'的位置，统计的'\0'之前出现多少字符
	// '\0'的ASCII值是0
	//
	return 0;
}

对于char类型我们可以更加深入地了解

这里我们可以看到char的范围是127~-128

我们可以看到其实char就像是一个轮回的从0~-128

豆腐乾净找方规

关注

2
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
2
评论
数据的储存(六千字详解)；

目录一.数据类型介绍1.类型的基本归类二.整型在内存中的存储1.原码，反码，补码2.大小端的介绍3.示例展示重点 1. 数据类型详细介绍 2. 整形在内存中的存储：原码、反码、补码 3. 大小端字节序介绍及判断 4. 浮点型在内存中的存储解析一.数据类型介绍相信现在来看我的文章的朋友们，应该都已经学习过了基本的内置类型了char //字符数据类型 short //短整型 int ...
复制链接

扫一扫