您现在的位置：程式碼之家 >> 編程語言 > >> C語言 >> C++ >> 關於C++

泛型編程與設計新思維：STL、Policy 與單例模式的現代 C++ 實踐

編輯：關於C++

編寫代碼的宗旨在於簡單明了，理解你所寫的每一行。1998 年 C++ 國際標準通過，標準化對 C++ 最大的貢獻是對「強大抽象概念」的有力支援，降低軟體複雜度。C++ 提供兩大抽象利器：**面向對象程式設計（OOP）**與**泛型程式設計（GP）**。STL（標準模板庫）正是泛型編程的集大成之作。

模板：泛型編程的基石

模板實現原始碼層面的重用，而非透過繼承/組合重用物件代碼。編譯器根據參數替換生成具體代碼。模板分類別模板與函數模板，參數可為型別參數（class/typename）或非型別參數（如整數）。

template<class T1, int Size>
class Queue {
    T1* temp_;
    int size_;
public:
    explicit Queue() : size_(Size) {}
    template<class T2> void assign(T2 first, T2 last); // 成員函數模板
};

// 類外實現成員函數模板
template<class T1, int Size> template<class T2>
void Queue<T1, Size>::assign(T2 first, T2 last) {}

// 使用
int ia[4] = {0,1,2,3};
Queue<int, sizeof(ia)/sizeof(int)> qi;
qi.assign(ia, ia+4);

STL 架構：演算法、容器、迭代器、函數物件

泛型編程不要求額外間接層，讓你編寫完全泛化、高效、可重用的演算法。STL 核心在於迭代器——泛型指標，將容器與演算法分離。演算法操作迭代器形成的區間，不直接操作容器。

五種迭代器分類（能力遞增）

Input Iterator：單向、只讀（如 istream_iterator）
Output Iterator：單向、只寫（如 ostream_iterator）
Forward Iterator：單向、讀寫
Bidirectional Iterator：雙向、讀寫（支援 ++/--）
Random Access Iterator：隨機存取（支援 +=、[]、-、比較）

各類迭代器透過標籤（iterator_tag）分派，實現如 advance 等演算法的最佳化：

// Random Access 版本直接 i += n
template<class RandomAccessIterator, class Distance>
void advance(RandomAccessIterator& i, Distance n, random_access_iterator_tag) {
    i += n;
}

函數物件：可呼叫的物件

函數物件（仿函數）重載 operator()，分為無參（Generator）、單參（Unary）、雙參（Binary）三種基本形式，STL 所有函數物件皆為此三者的強化：

// Generator
struct counter { int n; counter(int i=0):n(i){} int operator()() { return n++; } };

// Unary Function：尋找偶數
template<class T> struct even { bool operator()(T x) const { return (x&1)==0; } };
find_if(A, A+N, even<int>());

// Binary Function：字串比較
struct ltstr { bool operator()(const char* s1, const char* s2) const { return strcmp(s1,s2)<0; } };
set<const char*, ltstr> A(a, a+N), B(b, b+N);
set_union(A.begin(), A.end(), B.begin(), B.end(), ostream_iterator<const char*>(cout," "), ltstr());

容器分類

序列式容器：vector、list、deque
關聯式容器：set、map、multiset、multimap

容器提供迭代器，演算法操作迭代器區間，實現極高的組合靈活性。

設計新思維：Policy-based Design

將設計模式、泛型編程、面向對象有機結合，形成「設計新思維」。核心技術是 Policies（策略）——定義類別介面的小型類別，每個只負責單一行為或結構面向。Policy 機制由模板與多重繼承構成，可混合搭配，形成設計的多樣性。

泛型單例模式實現

傳統單例寫死建立與生命週期策略。泛型版本將其分解為 CreationPolicy 與 LifetimePolicy：

template<
    class T,
    template<class> class CreationPolicy = CreateUsingNew,
    template<class> class LifetimePolicy = DefaultLifetime
>
class SingletonHolder {
public:
    static T& Instance() {
        if (!pInstance_) {
            if (destroyed_) { LifetimePolicy<T>::OnDeadReference(); destroyed_ = false; }
            pInstance_ = CreationPolicy<T>::Create();
            LifetimePolicy<T>::ScheduleCall(&DestroySingleton);
        }
        return *pInstance_;
    }
private:
    static void DestroySingleton() {
        assert(!destroyed_);
        CreationPolicy<T>::Destroy(pInstance_);
        pInstance_ = 0; destroyed_ = true;
    }
    SingletonHolder(); // 禁止實例化
    static T* pInstance_;
    static bool destroyed_;
};

客製化應用範例

// 應用一：預設策略
class A{};
typedef SingletonHolder<A, CreateUsingNew> SingleA;

// 應用二：自訂建立策略（回傳衍生類別）
class A{}; class Derived : public A {};
template<class T> struct MyCreator : CreateUsingNew<T> {
    static T* Create() { return new Derived; }
    static void Destroy(T* p) { delete p; }
};
typedef SingletonHolder<A, MyCreator> SingleA;

泛型組件預先實現設計模組，使用者指定型別與行為即可形成合理設計，特點是靈活、通用、易用。這正是 Modern C++ 設計的精髓：以模板實現設計模式的靜態多態，實現零開銷抽象。