（程式碼執行環境：Xcode7.3.1）

先來看這段程式碼

#include <stdio.h>
int main() {
    int a = 0x12345678;
    int i = 0;
    printf("0x%x, 0x%x\n", &a, a);
    for(; i < sizeof(a); i++) {
        printf("0x%x, 0x%x\n",(char *)&a +i, *((char *)&a + i));
    }
    return 0;
}

輸出：
0x5fbff7c8, 0x12345678
0x5fbff7c8, 0x78
0x5fbff7c9, 0x56
0x5fbff7ca, 0x34
0x5fbff7cb, 0x12
 

得出結論：在記憶體中，數是倒著儲存的；

87 65 43 21

整形的儲存方式
執行此程式碼
我們把Int型別拆開來看，分成4個位元組看（32位）

#include <iostream>
#include <vector>
void c_to_b(unsigned char c, std::vector<int> &ve) { // 十進位制char型別轉換為二進位制
    int st[8];
    for(int index = 7; index >= 0; index--) {
        st[index] = c % 2
 
;
        c >>= 1;
    }
    for (int index = 0; index < 8; index++) {
        ve.push_back(st[index]);
    }
}
void int_to_char(int interge) { // int型別轉化為char型別，而且以二進位制輸出
    std::vector<int> ve;
    union {
        int a;
        struct {
            unsigned char a1, a2, a3, a4;
        } st;
    } un;
    un.a = interge;
    c_to_b(un.st.a1, ve); // 明顯體現出。倒著儲存的
 

    c_to_b(un.st.a2, ve);
    c_to_b(un.st.a3, ve);
    c_to_b(un.st.a4, ve);

    for (int index = 0; index < 8; index++) {
        std::cout << ve[index];
    }
    std::cout << " ";
    for (int index = 8; index < 16; index++) {
        std::cout << ve[index];
    }
    std::cout << " ";
    for (int index = 16; index < 24; index++) {
        std::cout << ve[index];
    }
    std::cout << " ";
    for (int index = 24; index < 32; index++) {
        std::cout << ve[index];
    }
}

int main(int argc, const char * argv[]) {
    int_to_char(-2);
    return 0;
}

-2 :11111110 11111111 11111111 11111111
    低位                          高位
2:  00000010 00000000 00000000 00000000
-5: 11111011 11111111 11111111 11111111

結論：
1 資料倒著儲存
2 負數在計算機中是以該負數的二進位制的補碼形式
儲存的。
比如2的反碼是 11111101 11111111 11111111 11111111
補碼是（反碼 + 1 ，在低位加1） 11111110 11111111 11111111 11111111
在有符號數中，正數第一位是0，負數第一位是1
（高位位元組的第一位就是符號位）

浮點型的儲存方式
float 單精度浮點型 1位符號位 8為階碼位 23位尾位
double 雙精度浮點型 1位符號位 11位階碼位 52位尾位

以double為例

void d_to_b(double d) { //double轉化為記憶體中的二進位制表示
    std::vector<int> ve;
    union  {
        double a;
        struct  {
            unsigned char a1, a2, a3, a4, a5, a6, a7, a8;
        } b;
    } t;
    t.a = d;
    c_to_b(t.b.a8, ve); // 已經確實是倒著儲存了，這裡手動把他反過來
    c_to_b(t.b.a7, ve);
    c_to_b(t.b.a6, ve);
    c_to_b(t.b.a5, ve);
    c_to_b(t.b.a4, ve);
    c_to_b(t.b.a3, ve);
    c_to_b(t.b.a2, ve);
    c_to_b(t.b.a1, ve);
    std::cout << "符號位：" << ve.at(0) << " ";
    std::cout << "階碼：";
    for (int index = 1; index < 12; index++) {
        std::cout << ve.at(index);
    }
    std::cout << std::endl << "尾碼：";
    for (int index = 12; index < 64; index++) {
        std::cout << ve.at(index);
    }
    std::cout << std::endl;
}

7.3：
符號位：0 階碼：10000000001
尾碼：1101001100110011001100110011001100110011001100110011

7.5：
符號位：0 階碼：10000000001
尾碼：1110000000000000000000000000000000000000000000000000

來看一道題目

printf("%d",7.5f); // 輸出是多少？

（在VS2005上執行的時候是0 ,在Xcode裡是一堆數）

解釋一下為什麼是0，7.5f在記憶體中的儲存已經知道了，而%d是讀取32位，很明顯尾數的7.5f都是0

也不是所有浮點數這樣輸出都是0，試試7.4

在Mac中嘗試了一下，。。。竟然是隨機數。。。神奇的事情，有待研究。

指標的應用

指標是從低位開始的

int main(int argc, const char * argv[]) {
    int num = 1;
    int *p1 = #
    char *p2 = p1;
    char *p3 = p2 + 1;
    *p3 = 3;
    printf("%d", *p1);

    return 0;
}
// 低位                        高位
// 00000001 00000000 00000000 00000000
// p1
// p2
//          p3
// 00000001 00000011 00000000 00000000
// 倒回來讀00000000 00000000 00000011 00000001 = 512+256+1