C++模板与运算符重载问题：相同类型实例化下标运算符冲突求解

你遇到的这个问题非常典型——当模板参数A和B是同一类型时，两个operator[]的签名会完全一致（都是T& operator[](const T&)，其中T是那个相同的类型），编译器无法判断你要调用哪一个，自然就会报歧义错误。下面给你几种实用的解决方案，从简单到进阶都有：

方案一：改用不同的成员函数名（最直接） #

如果不是特别执着于[]运算符的语法，最简单的办法就是把两个重载改成不同名字的成员函数，彻底避免重载歧义：

template<class A, class B>
class test {
    A a1;
    B a2;
public:
    A& get_by_b(const B& key) { return a1; } // 对应原 operator[](const B&)
    B& get_by_a(const A& key) { return a2; } // 对应原 operator[](const A&)
};

调用的时候直接用obj.get_by_b(5)或者obj.get_by_a(5)，语义清晰，编译器也不会有任何困惑。

方案二：标签分发（Tag Dispatch）保留[]语法 #

如果你想继续使用[]运算符，可以用标签分发的技巧，给两个重载加上不同的"标签"参数，让它们的签名变得不同。具体步骤如下：

1. 先定义两个空的标签结构体，用来区分不同的重载：

struct tag_for_a {};
struct tag_for_b {};

2. 修改你的模板类，把operator[]改成带标签参数的版本，同时提供无标签的自动推导版本（适配A、B不同的场景）：

template<class A, class B>
class test {
    A a1;
    B a2;
public:
    // 带标签的重载，签名明确不同
    A& operator[](const B& key, tag_for_a) { return a1; }
    B& operator[](const A& key, tag_for_b) { return a2; }

    // 当A和B不同时，自动推导调用对应的带标签版本
    template<typename T = A, typename U = B, std::enable_if_t<!std::is_same_v<T, U>, bool> = true>
    A& operator[](const B& key) { return (*this)[key, tag_for_a{}]; }

    template<typename T = A, typename U = B, std::enable_if_t<!std::is_same_v<T, U>, bool> = true>
    B& operator[](const A& key) { return (*this)[key, tag_for_b{}]; }
};

当A和B不同时，你可以像之前一样直接调用obj[some_b]或obj[some_a]；当它们相同时，需要手动指定标签来明确调用哪一个：

test<int, int> obj;
obj[10, tag_for_a{}]; // 调用返回A&的版本
obj[10, tag_for_b{}]; // 调用返回B&的版本

方案三：用SFINAE禁用歧义重载 #

如果希望当A和B相同时，只保留其中一个operator[]（或者做特殊处理），可以用C++11及以后的std::enable_if实现SFINAE（替换失败不是错误）：

#include <type_traits>

template<class A, class B>
class test {
    A a1;
    B a2;
public:
    // 当A != B时，启用这个重载
    template<typename T = B, std::enable_if_t<!std::is_same_v<A, T>, bool> = true>
    A& operator[](const T& key) { return a1; }

    // 当B != A时，启用这个重载
    template<typename T = A, std::enable_if_t<!std::is_same_v<B, T>, bool> = true>
    B& operator[](const T& key) { return a2; }

    // 当A == B时，单独提供一个重载（可根据需求返回a1、a2或做其他处理）
    template<typename T = A, std::enable_if_t<std::is_same_v<A, B>, bool> = true>
    A& operator[](const T& key) { 
        return a1; // 示例：默认返回a1，你可以改成自己需要的逻辑
    }
};

这个方案的好处是，当A和B不同时，用法和之前完全一致；当它们相同时，编译器只会看到一个operator[]，不会有歧义。

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