計算機是如何儲存人類所認知的資料呢？C語言資料的儲存

⭐️前面的話⭐️

部落客在揭開C語言神秘的面紗，簡單的C語言程式已經簡單的介紹了了C語言中一些簡單的資料類型。在本篇文章中我們繼續深入C語言中的結構類型，了解整型資料，浮點型資料在記憶體中究竟是怎樣儲存的。

📒部落格首頁：https://blog.csdn.net/m0_59139260?spm=1011.2124.3001.5343

🎉歡迎關注🔎點贊👍收藏⭐️留言📝

📌本文由未見花聞原創，CSDN首發！

✉️堅持和努力一定能換來詩與遠方！

🙏作者水準很有限，如果發現錯誤，一定要及時告知作者哦！感謝感謝！

部落客的碼雲gitee，平常部落客寫的程式代碼都在裡面。

内容導讀

• 1. 回顧C語言資料類型
• • 1.1整型資料類型
  • 1.2浮點型資料類型
  • 1.3自定義構造型資料類型
  • 1.4指針型資料類型
  • 1.5空型資料類型
• 2. 整形在記憶體中的存儲
• • 2.1原碼，反碼，補碼的概念
  • 2.2 大小端位元組序介紹及判斷
  • 2.3小試牛刀
• 3. 浮點型在記憶體中的存儲

1. 回顧C語言資料類型

在C語言中基本常見的資料類型有：

char

short

int

long

long long

float

double

等等。

現在我們來将C語言中資料類型系統地分一分類。大緻可以分為以下幾類：

整型

浮點

自定義構造

指針

空

。

1.1整型資料類型

🍒字元型char

signed char

unsigned char

🍒短整型short

signed short

unsigned short

🍒整型int

signed short

unsigned int

🍒長整形long

signed long [int]

unsigned long [int]

對于未标明是否帶符号的資料類型，比如就單說

int

char

short

long

…，一般情況下預設為有符号型，這個具體得看編譯器，大部分編譯器是預設為有符号型，是以本文所有未說明是否帶符号的類型通通預設為帶符号類型。

1.2浮點型資料類型

🍒單精度浮點型：float

🍒雙精度浮點型：double

1.3自定義構造型資料類型

🍒數組：array[ ]

🍒結構體：struct

🍒聯合：union

🍒枚舉：enum

1.4指針型資料類型

🍒整型指針：int*

🍒字元指針：char*

🍒短整型指針：short*

🍒長整型指針：long*

🍒單精度浮點指針：float*

🍒雙精度浮點指針：double*

🍒結構體指針：struct*

🍒萬能指針：void*

1.5空型資料類型

🍒void 表示空類型（無類型）

🍒通常應用于函數的傳回類型、函數的參數、指針類型。

2. 整形在記憶體中的存儲

我們已經知道整型int在記憶體中占四個位元組，但它究竟是怎樣儲存的呢？我們一探究竟。

2.1原碼，反碼，補碼的概念

計算機中的整數有三種表示方法，即原碼、反碼和補碼。

三種表示方法均有

符号位

和

數值位

兩部分，符号位都是用0表示“正”，用1表示“負”，而數值位負整數的三種表示方法各不相同。

🍓

原碼

。就是二進制定點表示法，原碼表示法在數值前面增加了一位符号位，正數該位為0，負數該位為1，其餘位表示數值的大小，即最高位為符号位，0表示正，1表示負，其餘位表示數值的大小。

🍓

反碼

。是數值存儲的一種，多應用于系統環境設定。将原碼除符号位外其他位取反就能得到反碼。

🍓

補碼

。在計算機系統中，數值一律用補碼來表示和存儲。原因在于使用補碼，可以将符号位和數值域統一處理；同時，加法和減法也可以統一處理。将反碼加上

1

就是補碼。

正整數的原碼，反碼，補碼都相同。負數三者均不同，三者轉換關系為

原碼

除符号位取反得

反碼

，

反碼

加上

1

就是

補碼

。

對整型資料來說記憶體中存放的是補碼。

2.2 大小端位元組序介紹及判斷

🍉

大端模式

，是指資料的高位元組儲存在記憶體的低位址中，而資料的低位元組儲存在記憶體的高位址中，這樣的存儲模式有點兒類似于把資料當作字元串順序處理:位址由小向大增加，而資料從高位往低位放;這和我們的閱讀習慣一緻。

🍉

小端模式

，是指資料的高位元組儲存在記憶體的高位址中，而資料的低位元組儲存在記憶體的低位址中，這種存儲模式将位址的高低和資料位權有效地結合起來，高位址部分權值高，低位址部分權值低。

比如數字

16

，将記憶體中的二進制碼轉換成16進制就是

00 00 00 10

，假設有四個位址

0x009FFA60

0x009FFA61

0x009FFA62

0x009FFA63

。

如果是

大端位元組序

進行儲存，則儲存順序如下：

記憶體位址	存儲内容
0x009FFA60	00
0x009FFA61	00
0x009FFA62	00
0x009FFA63	10

如果是

小端位元組序

進行儲存，則儲存順序如下：

記憶體位址	存儲内容
0x009FFA60	10
0x009FFA61	00
0x009FFA62	00
0x009FFA63	00

🍉

為什麼會有大小端模式之分呢？

這是因為在計算機系統中，我們是以位元組為機關的，每個位址單元都對應着一個位元組，一個位元組為

8bit

。但是在C語言中除了

8bit

的

char

之外，還有

16bit

的

short

型，

32bit

的

long

型（要看具體的編譯器），另外，對于位數大于

8

位的處理器，例如

16

位或者

32

位的處理器，由于寄存器寬度大于一個位元組，那麼必然存在着一個如果将多個位元組安排的問題。是以就導緻了大端存儲模式和小端存儲模式。

例如一個

16bit

的

short 型 x

，在記憶體中的位址為

0x0010

，

x

的值為

0x1122

，那麼

0x11

為高位元組，

0x22

為低位元組。對于大端模式，就将

0x11

放在低位址中，即

0x0010

中，

0x22

放在高位址中，即

0x0011

中。小端模式，剛好相反。我們常用的

X86

結構是小端模式，而

KEIL C51

則為大端模式。很多的ARM，DSP都為小端模式。有些ARM處理器還可以由硬體來選擇是大端模式還是小端模式。

🍉

總結

：整型資料大端模式儲存，高位在低位址，低位在高位址。小端模式儲存則相反，高位在高位址，低位在低位址。

🍉

筆試題

：

請簡述大端位元組序和小端位元組序的概念，設計一個小程式來判斷目前機器的位元組序。

//判斷是大端還是小端儲存
#include <stdio.h>
int check()
{
	int i = 1;
	//1的十六進序列為 00 00 00 01
	//使用char*的方式通路&i的空間，如果是1，說明低位存儲在低位址，為小端。
	//如果是0，說明高位存儲在低位址，為大端。
	return *((char*)&i);
}
int main()
{
	int ret = check();

	if (ret)
		printf("小端!\n");
	else
		printf("大端!\n");
	return 0;
}
           

2.3小試牛刀

🌽

小試牛刀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

為char型

-1

預設為有符号型，它的二進制原碼為

1000 0001

，記憶體中儲存的為補碼是以先要轉成補碼，除最高位取反得反碼

1111 1110

，加1的補碼

1111 1111

。在輸出的時候以

%d

形式輸出，過程中會發生

整型提升

（對于不了解整型提升的小夥伴可以閱讀部落客的一篇文章C語言中奇妙又有趣的符号——運算符(操作符）！C語言運算（操作）符最全集合（建議收藏）最後3.1.2部分，那裡有說明整型提升），

a

的補碼會先整型提升為

1111 1111 1111 1111 1111 1111 1111 1111

，它的原碼為

1000 0000 0000 0000 0000 0000 0000 0001

為數字

-1

。

b

為有符号型char型

-1

，是以結果與

a

一緻，為

-1

。

c

為無符号char型，值為

-1

，記憶體中存為補碼，無符号型整數類原碼，反碼，補碼相同，

-1

補碼為

1111 1111

，同理以

%d

形式輸出需先進行整型提升，無符号型整型提升統一補

，是以

c

整型提升後補碼為

0000 0000 0000 0000 0000 0000 1111 1111

，因為原反補碼相同，是以原碼也是補碼，是以輸出

c

的值為

255

。

💡

運作結果

：

a=-1,b=-1,c=255
D:\gtee\C-learning-code-and-project\test_810\Debug\test_810.exe (程序 30452)已退出，代碼為 0。
按任意鍵關閉此視窗. . .
           

🌽

小試牛刀2

：下面程式會輸出什麼？

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

🔑:

a

為有符号char型，值為

-128

,它比較特殊，在計算機内的補碼為

1000 0000

，當以

%u

形式列印時會發生整型提升，補碼會變為

1111 1111 1111 1111 1111 1111 1000 0000

，因為是以無符号型整數輸出，無符号整型原反補碼相同，通過電腦可以得出輸出的值為

4294967168

。

💡

運作結果

：

4294967168

D:\gtee\C-learning-code-and-project\test_810\Debug\test_810.exe (程序 38812)已退出，代碼為 0。
按任意鍵關閉此視窗. . .

           

🌽

小試牛刀3

：下面程式會輸出什麼？

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

🔑:有符号char型的範圍為

-128 到127

，

a

為有符号char型，指派

128

明顯超出資料範圍了,整數

128

的二進制序列為

0000 0000 0000 0000 0000 0000 1000 0000

将此值指派給

a

時會發生截斷，是以儲存在

a

中的補碼為

1000 0000

，這樣的話就和

小試牛刀2

那題一模一樣了，是以結果會輸出

4294967168

。

💡

運作結果

：

4294967168

D:\gtee\C-learning-code-and-project\test_810\Debug\test_810.exe (程序 37444)已退出，代碼為 0。
按任意鍵關閉此視窗. . .
           

🌽

小試牛刀4

：下面程式會輸出什麼？

#include <stdio.h>
int main()
{
	int i= -20;
	unsigned  int  j = 10;
	printf("%d\n", i+j); 
	return 0;
}
//按照補碼的形式進行運算，最後格式化成為有符号整數
           

🔑:

i

為有符号整型，值為

-20

，二進制原碼為

1000 0000 0000 0000 0000 0000 0001 0100

除符号位取反加一得補碼

1111 1111 1111 1111 1111 1111 1110 1100

j

為無符号型整數，值為

10

，原碼補碼相同，補碼為

0000 0000 0000 0000 0000 0000 0000 1010

，将倆個補碼相加得

i+j

的補碼

1111 1111 1111 1111 1111 1111 1111 0110

，以

%d

形式輸出，由于符号位為

1

是以需計算原碼，減一取反後得

1000 0000 0000 0000 0000 0000 0000 1010

，為數字

-10

。

💡

運作結果

：

-10

D:\gtee\C-learning-code-and-project\test_810\Debug\test_810.exe (程序 27368)已退出，代碼為 0。
按任意鍵關閉此視窗. . .
           

🌽

小試牛刀5

：下面程式會輸出什麼？

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

🔑:

i

為無符号整型，範圍為

0~2^32 -1

,是以這個

i

随着for循環到

後再減減，

i

在記憶體中儲存的補碼為

1111 1111 1111 1111 1111 1111 1111 1111

，由于無符号整型原反補碼相同，是以

i

實際值是一個非常大的數，是以這個循環為死循環，因為

i

永遠不會小于

，循環永遠跳不出去。

🌽

小試牛刀6

：下面程式會輸出什麼？

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

🔑:定義了一個元素為有符号型char大小為

1000

的數組

a

，有符号char類型的範圍為

-128~127

,

strlen函數

遇到

\0

後才會停止計數，

\0

的ASCII碼為

，是以

strlen

會計算從開始到數組

a

中第一個

的地方。

整數

i

從

開始增加，則數組

a

内的元素随着下标增大會減小，初始值為

-1

。是以就相當于繞着如圖這個圈逆時針旋轉，數組

a

中首個

出現時，

i

應該為

128+127=255

，是以

strlen

能夠計算在

i

為

0~254

所對應字元數組

a

的字元長度，即

255

。

根據這個圖我們可以類推其他類型的整數的範圍，以及超出範圍後會一樣進行一個類似的循環進行資料值的‘轉換’。

💡

運作結果

：

255
D:\gtee\C-learning-code-and-project\test_810\Debug\test_810.exe (程序 42544)已退出，代碼為 0。
按任意鍵關閉此視窗. . .
           

🌽

小試牛刀7

：下面程式會輸出什麼？

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

🔑:無符号char類型的範圍為

0 ~ 255

,

i

是一個無符号char類型，無論

i

怎麼加加，它的有效值一定在

0 ~ 255

範圍内，而循環能進行的條件就是

i

的值在

0 ~ 255

是以這是一個死循環，會一直輸出

hello world

。

3. 浮點型在記憶體中的存儲

進入正題之前先來看一道例題，通過這道題來引出浮點數在記憶體中究竟是這麼存儲的。

🌽

例題

：下面程式會輸出什麼？

#include <stdio.h>
int main()
{
	int n = 9;
	float* pFloat = (float*)&n;
	printf("n的值為：%d\n", n);
	printf("*pFloat的值為：%f\n", *pFloat);
	*pFloat = 9.0;
	printf("num的值為：%d\n", n);
	printf("*pFloat的值為：%f\n", *pFloat);
	return 0;
}
           

如果你不知道浮點數在記憶體中怎麼存儲的，你可能會覺得會輸出：

n的值為：9
*pFloat的值為：9.000000
num的值為：9
*pFloat的值為：9.000000
           

但是，實際上會得出以下結果：

n的值為：9
*pFloat的值為：0.000000
num的值為：1091567616
*pFloat的值為：9.000000

D:\gtee\C-learning-code-and-project\test_810\Debug\test_810.exe (程序 3232)已退出，代碼為 0。
按任意鍵關閉此視窗. . .
           

那是為什麼呢？要解釋這個問題就要弄清楚浮點數在記憶體中的儲存方式。

💡根據

國際标準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^2

。 那麼，按照上面

V

的格式，可以得出

s=0

，

M=1.01，E=2

。

十進制的

-5.0

，寫成二進制是

-101.0

，相當于

-1.01×2^2

。那麼，

s=1

，

M=1.01，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^10

的

E

是

10

，是以儲存成

32

位浮點數時，必須儲存成

10+127=137

，即

10001001

。

指數E從記憶體中取出還可以再分成三種情況：

🍇E不全為0或不全為1

這時，浮點數就采用下面的規則表示，即指數E的計算值減去

127（1023）

，得到真實值，再将有效數字M前加上第一位的1。 比如：

0.5（1/2）

的二進制形式為

0.1

，由于規定正數部分必須為1，即将小數點右移1位，則為

1.0*2^(-1)

，其階碼為

-1+127=126

，表示為

01111110

，而尾數

1.0

去掉整數部分為

，補齊0到23位

00000000000000000000000

，則其二進制表示形式為:

0 01111110 00000000000000000000000

。

🍇E全為0

這時，浮點數的指數E等于

1-127（或者1-1023）

即為真實值， 有效數字M不再加上第一位的1，而是還原為

0.xxxxxx

的小數。這樣做是為了表示

±0

，以及接近于0的很小的數字。

🍇E全為1

這時，如果有效數字M全為0，表示

±無窮大（正負取決于符号位s）

。

下面，讓我們回到一開始的問題：為什麼

0x00000009

還原成浮點數，就成了

0.000000

？ 首先，将

0x00000009

拆分，得到第一位符号位

s=0

，後面8位的指數

E=00000000

，最後23位的有效數字

M=000 0000 0000 0000 0000 1001

。

9 -> 0000 0000 0000 0000 0000 0000 0000 1001
           

由于指數E全為0，是以符合上一節的第二種情況。是以，浮點數V就寫成：

V=(-1)^0 ×0.00000000000000000001001×2^(-126)=1.001×2^(-146)

顯然，V是一個很小的接近于0的正數，是以用十進制小數表示就是

0.000000

。

再看例題的第二部分。 請問浮點數

9.0

，如何用二進制表示？還原成十進制又是多少？ 首先，浮點數

9.0

等于二進制的

1001.0

，即

1.001×2^3

。

9.0 -> 1001.0 ->(-1)^01.0012^3 -> s=0, M=1.001,E=3+127=130
           

那麼，第一位的符号位

s=0

，有效數字M等于

001

後面再加20個0，湊滿23位，指數E等于

3+127=130

，即

10000010

。 是以，寫成二進制形式，應該是

s+E+M

，即

0 10000010 001 0000 0000 0000 0000 0000
           

這個32位的二進制數，還原成十進制，正是

1091567616

。

覺得文章寫得不錯的老鐵們，點贊評論關注走一波！謝謝啦！