如何对C++模板类进行类级特化且无需重复编写类方法

你可以通过存储策略辅助类把栈/堆分配的差异封装起来，不需要特化整个Cache类，自然也就不需要重复编写类方法，兼容C++11及以上标准。

步骤1：定义存储阈值和策略辅助类 #

首先定义栈上允许的最大容量阈值，再通过模板偏特化实现两种存储策略，对外暴露统一的访问接口：

#include <array>
#include <memory>

// 可自定义栈上允许的最大数组大小，根据实际栈空间调整
constexpr size_t STACK_MAX_SIZE = 1024;

// 通用策略：小SIZE走栈存储
template<size_t SIZE, bool UseStack = (SIZE <= STACK_MAX_SIZE)>
struct CacheStorage {
    using StorageType = std::array<int, SIZE>;

    static StorageType init() {
        return StorageType{};
    }

    static int* data(StorageType& obj) {
        return obj.data();
    }

    static const int* data(const StorageType& obj) {
        return obj.data();
    }
};

// 偏特化策略：大SIZE走堆存储
template<size_t SIZE>
struct CacheStorage<SIZE, false> {
    using StorageType = std::unique_ptr<std::array<int, SIZE>>;

    static StorageType init() {
        return std::make_unique<std::array<int, SIZE>>();
    }

    static int* data(StorageType& obj) {
        return obj->data();
    }

    static const int* data(const StorageType& obj) {
        return obj->data();
    }
};

步骤2：实现Cache类 #

Cache类直接调用辅助类的统一接口操作存储成员，所有方法只需要实现一次：

template<size_t SIZE>
class Cache {
// 所有原有类方法都可以在这里实现，无需重复编写
public:
    Cache() : _storage(CacheStorage<SIZE>::init()) {}

    // 示例：数组访问接口
    int& operator[](size_t idx) {
        return CacheStorage<SIZE>::data(_storage)[idx];
    }

    const int& operator[](size_t idx) const {
        return CacheStorage<SIZE>::data(_storage)[idx];
    }

    // 其他原有类方法直接通过上述统一接口访问存储即可，无需感知底层是栈还是堆

private:
    typename CacheStorage<SIZE>::StorageType _storage;
};

方案优势 #

• 无重复代码：所有业务逻辑仅在Cache类中实现一次
• 无额外开销：小SIZE场景和原生栈上std::array性能完全一致，没有指针间接访问开销
• 适配灵活：调整STACK_MAX_SIZE的值即可自由切换栈/堆分配的阈值
• 接口透明：上层调用不需要关心底层存储实现，使用方式和原有类完全一致

内容的提问来源于stack exchange，提问作者user997112