C++如何实现类模板部分特化

MyContainer

#include <iostream>
#include <string>
#include <vector>
#include <typeinfo> // 用于 typeid().name()

// 1. 主模板 (Primary Template)
// 这是一个通用的容器模板，接受任意类型 T 和一个分配器 Allocator。
template<typename T, typename Allocator>
class MyContainer {
public:
    MyContainer() {
        std::cout << "Primary MyContainer constructed for <" 
                  << typeid(T).name() << ", " << typeid(Allocator).name() << ">" << std::endl;
    }
    void doSomething() {
        std::cout << "Primary container doing something with type " << typeid(T).name() << std::endl;
        // 默认的通用行为
    }
    // 假设有一些其他成员...
};

// 2. 部分特化：针对所有指针类型 T*
// 当 MyContainer 的第一个模板参数是一个指针类型时，使用此特化版本。
template<typename T, typename Allocator>
class MyContainer<T*, Allocator> { // 注意：这里 T* 替换了 T
public:
    MyContainer() {
        std::cout << "Partial specialization for T* MyContainer constructed for <" 
                  << typeid(T*).name() << ", " << typeid(Allocator).name() << ">" << std::endl;
    }
    void doSomething() {
        std::cout << "Pointer specialized container doing something with type " << typeid(T*).name() << std::endl;
        // 针对指针类型可能需要特殊处理，比如解引用、所有权管理等
    }
    // 这个特化版本可以有与主模板完全不同的成员或优化
};

// 3. 部分特化：针对 std::string 类型
// 当 MyContainer 的第一个模板参数是 std::string 时，使用此特化版本。
template<typename Allocator> // 只有 Allocator 仍是泛型
class MyContainer<std::string, Allocator> { // 注意：这里 std::string 替换了 T
public:
    MyContainer() {
        std::cout << "Partial specialization for std::string MyContainer constructed for <" 
                  << typeid(std::string).name() << ", " << typeid(Allocator).name() << ">" << std::endl;
    }
    void doSomething() {
        std::cout << "std::string specialized container doing string-specific operations." << std::endl;
        // 针对字符串类型，可能需要特定的内存布局或优化
    }
    // ...
};

// 4. 部分特化：针对特定分配器类型 (例如 std::allocator<int>)
// 当 MyContainer 的第二个模板参数是 std::allocator<int> 时，使用此特化版本。
template<typename T> // 只有 T 仍是泛型
class MyContainer<T, std::allocator<int>> { // 注意：这里 std::allocator<int> 替换了 Allocator
public:
    MyContainer() {
        std::cout << "Partial specialization for std::allocator<int> MyContainer constructed for <" 
                  << typeid(T).name() << ", " << typeid(std::allocator<int>).name() << ">" << std::endl;
    }
    void doSomething() {
        std::cout << "Allocator<int> specialized container doing something with type " << typeid(T).name() << std::endl;
        // 针对特定分配器，可能需要特殊的资源管理策略
    }
    // ...
};

int main() {
    MyContainer<int, std::allocator<int>> c1;
    c1.doSomething();
    std::cout << "--------------------" << std::endl;

    MyContainer<int*, std::allocator<int>> c2; // 匹配 MyContainer<T*, Allocator>
    c2.doSomething();
    std::cout << "--------------------" << std::endl;

    MyContainer<std::string, std::allocator<char>> c3; // 匹配 MyContainer<std::string, Allocator>
    c3.doSomething();
    std::cout << "--------------------" << std::endl;

    MyContainer<double, std::allocator<double>> c4; // 匹配主模板
    c4.doSomething();
    std::cout << "--------------------" << std::endl;

    // 注意：如果存在多个特化版本都可以匹配，并且没有一个比另一个更“特化”，则会导致编译错误。
    // 例如，如果有一个 MyContainer<int*, std::allocator<int>> 的特化，
    // 那么 c2 的匹配就会变得模糊。但在我们的例子中，每个调用都只有一个最匹配的特化。

    return 0;
}

MyContainer

doSomething

Vector

T

T

bool

Vector<bool>

bool

if (std::is_same_v<T, bool>)

Vector<bool>

std::vector<bool>

std::vector

SmartPointer<T>

new/delete

T

Release()

SmartPointer<IUnknown*>

SmartPointer<HANDLE>

if constexpr

traits

std::string

HashTable<std::string, ...>

HashTable<int, ...>