C語言基礎——讓我用短短幾分鐘就讓你了解資料是怎樣在記憶體中存盤的

一、資料型別的介紹

談到資料的型別，我們就會想到我們用過的最多的整型和浮點型，就以這兩個資料型別為例，我們知道在計算機記憶體中的整數與小數不像在現實生活中可以無限大，它們的大小往往都是受制約的，比如 int 型別只能占4個位元組，double 型別只能占8個位元組等等，可以說，具體的型別開辟了存盤空間的大小，而大小決定了使用范圍，還有一個問題就是，我們應該以怎樣的視角去看待記憶體空間的資料，首先我們從資料的基本型別開始了解，

1.整型

char
int
short
long
long long

整型可以理解為整數，所有的整型都分為有符號整型與無符號整型，正是因為符號位的影響，所以有符號數與無符號數的范圍就有了差別，至于有怎樣的差別，我們會在第二節中提到，
一般來說，在不注明該整型是否有無符號是，默認此型別是有符號的，所以 signed 是可省略的，char 型別的而本質也是整型，
一般的，在短整型與長整型、超長整型中，我們也可以將后面的 int 省略，所以在表示有符號整型時，int, short, long, long long 是最簡便的寫法，

2.浮點型

單精度浮點型 float
雙精度浮點型 double

浮點數可以理解為計算機存盤的小數，浮點數可以分為 float 和 double 型別，float 在記憶體中占4個位元組，double 型別在記憶體中占8個位元組，

3.構造型別

陣列型別
結構體型別 struct
列舉型別 enum
聯合型別 union

4.指標型別

char * p 指向字符型別的指標
short * p 指向短整型的指標
int * p 指向整型的指標
unsigned int * p 指向無符號整型的指標
long * p 指向長整形的指標
float * p 指向單精度浮點型的指標
double * p 指向雙精度浮點型的指標
void * p 指向空型別的指標

5.空型別

void

void 表示空型別（無型別），通常應用于函式的回傳型別、函式的引數、指標型別，

二、整型資料在記憶體中的存盤

2.1 原碼、反碼、補碼

我們知道，整型在記憶體中存盤是要開辟存盤空間的，那么開辟的存盤空間的大小取決于型別，如 int 需要開辟 4 個位元組的空間 ，也就是 32 個位元位；double 需要開辟 8 個位元組的空間，也即是 64 個位元位……
要想弄清楚整型如何在記憶體中存盤，我們就先得明白下面一段代碼是如何存盤的，

int a = 10;
int b = -10;

整型分為有符號與無符號，
計算機中的有符號數有三種表示方法：原碼、反碼、補碼，
三種表示方法均有符號位與數值位，符號位都是用 0 表示正，1 表示負，數值位三種表示方法各不相同，

原碼
直接將二進制按照正負數的形式翻譯成二進制就是原碼，例如：

int a = 10;
因為 int 型別占4個位元組，32個位元位，第一個數表示符號位
其原碼為： 00000000 00000000 00000000 00001010

int b = -10;
因為 int 型別占4個位元組，32個位元位，第一個數表示符號位
其原碼為： 10000000 00000000 00000000 00001010

正數的原、反、補碼都相同，
無符號數的原、反、補碼都相同，

反碼
將原碼的符號位不變，其他位依次按位取反就可以得到反碼，例如：

int a =10 ;
其原碼為： 00000000 00000000 00000000 00001010
其反碼為： 00000000 00000000 00000000 00001010

int b = -10 ;
其原碼為： 10000000 00000000 00000000 00001010
其反碼為： 11111111 11111111 11111111 11110101

補碼
反碼+1就得到補碼，

int a =10 ;
其原碼為： 00000000 00000000 00000000 00001010
其反碼為： 00000000 00000000 00000000 00001010
其補碼為： 00000000 00000000 00000000 00001010

int b = -10 ;
其原碼為： 10000000 00000000 00000000 00001010
其反碼為： 11111111 11111111 11111111 11110101
其補碼為： 11111111 11111111 11111111 11110110

對于整形來說：資料存放記憶體中其實存放的是補碼，

既然有以上的法則，我們就來看看記憶體中的存盤到底是不是這樣的，

a的補碼： 00000000 00000000 00000000 00001010
轉化為 16 進制：00 00 00 0a

b 的補碼： 11111111 11111111 11111111 11110110
轉化為 16 進制：ff ff ff f6

我們可以看到，記憶體中的結果和我們推算出的結果基本一致，只是順序上不同，這是我們后面會談到的大小端存盤問題，我們下節再做介紹，

2.2 計算機的大小端存盤

上一節的結果讓我們很困惑，為什么我們推算出來的結果卻與實際結果順序相反？難道還有什么特殊的約定嗎？
其實，計算機存盤資料的方式分為兩種模式：大端存盤模式和小端存盤模式，

大端存盤模式
大端模式，是指資料的高位元組保存在記憶體的低地址中，而資料的低位元組保存在記憶體的高地址中，
小端存盤模式
小端模式，是指資料的高位元組保存在記憶體的高地址中，而資料的低位元組保存在記憶體的低地址中，
可見，我們剛剛編譯代碼的機器采用的是小端存盤模式，

為什么會有大小端模式之分呢？這是因為在計算機系統中，我們是以位元組為單位的，每個地址單元都對應著一個位元組，一個位元組為8bit，但是在C語言中除了8bit的char之外，還有16bit的short型，32bit的long型（要看具體的編譯器），另外，對于位數大于8位的處理器，例如16位或者32位的處理器，由于暫存器寬度大于一個位元組，那么必然存在著一個如果將多個位元組安排的問題，因此就導致了大端存盤模式和小端存盤模式，

那么我們怎樣設計一個程式來判斷當前機器是大端存盤還是小端存盤呢?

首先我們需要一個例子，我們取 a=1;

#include<stdio.h>
int main()
{
   int a = 1;
   int ret = 0;
   ret = *((char*) &a);  //從左到右取第一個位元組的內容
   if(ret == 1)  //如果是 1 ，則是小端
   {
      printf("小端存盤\n");
   }
   else  //如果不是 1 ，則是大端
   { 
      printf("大端存盤\n");
   }
   return 0;
}

2.3 整型提升與截斷

整型提升是C程式設計語言中的一項規定：在運算式計算時，各種整形首先要提升為int型別，如果int型別不足以表示則要提升為unsigned int型別；然后執行運算式的運算，下面我們用幾個例子來說明，

例1

輸出什么?

#include <stdio.h>
int main()
{
char a= -1;
signed char b=-1;
unsigned char c=-1;
printf("a=%d,b=%d,c=%d",a,b,c);
return 0;
}

我們先從a 看起，
-1是一個整數，整型在記憶體中占32個位元位，而char型別只有8個位元位，這樣存盤時必會發生截斷：

-1的原碼：10000000 00000000 00000000 00000001
-1的反碼：11111111 11111111 11111111 11111110
-1的補碼：11111111 11111111 11111111 11111111

存盤到 a 中的補碼：

a的補碼：11111111

而在記憶體中的確也表現為這樣
好，現在我們知道存盤到 a 中的是什么了，那么對 a 進行整型列印又會發生什么呢？整型需要32個位元位，而現在的 a 只有8個位元位，所以這時需要整型提升，
因為 a 是有符號數，所以就按符號位進行整型提升：

a發生整型提升（補碼）：11111111 11111111 11111111 11111111

整型提升之后，就可以對 a 進行列印了，對 a 的原碼進行列印：

a的反碼：11111111 11111111 11111111 11111110
a的原碼：10000000 00000000 00000000 00000001

所以最后列印出的結果是 -1，

因為b也是有符號整數，所以原理同a,列印出的結果也是-1，

我們來看c，
c是一個無符號整數，占8個位元位，-1是有符號整數，占32個位元位，因此也會發生截斷，

-1的原碼：10000000 00000000 00000000 00000001
-1的反碼：11111111 11111111 11111111 11111110
-1的補碼：11111111 11111111 11111111 11111111

存盤到 c 中的補碼：

c的補碼：11111111

此時對 c 進行整型列印，需要整型提升，因為 c 是無符號數，提升時高位補0：

c進行整型提升后（補碼）：00000000 00000000 0000000 11111111

因為無符號數的原碼、反碼、補碼都相同，所以列印出來的結果就是255，

例2
輸出什么？

#include <stdio.h>
int main()
{
char a = -128;
printf("%u\n",a);
return 0;
}

-128是一個有符號整型數，要存到有符號字符型別中去，因此要發生截斷：

-128的原碼：10000000 00000000 00000000 10000000
-128的反碼：11111111 11111111 11111111 01111111
-128的補碼：11111111 11111111 11111111 10000000

發生截斷后

a 的補碼為：10000000

再將a 進行無符號整型列印，首先要進行整型提升，因為a是有符號型別，所以高位補符號位：

a 發生整型提升后（補碼）： 11111111 11111111 11111111 10000000

以無符號數的形式列印出來，原碼、反碼、補碼都相同，最高位1是數值位，所以列印出來的值為4294967168，

例3

輸出什么？

#include <stdio.h>
int main()
{
char a = 128;
printf("%u\n",a);
return 0;
}

這一題與上一題類似，只不過賦給a的值改變了符號，

128的原碼、反碼、補碼都相同：
00000000 00000000 00000000 10000000

發生截斷之后：

a 的補碼： 10000000

按符號位進行提升：

a發生整型提升之后（補碼）：11111111 11111111 11111111 10000000

因為要按照無符號整數進行列印，所以原碼、反碼、補碼相同，列印出的結果為4294967168，
例4

輸出什么？

#include<stdio.h>
int main()
{
int i = -20;
unsigned int j = 10;
printf("%d\n",i+j);
return 0;
}

首先我們寫出-20的補碼和無符號數10的補碼：

-20的原碼：10000000 00000000 00000000 00010100
-20的反碼：11111111 11111111 11111111 11101011
-20的補碼：11111111 11111111 11111111 11101100
10的補碼： 00000000 00000000 00000000 00001010

將-20的補碼與10的補碼相加：

相加后的結果： 11111111 11111111 11111111 11110110

要想按有符號整型列印：

相加后的反碼：11111111 11111111 11111111 11110101
相加后的原碼：10000000 00000000 00000000 00001010

結果為-10，

例5

輸出什么?

#include<stdio.h>
int main()
{
unsigned int i;
for(i=9;i>=0;i--)
{
printf("%u\n",i);
}
return 0;
}

因為 i 是一個無符號整型變數，所以它的值不可能為負，隨著回圈的不斷進行，當 i=0 時，列印出0，i - -, i 不會變成 -1 那會變成什么呢？我們從記憶體的角度來看問題，

無符號整數 0 的補碼為：

00000000 00000000 00000000 00000000
可以看作 1 00000000 00000000 00000000 00000000被截斷32位

在此基礎上減去1 ：

11111111 11111111 11111111 11111111

而無符號數的原反補碼相同，所以就會輸出以上的無符號數：4,294,967,295
因為仍然是大于等于0的數，所以會一直無限回圈下去，

例6

輸出什么？

int main()
{
char a[1000];
int i;
for(i=0; i<1000; i++)
{
a[i] = -1-i;
}
printf("%d",strlen(a));
return 0;
}

這一題讓我們求字串的長度，我們知道 strlen 函式什么時候得到回傳值取決于什么時候遇到 ‘\0’ , a 是一個存放字符型別的陣列，陣列內元素的范圍應該在 -128~127內，否則就會發生截斷，
當 i = 126 時，a[126] = -127,

-127的原碼：11111111
-127的反碼：10000000
-127的補碼：10000001

進行下一次回圈時，i=127, a[127]又會在a[126]的基礎上減一，得到a[127]的補碼：

10000000

有人就會問了，這不是0嗎？
從表面上來說，它的值的確是0，但是

00000000

也是0，這樣0的表示不就不唯一了嗎？這可就麻煩了，出大事了，因此C語言規定 10000000 在這種情況下的值為 -128 ，所以a[127] = -128，再進行下一次回圈， i=128, a[128] = a[127] -1 ,會是-129嗎？不會，因為 char 的范圍是 -128~127,我們再從記憶體上來看：

10000000 減去1
得到 01111111 ------ 127

因為這次減法之后，符號位變成了0，而正數的原碼、反碼、補碼相同，結果 a[128] = 127，這樣一直回圈，a[255] = 0,當 strlen 函式查找到 0 ，就會回傳 0~254的長度，結果為255，

例7

輸出什么？

#include <stdio.h>
unsigned char i = 0;
int main()
{
for(i = 0;i<=255;i++)
{
printf("hello world\n");
}
return 0;
}

i 是一個全域的無符號字符型別變數，在for回圈內，i 從0增加到255，列印256次 hello world ,因為無符號字符型的取值范圍是 0~255 ，如果將 255 再加一，會怎么樣呢？

255的原反補碼：11111111

若在此基礎上加1，結果會變成

1 00000000

此時最高位會溢位，char 型別截取了低8位，得到：

0000 0000

所以255 + 1 的結果是 0，這樣 ，0 <= 255,又可以回圈下去，因此該程式會死回圈列印 hello world，

經過了上面若干道題的思考，整型的提升與截斷應該很簡單了吧，
在進行整型提升時，觀察其為有符號數還是無符號數，若是有符號數，則按符號位進行提升；若是無符號數，則在高位補0；截斷時，要知道應該截取多少位，從低位元組到高位元組進行截取，另外我們還可以發現字符型別的加減有以下規律:

其他整型的加減也類似，

三、浮點數資料在記憶體中的存盤

既然我們了解了整型在記憶體中是如何存盤的，那我們思考，浮點數與整數的最大不同就是要表示小數點與小數，浮點數的存盤是否也像整型一樣呢？我們來看接下來的一個例子：

#include<stdio.h>
int main()
{
int n = 9;
float * p = (float*)&n;
printf("n的值為%d\n",n);
printf("*p的值為%f\n",*p);

*p = 9.0;
printf("n的值為%d\n",n);
printf("*p的值為%f\n",*p);
return 0;
}

如果浮點型資料的存盤與整型資料的存盤一樣，那么我們會很自信的說出程式的結果是 ：

n的值為9
*p的值為9.000000
n的值為9
*p的值為9.000000

我們來看一下結果：
結果出乎我們的意外，這樣的結果說明了一件事：就是浮點型的存盤方式與整型的存盤方式是不同的，接下來我們來詳細了解浮點型的存盤方式，

根據國際標準IEEE（電氣和電子工程協會） 754，任意一個二進制浮點數V可以表示成下面的形式：
(-1)^S * M * 2^E
(-1)^S表示符號位，當S=0，V為正數；當S=1，V為負數，
M表示有效數字，大于等于1，小于2，
2^E表示指數位，

我們舉以下的例子來說明：

十進制數 5.0
用二進制表示為101.0
相當于 1.01×2²
S=0 ,M =1.01 ,E=2
十進制數 -7.25
用二進制表示為-111.01
相當于 -1.1101×2²
S=1 ,M=1.1101 ,E=2

IEEE 754規定： 對于32位的浮點數，最高的1位是符號位S，接著的8位是指數E，剩下的23位為有效數字M，
對于64位的浮點數，最高的1位是符號位S，接著的11位是指數E，剩下的52位為有效數字M，

IEEE 754對有效數字M和指數E，還有一些特別規定， 前面說過， 1≤M<2 ，也就是說，M可以寫成1.xxxxxx 的形式，其中xxxxxx表示小數部分，

IEEE 754規定，在計算機內部保存M時，默認這個數的第一位總是1，因此可以被舍去，只保存后面的xxxxxx部分，比如保存1.01的時候，只保存01，等到讀取的時候，再把第一位的1加上去，這樣做的目的，是節省1位有效數字，以32位浮點數為例，留給M只有23位，將第一位的1舍去以后，等于可以保存24位有效數字，

而對于E來說，情況就比較復雜，首先，E為一個無符號整數（unsigned int） 這意味著，如果E為8位，它的取值范圍為0~255；如果E為11位，它的
取值范圍為0~2047，但是，我們知道，科學計數法中的E是可以出現負數的，所以IEEE 754規定，存入記憶體時E的真實值必須再加上一個中間數，對于8位的E，這個中間數是127，對于11位的E，中間數是1023，比如2¹⁰的E是10，所以保存為32位浮點數時，必須保存成10+127=137，即10001001，

然后，指數E從記憶體中取出還可以分成三種情況，

E不全為0或不全為1
這時，浮點數就采用下面的規則表示，即指數E的計算值減去127（或1023），得到真實值，再將有效數字M加上第一位的1，

E全為0
這時，浮點數的指數E等于1-127（或者1-1023）即為真實值，有效數字M不再加上第一位的1，二十還原為0.xxxxxx的小數，這樣做是為了表示±0，以及接近于0的很小的數字，

E全為1
這時，如果有效數字M全為0，表示±∞（正負取決于符號位S），

現在我們再用學過的知識來解釋以下這一節剛開始的例子，為什么0x00000009 還原成浮點數，就成了0.000000呢？我們將9拆分為二進制數：

0000 0000 0000 0000 0000 0000 0000 1001

得到第一位符號位S=0，后面8位的指數E=00000000 ，最后23位的有效數字M=000 0000 0000 0000 00001001，浮點數就寫成：(-1)⁰ × 0.00000000000000000001001×2^(-126)=1.001×2^(-146) 顯然，這是一個很小的接近于0的正數，所以用十進制小數表示就是0.000000，

請問浮點數9.0，如何用二進制表示？還原成十進制又是多少？ 首先，浮點數9.0等于二進制的1001.0，即1.001×2³，

9.0 -> 1001.0 ->(-1)⁰×1.0012³
S=0, M=1.001,E=3+127=130

得到二進制序列：

0 10000010 001 0000 0000 0000 0000 0000

還原成十進制數，即為1091567161，

這些就是浮點型在記憶體中的存盤，
以上就是該篇文章的全部內容，感謝讀者老爺們的觀看，別忘了點贊支持下噢~