資料在記憶體中的存儲
文章目錄
- 資料在記憶體中的存儲
- 本章重點
-
- 1. 資料類型介紹
-
- 1.1 類型的基本歸類：
-
- 整形家族：
- 浮點數家族：
- 構造類型：
- 指針類型
- 空類型：
- 2. 整形在記憶體中的存儲
-
- 2.2 大小端介紹
- 2.2 練習
- 3. 浮點型在記憶體中的存儲
-
- 3.1 浮點數存儲的例子：
- 3.2 浮點數存儲規則
本章重點
- 資料類型詳細介紹
- 整形在記憶體中的存儲：原碼、反碼、補碼
- 大小端位元組序介紹及判斷
- 浮點型在記憶體中的存儲解析
1. 資料類型介紹
我們已經學習了基本的内置類型：
char //字元資料類型 - 字元在底層存儲的是ASCII值，歸類于“整型”
short //短整型
int //整形
long //長整型
long long //更長的整形
float //單精度浮點數
double //雙精度浮點數
//C語言有沒有字元串類型？
類型的意義：
- 使用這個類型開辟記憶體空間的大小（大小決定了使用範圍）。
- 如何看待記憶體空間的視角
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//8位元組
//一些定義
int main()
{
signed short int a = 0;
unsigned short b = 0;
char a;//有符号？還是無符号？
//取決于編譯器，大部分的編譯器下char 就是signed char
//short/int/long - 都是有符号的
short == signed short
int == signed int
long == signed long
//預設都是有符号的，若需要定義無符号，則必須定義無符号
unsigned short;
unsigned int;
unsigned long;
return 0;
}
unsigned和signed辨析
unsigned和signed範圍對比
浮點數家族：
float//4byte
double//8byte，更高精度
構造類型：
> 數組類型
> 結構體類型 struct
> 枚舉類型 enum
> 聯合類型 union
//數組類型剖析
#include <stdio.h>
int main()
{
int a = 10;
int arr[10] = {0};
printf("%d\n", sizeof(a));//4
printf("%d\n", sizeof(int));//4
printf("%d\n", sizeof(arr));//40
printf("%d\n", sizeof(int [10]));//40 - 數組類型
int arr2[5];//數組類型發生變化 - int [5]
return 0;
}
指針類型
int *pi;
char *pc;
float* pf;
void* pv;
空類型：
void 表示空類型（無類型）
通常應用于函數的傳回類型、函數的參數、指針類型。
函數參數void剖析
2. 整形在記憶體中的存儲
一個變量的建立是要在記憶體中開辟空間的，空間的大小是根據不同的類型而決定的。
資料在所開辟記憶體中到底是如何存儲的？
比如：
//-1的原碼、反碼、補碼
10000000000000000000000000000001
11111111111111111111111111111110
11111111111111111111111111111111
了解下面的概念:
原碼、反碼、補碼
有符号數的三種表示方法，即原碼、反碼、補碼。
三種表示方法均有符号位和數值位兩部分，符号位都是用0表示“正”，用1表示“負”。
**正整數：**原碼、反碼、補碼相同
**負整數：**三種表示方法各不相同。
原碼
直接将數值按照正負數的形式翻譯成二進制就可以。
反碼
将原碼的符号位不變，其他位依次按位取反就可以得到了。
補碼
反碼+1就得到補碼。
為什麼呢？
在計算機系統中，數值一律用補碼來表示和存儲。原因在于，使用補碼，可以将符号位和數值域統一處理；
同時，加法和減法也可以統一處理（CPU隻有加法器）此外，補碼與原碼互相轉換，其運算過程是相同的，不需要額外的硬體電路。
對于整形來說：資料存放記憶體中其實存放的是補碼。
2.2 大小端介紹
大端（存儲）模式，是指資料的低位儲存在記憶體的高位址中，而資料的高位，儲存在記憶體的低位址中；
小端（存儲）模式，是指資料的低位儲存在記憶體的低位址中，而資料的高位,，儲存在記憶體的高位址中。
為什麼會有大小端模式
在計算機系統中，以位元組為機關，每個位址單元都對應着一個位元組，一個位元組為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處理器還可以由硬體來選擇是大端
模式還是小端模式。
百度筆試題：
請簡述大端位元組序和小端位元組序的概念，設計一個小程式來判斷目前機器的位元組序。（10分）
#include <stdio.h>
//version1
int check_sys()
{
int a = 1;
char* p = (char*)&a;
if (*p == 1)
return 1;//小端位元組序
else
return 0;//大端位元組序
}
//version2
int check_sys()
{
int a = 1;
char* p = (char*)&a;
return *p;
}
//version3
int check_sys()
{
int a = 1;
return *(char*)&a;//取位址 - 強制類型轉換 - 解引用
//指針類型使用的啟發
}
int main()
{
//int a = 0x11223344;
//short b = 0x5566;
//如果是大端，傳回0
//如果是小端，傳回1
int ret = check_sys();
if (1 == ret)
{
printf("小端\n");
}
else
{
printf("大端\n");
}
return 0;
}
2.2 練習
1.
//輸出什麼？
#include <stdio.h>
int main()
{
char a = -1; //1.-1存入a，依次顯示原反補碼
//10000000000000000000000000000001
//11111111111111111111111111111110
//11111111111111111111111111111111
//11111111 - a
//2.限于char的大小，發生截斷，當以整數列印時，進行整型提升,按符号位補充
//11111111111111111111111111111111 - 整型提升後的結果
//11111111111111111111111111111110 - 補碼
//10000000000000000000000000000001 - 原碼：-1
signed char b = -1; //11111111 - b - 等價于a
unsigned char c = -1;//11111111 - c
//無符号數整型提升，高位補0
//00000000000000000000000011111111 - 整型提升的結果
//00000000000000000000000011111111
//00000000000000000000000011111111 - 正數原反補相同
printf("a=%d,b=%d,c=%d", a, b, c);//%d - 以有符号整數的形式進行列印
return 0;
}
2.
#include <stdio.h>
int main()
{
//1.
char a = -128; //10000000000000000000000010000000 - 原碼
//11111111111111111111111101111111 - 反碼
//11111111111111111111111110000000 - 補碼
//10000000 - a存在記憶體的8bit
//2. 整型提升 char a - 有符号數
//11111111111111111111111110000000 - 整型提升結果
//3.無符号數 - 原反補相同 - 4294967168
printf("%u\n", a);//%u - 以無符号整數列印
return 0;
}
3.
#include <stdio.h>
int main()
{
char a = 128; //1.存進a的值
//00000000000000000000000010000000 - 128原、反、補碼
//10000000 - a
//2.對10000000進行整型提升，a是char類型，1被認為是符号位
//11111111111111111111111110000000
printf("%u\n", a); //3.無符号數列印 - 原反補相同 - 4294967168
return 0;
}
4.
#include <stdio.h>
int main()
{
int i = -20; //10000000000000000000000000010100 - -20原碼
//11111111111111111111111111101011 - 反碼
//11111111111111111111111111101100 - -20的補碼
unsigned int j = 10; //00000000000000000000000000001010 - 10的補碼
//11111111111111111111111111110110 - 相加後補碼
//11111111111111111111111111110101 - 反碼
//10000000000000000000000000001010 - 結果：-10
//printf("%d\n", i + j);//-10
printf("%u\n", i + j);//%u - 無符号列印，相加後的補碼即是有效值 //4294967286
return 0;
}
//類比4.
#include <stdio.h>
int main()
{
unsigned int n = -10;//将-10的補碼放入n，記憶體隻是提供一塊空間，不關心n的類型
//10000000000000000000000000001010
//11111111111111111111111111110101
//11111111111111111111111111110110
//
//%d - 以有符号整數列印,最高位是符号位，補碼放入，原碼顯示
//%u - 以無符号整數列印,所有位都是有效位
printf("%d\n", n);//-10
printf("%u\n", n);//4294967286
return 0;
}
//按值存入，類型不重要，關鍵是怎麼讀取列印
//回顧操作符 - 算數轉換 的知識/
5.
//i>0恒成立，死循環
#include <stdio.h>
#include <windows.h>
int main()
{
unsigned int i; //無符号i
for (i = 9; i >= 0; i--) //9 8 7 6 5 4 3 2 1 0 -1
{ //11111111111111111111111111111111
printf("%u\n", i); //%u - -1被了解為無符号整數
Sleep(1000);
}
return 0;
}
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));//找'\0'(ASCII:0) 之前元素的個數 - 255
return 0;
}
7.
#include <stdio.h>
unsigned char i = 0;//unsigned char 的取值範圍 0~255
int main()
{
for (i = 0; i <= 255; i++)
{
printf("hello world\n");//死循環列印
}
return 0;
}
3. 浮點型在記憶體中的存儲
常見的浮點數：
3.14159
1E10=1.0*10^10
浮點數家族包括：
float、double、long double
類型
浮點數表示的範圍：
中定義float.h
3.1 浮點數存儲的例子：
#include <stdio.h>
int main()
{
int n = 9;
float* pFloat = (float*)&n;
printf("n的值為：%d\n", n);//9
printf("*pFloat的值為：%f\n", *pFloat);//以整數放進去，以浮點數形式拿出來，說明兩者存儲方式有别
*pFloat = 9.0;
printf("num的值為：%d\n", n);
printf("*pFloat的值為：%f\n", *pFloat);//9.000000
return 0;
}
num
和
*pFloat
在記憶體中明明是同一個數，為什麼浮點數和整數的解讀結果會差别這麼大？(留到文章最後解釋)
下面介紹浮點數在計算機内部的表示方法。
3.2 浮點數存儲規則
根據國際标準IEEE（電氣和電子工程協會） 754，任意一個二進制浮點數V可以表示成下面的形式：
- (-1)^S * M * 2^E
- (-1)^s表示符号位，當s=0，V為正數；當s=1，V為負數。
- M表示有效數字，大于等于1，小于2。
- 2^E表示指數位。
IEEE 754規定：
對于32位的浮點數(float)，最高的1位是符号位s，接着的8位是指數E，剩下的23位為有效數字M。
對于64位的浮點數(double)，最高的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位，它的取值範圍為0255；如果E為11位，它的取值範圍為02047。
但是，我們知道，科學計數法中的E是可以出現負數的，
是以IEEE 754規定，存入記憶體時E的真實值必須再加上一個中間數，對于8位的E，這個中間數是127；對于11位的E，這個中間數是
1023。
比如，2^10的E是10，是以儲存成32位浮點數時，必須儲存成10+127=137，即10001001。
//浮點數的存儲過程舉例
#include <stdio.h>
int main()
{
float f = 5.5f;//101.1
//(-1)^0 * 1.011 * 2^2
//S=0
//M=1.011
//E=2 +127存儲
//0 10000001 01100000000000000000000
//S E M
//0100 0000 1011 0000 0000 0000 0000 0000
//40 B0 00 00 - 16進制
return 0;
}
然後，指數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，補齊0到23位
00000000000000000000000，則其二進制表示形式為:
0 01111110 00000000000000000000000
E全為0
首先存入值是在真實值基礎上+127獲得，故出現E全為0的情況說明原數字極小。
這時，浮點數的指數E等于1-127（或者1-1023）即為真實值， 有效數字M不再加上第一位的1，而是還原為0.xxxxxx的小數。這樣做
是為了表示±0，以及接近于0的很小的數字。
E全為1
E的真實值+127等于存入值255
這時，如果有效數字M全為0，表示±無窮大（正負取決于符号位s）
好了，關于浮點數的表示規則，就說到這裡。
解釋前面的題目：
困惑點有二
-
printf("*pFloat的值為：%f\n", *pFloat);
-
printf("num的值為：%d\n", n);
#include <stdio.h>
int main()
{
int n = 9; //00000000000000000000000000001001 - 原反補相同
float* pFloat = (float*)&n; //浮點數列印：0 00000000 00000000000000000001001
//E為全0 - 規則：1-127 = -126
//M:0.00000000000000000001001
//%f列印時 = 0.00000000000000000001001*2^-126
printf("n的值為：%d\n", n); //9
printf("*pFloat的值為：%f\n", *pFloat); //0.000000 以整數放進去，以浮點數形式拿出來，說明兩者存儲方式有别
*pFloat = 9.0; //9.0 存 - 1001.0
//(-1)^0 * 1.001 * 2^3
//S=0
//E=3+127=130
//M=1.001
//0 10000010 00100000000000000000000
//01000001000100000000000000000000 - 以%d列印時，認定存儲的是有符号整數 - 正數
printf("num的值為：%d\n", n); //1091567616 以浮點數存入，以整型取出
printf("*pFloat的值為：%f\n", *pFloat); //9.000000
return 0;
}