在C語言中，我們知道常見的資料型別有char、short、int 、long、long long、float、double等，以及它們所占的存盤空間大小：資料型別基礎知識
而這些型別的意義在于：

1. 使用這個型別開辟記憶體空間的大小（大小決定了使用范圍），
2. 如何看待記憶體空間的視角，

下面作具體講解，

1.型別基本歸類

整型家族：

char型：
unsigned char
signed char
short型：
unsigned short
signed short
int型：
unsigned int
signed int
long型：
unsigned long
signed long

補充說明：
1.char型到底是 signed char 還是 unsigned char ？
答：C語言標準并沒有規定，取決于編譯器
2.我們常用的 int 型就為 signed int 型，
3.在編程中其他型別如沒特別說明是unsigned型，都默認為 signed 型，

浮點型家族：

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

那么這些資料怎樣在記憶體中存盤的呢？

2.整型在記憶體中的存盤

首先了解如下概念：

2.1. 原碼、反碼、補碼

計算機中的整數有三種表示方法，即原碼、反碼和補碼，
三種表示方法均有符號位和數值位兩部分，符號位位于二進制序列的最高位，用 0 表示“正”，用 1 表示“負”，而數值位中負整數的三種表示方法各不相同，分別如下：

原碼：
直接將二進制按照正負數的形式翻譯成二進制就可以
反碼：
將原碼的符號位不變，其他位依次按位取反就可以得到了
補碼：
反碼+1就得到補碼

對于正數來說，正數的原、反、補碼都相同，
對于整形來說：無論正數還是負數，資料存放記憶體中其實存放的都是補碼，補碼，補碼！！！

這是為什么呢？
在計算機系統中，數值一律用補碼來表示和存盤，原因在于，使用補碼，可以將符號位和數值域統一處理；同時，加法和減法也可以統一處理（CPU只有加法器）此外，補碼與原碼相互轉換，其運算程序是相同的，不需要額外的硬體電路（即補碼通過+1取反也會得到原碼），
具體看代碼：

從上圖紅色圈起來的部分可以看出正負數在記憶體中是以不同的形式存盤的；當然，我相信細心的人也看出了黃色方框中資料放入的順序不一樣，這又是為什么呢？

接下來就要介紹一下大小端

2.2. 大小端

什么是大、小端：

大端（存盤）模式，是指資料的低位保存在記憶體的高地址中，而資料的高位，保存在記憶體的低地址中；
小端（存盤）模式，是指資料的低位保存在記憶體的低地址中，而資料的高位,，保存在記憶體的高地址中，

所以若為上圖中1就為大端存盤，為2就為小端存盤，
這里有一道題目：
請簡述大端位元組序和小端位元組序的概念，設計一個小程式來判斷當前機器的位元組序，
代碼如下:

int check_sys()
{
	int i = 1;
	char* p = &i;//定義為char*型別的指標，目的是為了只訪問一個位元組
	return *p;//*p=0就回傳 0，*p=1就回傳 1
}
int main()
{
	int ret = check_sys();
	if (ret == 1)
	{
		printf("小端\n");
	}
	else
	{
		printf("大端\n");
	}
	return 0;
}

所以經過測驗，當前機器為小端位元組序，

2.3. 練習

以下題目會涉及整型提升的知識，如有不明白的地方，可查看：
C語言中的整型提升

題目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;
}

決議：

char a= -1;
-1的二進制序列為：10000000000000000000000000000001
轉換成補碼：11111111111111111111111111111111
變數a為char型別，只有一個位元組（即8個位元位），所以將-1放入a中時首先會發生截斷，所以a中的二進制序列就為：11111111
signed char b=-1;
變數b的型別為signed char型，所以放入b中的二進制序列與變數a中的一樣，為：11111111
unsigned char c=-1;
c為 unsigned char型，-1放進去也會發生截斷，即為：11111111
printf(“a=%d,b=%d,c=%d”,a,b,c);
a、b在列印出來之前會根據自己的型別來整型提升，因為a、b都為char型，所以提升為: 11111111111111111111111111111111
而提升后是以補碼的形式放入記憶體中的，轉換為原碼以‘%d’(有符號整型)列印出就為：1
c為unsigned 型，列印出來之前會以unsigned形式提升，提升為：
00000000000000000000000011111111
所以‘%d’的形式列印出來就為255

題目2：
下面代碼輸出什么？

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

決議：

char a = -128;
-128的二進制序列：10000000000000000000000010000000
補碼為：11111111111111111111111110000000
a為char型，放入a中發生截斷，所以最后放入的序列為：10000000
printf("%u\n",a);
a在列印出來之前會根據自己的型別做整型提升，a 為char型，所以提升為：
11111111111111111111111110000000
以‘%u’（無符號（unsigned）整型）形式列印出來就為 4292967168

題目3：

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

決議：

此題與題目2存在的不同一點就在于a為正數，128放入a中前會發生截斷，截斷后放入的二進制序列為:10000000
最后列印的程序同題目2一樣，

補充1（算數轉換）

在以下題目前補充算數轉換相關知識：
如果某個運算子的各個運算元屬于不同的型別，那么除非其中一個運算元的轉換為另一個運算元的型別，否則操作就無法進行，下面的層次體系稱為尋常算術轉換，（以下型別依次至下而上轉換）

例如：計算a+b,其中a為int 型，b為unsigned int型，則在計算時會將a轉換為與a一致的型別，即unsigned int 型，

題目4：

int i= -20;
unsigned  int  j = 10;
printf("%d\n", i+j); 

決議：

i、j 的型別不同，所以在進行相加運算時會發生算數轉換，然后按照補碼的形式進行運算，最后列印格式為有符號整數（‘%d’形式）
i 的補碼：11111111111111111111111111101100
j 的補碼（原碼）：00000000000000000000000000001010
相加后為：11111111111111111111111111110110（補碼）
原碼為：10000000000000000000000000001010
所以列印出為 -10

補充2（char型別變數范圍）

在程式運行程序中有些情況下會涉及到各種型別的范圍，這里以char型別為例，來講解變數的范圍

所以char型別變數的范圍為 -128 ~ 127， 為了加深理解，下面一張圖能很好的說明char型別范圍中數值的變化

所以可以看出一點，在char型別中，127+1 后會變為 -128
延伸：
unsigned char 型別變數的取值范圍就為 0 ~ 255
同char型別一致，int型別變數的范圍為 -2^31 ~ 2^31-1
unsigned int 變數的范圍為 0 ~ 2^32-1

題目5：

unsigned int i;
for(i = 9; i >= 0; i--)
{
    printf("%u\n",i);
}

答案：9 8 7 6 . . . 死回圈下去
決議：

因為變數 i 為unsigned int 型，所以 i 的范圍為 0 ~ 2^32-1，始終不會小于0，回圈就會一直運行下去，最終死回圈

題目6：

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

決議：

i 為unsigned char型，所以i 會始終 <= 255,程式會一直死回圈下去

題目7：

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

決議：

a為char型，所以a變數的范圍為 -128 ~ 127
隨著回圈的運行，a[i]變化情況為：
-1 -2 -3 . . . -127 -128 127 126 . . . 0 -1 -2 . . .
strlen函式計算的是‘\0’(0)前的字符個數，所以回圈到第一次a[i]=0,時就會停止，此時0前面的數字共有255個，所以列印為255

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

常見的浮點數例如：3.14159、1E5（表示1.0x10^5次方）
浮點數家族包括： float、double、long double 型別，
浮點數表示的范圍：float.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;
}

可以看出，不同的資料型別以不同的方式列印出來的結果也各不相同，

3.1. 浮點數存盤規則

num 和 *pFloat 在記憶體中明明是同一個數，為什么浮點數和整數的解讀結果會差別這么大？
要理解這個結果，就一定要弄懂浮點數在計算機內部的表示方法，
這里就需要理解IEEE（電氣和電子工程協會） 754標準.

IEEE754標準

根據國際標準IEEE（電氣和電子工程協會） 754，任意一個二進制浮點數v可以表示成下面的形式：

即 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，

那么浮點數具體是怎樣存盤的呢？（存盤方式）

IEEE754規定：
對于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 從記憶體中取出還可以再分成三種情況：（取出方式）

1）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，補齊0到23位00000000000000000000000，則其二進制表示形式為:

2）E全為0

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

3）E全為1

這時，意味著浮點數指數的真實值為128（255-127），如果有效數字M全為0，表示±無窮大（正負取決于符號位s）

OK，關于浮點數的表示規則，就說到這里，

再次回到前面的例子

 int main()
{
 int n = 9;
 float *pFloat = (float *)&n;
 

 printf("n的值為：%d\n",n);

n 本身就是 int 型，當以‘%d’形式列印出來時不會變化，仍為 9

 printf("*pFloat的值為：%f\n",*pFloat);

*pFloat=9,即以整型的形式存入，而已‘ %f ’的形式取出（列印出來），
所以取出時是以浮點型的視角看待二進制序列的，視角如下

由于指數E全為0，所以符合上一節的第二種情況，因此，浮點數V就寫成：
V = (-1)^0 × 0.00000000000000000001001×2^(-126) =1.001×2^(-146)
顯然，V是一個很小的接近于0的正數，所以用十進制小數表示就是0.000000

 *pFloat = 9.0;
 printf("num的值為：%d\n",n);

將9.0放入 *pFloat中，即以浮點型方式將9.0存入n中 ，又以‘%d’（整型）形式取出，方式為：
首先，浮點數9.0等于二進制的1001.0，即1.001×2^3，
而 9.0 -> 1001.0 -> (-1)^0 x 1.001 x 2 ^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，即

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

 printf("*pFloat的值為：%f\n",*pFloat);

將9.0放入 *pFloat中,即以浮點型的形式將資料存入記憶體中，而已‘%f’的形式將資料取出，因為存入與取出的形式一致，所以列印出來為9.000000

以上就是對資料在內中存盤的決議，