C++中泛型使用所導致的膨脹問題

前幾天，部落客看了一篇文章抨擊C++的泛型會導致產生的可執行檔程式碼臃腫。

部落客從事C++軟體開發多年，由於先前的開發環境都是資源充足的伺服器，不用考慮磁碟空間的問題。最近打算在智慧家庭主機的嵌入式平台上使用C++進行開發。 FLASH儲存空間有限，這是必須要考慮的因素，一定要重視。

如下定義兩個list，元素類型不同：

list<int> l1;
list<string> l2;

如果是用C語來做該怎麼辦？它會對應list寫一套程式碼，再對list寫一套。每套都有相同的成員函數，只是變數類型各自不同罷了。

下面是list的C語言實作方式：

//! code-1struct list_int_item {
    int value;
    struct list_int_item *next;
};struct list_int {
    struct list_int_item *head;
    size_t size;
};

void list_int_insert(struct list_int *p, int value);int  list_int_sort(struct list_int *p);bool list_int_empty(struct list_int *p);
...

 下面是list的C語言實作方式：

//! code-2
struct list_string_item {
    string value;
    struct list_string_item *next;
};

struct list_string {
    struct list_string_item *head;
    size_t size;
};

void list_string_insert(struct list_int *p, string value);
int  list_string_sort(struct list_int *p);
bool list_string_empty(struct list_int *p);
...

兩者之間就是類型的差異。所以很多時間，在C語言中我們就用巨集來取代它的類型，如下：

//! code-3
#define LIST_DECLARE(TYPE) \
    struct list_##TYPE##_item { \
        TYPE## value; \
        struct list_##TYPE##_item *next; \
    }; \
    \
    struct list_##TYPE { \
        struct list_##TYPE##_item *head; \
        size_t size; \
    }; \
    \
    void list_##TYPE##_insert(struct list_##TYPE *p, ##TYPE## value); \
    int  list_##TYPE##_sort(struct list_##TYPE *p); \
    bool list_##TYPE##_empty(struct list_##TYPE *p); \
    ...

然後在頭檔中是這樣定義list的：

//! code-4

LIST_DECLARE(double)

所以，泛型產生冗餘程式碼是無法避免的，至少用C來做這樣的泛型也是無法避免的。

既然無法避免的，那就看看怎麼盡可能以避免上述的問題。在《Effective C++》中有一章節專門提到：不要在模板中使用不必要的參數。因為每一個不同的參數編譯器都會為之產生一套對應的程式碼。

如果程式碼中只有一種資料型，就算用該型別定義了多個變量，編譯器是不是只會產生一套相關的程式碼？ （應該是這樣的）。

寫範例比較一下：（省略不必要的程式碼）

test1.cpp，裡面只有map，但定義了m1, m2, m3。

//! code-5

    map<int, string> m1;
    map<int, string> m2;
    map<int, string> m3;

    m1.insert(std::make_pair(1, "hello"));
    m2.insert(std::make_pair(1, "hi"));
    m3.insert(std::make_pair(1, "lichunjun"));

test2.cpp，與test1.cpp相比，裡面有三個類型：

//! code-6    map<int, string> m1;
    map<int, double> m2;
    map<int, int> m3;

    m1.insert(std::make_pair(1, "hello"));
    m2.insert(std::make_pair(1, 1.2));
    m3.insert(std::make_pair(1, 44));

結果，編譯出來的可執行檔大小比較：

[hevake_lcj@Hevake tmp]$ ll test1 test2
-rwxrwxr-x. 1 18784 Mar 19 22:01 test1
-rwxrwxr-x. 1 35184 Mar 19 22:03 test2

test2比test1大一倍，原因不用多說。

還有一個問題：指針是不是被認為是一種類型？

上面的list與list不能共用同一套程式碼，根據的原因是因為int與string這兩種型別在空間大小與賦值的方式上都是不同的。所以，必須產生兩套程式碼來實現。

而指針，不管是什麼指針，它們都是一樣的。我們可以用void*代表所有的指標類型。

於是我們將上面的程式碼改改，再測試一下：

//! code-7    map<int, string*> m1;
    map<int, string*> m2;
    map<int, string*> m3;

    m1.insert(std::make_pair(1, new string("hello")));
    m2.insert(std::make_pair(1, new string("hi")));
    m3.insert(std::make_pair(1, new string("lichunjun")));

與

//! code-8    map<int, string*> m1;
    map<int, double*> m2;
    map<int, int*> m3;

    m1.insert(std::make_pair(1, new string("hello")));
    m2.insert(std::make_pair(1, new double(1.2)));
    m3.insert(std::make_pair(1, new int(44)));

結果是這樣的：

-rwxrwxr-x. 1 18736 Mar 19 23:05 test1
-rwxrwxr-x. 1 35136 Mar 19 23:05 test2

預期的結果test1與test2相差不多，但從結果上看並沒有什麼優化，結果有點令人失望～

思考：C++有沒有什麼參數可以優化這個？

如果沒有，為了節省空間，我們只能將所有的指標統一定義成void*類型了，在使用時再強制轉換。

//! code-9    map<int, void*> m1;
    map<int, void*> m2;
    map<int, void*> m3;

    m1.insert(std::make_pair(1, new string("hello")));
    m2.insert(std::make_pair(1, new double(1.2)));
    m3.insert(std::make_pair(1, new int(44)));

    cout << *static_cast<string*>(m1[1]) << endl;
    cout << *static_cast<double*>(m2[1]) << endl;
    cout << *static_cast<int*>(m3[1]) << endl;

如上代碼是將code-8的基礎上，將所有的指定都定義成了void*，在使用的時候用static_cast進行強制轉換成對應的指標類型。

如此得到的代碼大小與code-7的比較，只多了16個位元組。

但這種做法是很不可取的，必須用void*指標之後，編譯器不再對型別進行檢查，很容易把型別搞混淆。