一步步寫算法：通用算法編寫的 C++ 模板與 C 語言 void* 兩大範式

編輯：關於C語言

痛點：類型耦合的排序代碼

傳統冒泡排序硬編碼 int 類型：

void bubble_sort(int array[], int length) {
    for (int i = length-1; i > 0; i--)
        for (int j = 0; j < i; j++)
            if (array[j] > array[j+1]) {
                int tmp = array[j];
                array[j] = array[j+1];
                array[j+1] = tmp;
            }
}

若需排序 double、string 或自定義結構體，必須複製修改代碼，違反 DRY 原則。

C++ 範式：模板

利用模板參數化類型，比較與交換操作直接用運算符：

template <typename T>
void bubble_sort(T array[], int length) {
    if (!array || length == 0) return;
    for (int i = length-1; i > 0; i--)
        for (int j = 0; j < i; j++)
            if (array[j] > array[j+1]) {
                T tmp = array[j];
                array[j] = array[j+1];
                array[j+1] = tmp;
            }
}

要求：類型 T 必須支援 > 比較、拷貝構造、拷貝賦值。

C 語言範式：函數指針 + void*

C 無模板，通過回調函數分離「演算法邏輯」與「類型具體操作」：

// 通用排序框架
void bubble_sort(void *array[], int length,
                 int (*compare)(void*, void*),
                 void (*swap)(void*, void*)) {
    for (int i = length-1; i > 0; i--)
        for (int j = 0; j < i; j++)
            if (compare(array[j], array[j+1]))
                swap(array[j], array[j+1]);
}

// int 類型的具體實現
int compare_int(void *a, void *b) {
    return *(int*)a > *(int*)b;
}

void swap_int(void *a, void *b) {
    int tmp = *(int*)a;
    *(int*)a = *(int*)b;
    *(int*)b = tmp;
}

// 調用示例
void test() {
    int arr[5] = {1, 2, 4, 3, 5};
    int *parr[5] = {&arr[0], &arr[1], &arr[2], &arr[3], &arr[4]};
    bubble_sort((void**)parr, 5, compare_int, swap_int);
}

兩種範式深度對比

維度	C++ 模板	C void* 回調
類型安全	編譯期強類型檢查	運行期解釋，易誤用
代碼膨脹	每種類型生成獨立代碼	單一代碼，體積較小
性能	內聯優化，零開銷	函數指針間接調用，有開銷
使用便利性	直接用數組，語法自然	需構建指標數組，轉換繁瑣
泛化能力	支援運算符重載、traits	完全手動實現比較/交換

現代 C++ 的更佳選擇：std::sort + Lambda

#include <algorithm>
#include <vector>

std::vector<int> v = {5, 2, 4, 1, 3};
std::sort(v.begin(), v.end());                    // 升序
std::sort(v.begin(), v.end(), [](int a, int b){ return a > b; }); // 降序

// 自定義類型
struct Student { string name; int score; };
std::vector<Student> students = ...;
std::sort(students.begin(), students.end(), 
          [](const Student& a, const Student& b) { return a.score > b.score; });

std::sort 平均 O(N log N)，內部用 Introsort（快排+堆排+插排混合），遠超冒泡排序的 O(N²)。