含std::variant的类自定义[]运算符：模板参数推导失败问题

问题重现 #

你的代码尝试用模板化的operator[]访问std::variant存储的数组指针，但编译器无法推导模板参数T：

原代码 #

#include <variant>

struct RawDataArray{
    std::variant<double*, float*> data;

    template <typename T>
    constexpr bool IsType() const noexcept{
        return std::holds_alternative<T*>(data);
    }

    template <typename T>
    T& operator [](const int index){
        return std::get<T*>(data)[index];       
    }
};

int main(){
   double* tmpData = new double[3];
   tmpData[0] = 1;
   tmpData[1] = 2;
   tmpData[2] = 3;

   RawDataArray rawData;
   rawData.data = tmpData;

   rawData[0] = 0.0;
}

编译错误 #

error C2676: binary '[': 'RawDataArray' does not define this operator or a conversion to a type acceptable to the predefined operator
message : could be 'T &RawDataArray::operator [](const int)'
message : 'T &RawDataArray::operator [](const int)': could not deduce template argument for 'T'

原因分析 #

模板参数推导仅依赖函数的输入实参，这里operator[]的输入只有int index，和T完全无关。赋值操作的右侧值（如0.0）属于函数调用后的返回值赋值，无法反向推导模板参数T。

解决方案 #

方案1：显式指定模板参数 #

直接在调用时明确T的类型，这是最直接的修改：

// main函数中修改调用方式
rawData.operator[]<double>(0) = 0.0;

缺点：写法繁琐，失去了数组语法的简洁性。

方案2：使用代理类重载赋值运算符 #

定义一个代理类，让operator[]返回代理对象，代理类根据std::variant的实际类型处理赋值和取值操作：

#include <variant>
#include <stdexcept>

struct RawDataArray;

class RawDataProxy {
private:
    RawDataArray& parent;
    int index;
public:
    RawDataProxy(RawDataArray& p, int idx) : parent(p), index(idx) {}

    // 重载赋值运算符，处理double赋值
    RawDataProxy& operator=(double val) {
        if (auto* ptr = std::get_if<double*>(&parent.data)) {
            (*ptr)[index] = val;
        } else {
            throw std::bad_variant_access{};
        }
        return *this;
    }

    // 重载赋值运算符，处理float赋值
    RawDataProxy& operator=(float val) {
        if (auto* ptr = std::get_if<float*>(&parent.data)) {
            (*ptr)[index] = val;
        } else {
            throw std::bad_variant_access{};
        }
        return *this;
    }

    // 隐式转换为double，支持取值操作
    operator double() const {
        if (auto* ptr = std::get_if<double*>(&parent.data)) {
            return (*ptr)[index];
        }
        return static_cast<double>(std::get<float*>(parent.data)[index]);
    }

    // 隐式转换为float
    operator float() const {
        if (auto* ptr = std::get_if<float*>(&parent.data)) {
            return (*ptr)[index];
        }
        return static_cast<float>(std::get<double*>(parent.data)[index]);
    }
};

struct RawDataArray{
    std::variant<double*, float*> data;

    template <typename T>
    constexpr bool IsType() const noexcept{
        return std::holds_alternative<T*>(data);
    }

    // 返回代理对象，不再需要模板参数
    RawDataProxy operator[](int index) {
        return RawDataProxy(*this, index);
    }

    // 常量版本
    RawDataProxy operator[](int index) const {
        return RawDataProxy(const_cast<RawDataArray&>(*this), index);
    }
};

int main(){
   double* tmpData = new double[3];
   tmpData[0] = 1;
   tmpData[1] = 2;
   tmpData[2] = 3;

   RawDataArray rawData;
   rawData.data = tmpData;

   rawData[0] = 0.0; // 正常编译，自动匹配double赋值
   float val = rawData[1]; // 自动转换为float
}

优点：保留了数组的简洁语法，用户无需显式指定类型，内部自动处理类型匹配。

方案3：返回std::variant引用 #

让operator[]返回std::variant<double&, float&>，利用C++17对variant的赋值支持：

#include <variant>

struct RawDataArray{
    std::variant<double*, float*> data;

    template <typename T>
    constexpr bool IsType() const noexcept{
        return std::holds_alternative<T*>(data);
    }

    std::variant<double&, float&> operator[](int index) {
        return std::visit([index](auto* ptr) -> std::variant<double&, float&> {
            return (*ptr)[index];
        }, data);
    }

    // 常量版本
    std::variant<const double&, const float&> operator[](int index) const {
        return std::visit([index](const auto* ptr) -> std::variant<const double&, const float&> {
            return (*ptr)[index];
        }, data);
    }
};

int main(){
   double* tmpData = new double[3];
   tmpData[0] = 1;
   tmpData[1] = 2;
   tmpData[2] = 3;

   RawDataArray rawData;
   rawData.data = tmpData;

   // 直接赋值，variant会自动匹配类型
   std::get<double&>(rawData[0]) = 0.0;
   // 或者用std::visit处理取值/赋值
   std::visit([](auto& val) { val = 1.5; }, rawData[1]);
}

优点：无需额外代理类，利用标准库特性实现，但赋值时仍需显式get或用visit，语法比代理类稍繁琐。

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