如何编写可处理自定义结构体与C++基础类型的模板函数？

问题描述 #

你定义了带两个成员的模板结构体user_type，以及模板类array，希望array既能对user_type这类自定义类型进行成员赋值操作，也能处理int、float等基础类型。但尝试为setArray编写两个不同实现时，触发了以下编译错误：

error: redefinition of 'setArray'
error: member reference base type 'float' is not a structure or union

原代码如下：

template<typename T>
struct user_type
{
    T obj1;
    T obj2;
};

template<class T>
class array
{
    int length;
    T* ar_ptr;
    
    public:

    void setArray();
};

template<class T> void array<T>::setArray()
{
    for(int i = 0; i < length; ++i)
    {
        (*(ar_ptr+ i)).obj1 = 0;
        (*(ar_ptr+ i)).obj2 = 0;
    }
}

template <typename T>
void array<T>::setArray()
{
    for(int i = 0; i < length; ++i)
    {
        *(ar_ptr+ i) = 0;
    }
}

问题根源 #

1. 两个setArray的模板签名完全一致，属于重复定义，编译器无法区分。
2. 当实例化array<float>这类基础类型时，第一个实现中尝试访问.obj1和.obj2成员，但基础类型没有这些成员，导致编译错误。

解决方案 #

以下两种方法可以解决问题，根据场景选择：

方法1：模板特化（针对user_type类型） #

保留基础类型的通用实现，对array<user_type<T>>进行特化，单独实现其setArray：

#include <iostream>

template<typename T>
struct user_type
{
    T obj1;
    T obj2;
};

template<class T>
class array
{
protected:
    int length;
    T* ar_ptr;

public:
    // 补充构造函数，初始化长度和指针
    array(int len) : length(len), ar_ptr(new T[len]) {}
    // 补充析构函数，避免内存泄漏
    ~array() { delete[] ar_ptr; }

    void setArray();
};

// 基础类型的通用实现
template<class T>
void array<T>::setArray()
{
    for(int i = 0; i < length; ++i)
    {
        *(ar_ptr + i) = 0;
    }
}

// 针对user_type<T>的特化版本
template<typename T>
void array<user_type<T>>::setArray()
{
    for(int i = 0; i < length; ++i)
    {
        ar_ptr[i].obj1 = 0;
        ar_ptr[i].obj2 = 0;
    }
}

// 测试代码
int main()
{
    array<float> float_arr(5);
    float_arr.setArray(); // 调用基础类型版本

    array<user_type<int>> user_arr(3);
    user_arr.setArray(); // 调用特化版本
    return 0;
}

方法2：SFINAE结合类型特性（灵活区分多种类型） #

通过自定义类型特性，让编译器根据T的类型自动选择对应的setArray实现，适合需要区分多种类型的场景：

#include <iostream>
#include <type_traits>

template<typename T>
struct user_type
{
    T obj1;
    T obj2;
};

// 自定义类型特性：判断是否为user_type
template<typename T>
struct is_user_type : std::false_type {};

template<typename T>
struct is_user_type<user_type<T>> : std::true_type {};

template<class T>
class array
{
protected:
    int length;
    T* ar_ptr;

public:
    array(int len) : length(len), ar_ptr(new T[len]) {}
    ~array() { delete[] ar_ptr; }

    // 针对非user_type类型的实现
    template<typename U = T>
    std::enable_if_t<!is_user_type<U>::value> setArray()
    {
        for(int i = 0; i < length; ++i)
        {
            *(ar_ptr + i) = 0;
        }
    }

    // 针对user_type类型的实现
    template<typename U = T>
    std::enable_if_t<is_user_type<U>::value> setArray()
    {
        for(int i = 0; i < length; ++i)
        {
            ar_ptr[i].obj1 = 0;
            ar_ptr[i].obj2 = 0;
        }
    }
};

// 测试代码
int main()
{
    array<int> int_arr(4);
    int_arr.setArray();

    array<user_type<float>> user_arr(2);
    user_arr.setArray();
    return 0;
}

注意事项 #

• 原代码缺少array的构造/析构函数，实际使用中必须补充，否则会出现未初始化指针、内存泄漏等问题。
• 模板特化方式语法简单，适合仅需区分少数类型的场景；SFINAE方式更灵活，支持扩展更多类型判断。

内容的提问来源于stack exchange，提问作者Mr. Noob