C++模板实例化解析：为何一个operator<<匹配另一个不匹配？

问题描述 #

在main函数中尝试通过operator<<打印std::vector<int>时，以下两个模板实现中，第一个能成功匹配实例化，第二个却不行，需要分析原因并给出修改方案：

#include <iostream>
#include <vector>

template< typename value_type, typename allocator_type >
std::ostream& operator<<( 
    std::ostream& os, 
    std::vector< value_type, allocator_type >const& v
)
{
    os << "[vector-1]" << std::endl;
    return os;
}

template< typename VECTOR >
std::ostream& operator<<( 
    std::ostream& os, 
    std::vector< typename VECTOR::value_type, typename VECTOR::allocator_type >const& v
)
{
    os << "[vector-2]" << std::endl;
    return os;
}

int main() {
    std::vector v = {1, 2, 3, 4};
    std::cerr << v;
}

匹配差异的原因 #

第一个模板能匹配的原因 #

第一个模板的模板参数是value_type和allocator_type，函数参数直接是std::vector<value_type, allocator_type> const&。当编译器处理std::cerr << v时，v的实际类型是std::vector<int, std::allocator<int>>，编译器可以直接从这个类型中推导出value_type=int、allocator_type=std::allocator<int>，因此模板能成功实例化并匹配调用。

第二个模板无法匹配的原因 #

第二个模板的问题在于非推导上下文：函数参数中的std::vector<typename VECTOR::value_type, typename VECTOR::allocator_type>里，typename VECTOR::value_type和typename VECTOR::allocator_type属于非推导上下文。

编译器无法从给定的std::vector<int, std::allocator<int>>类型反向推导出VECTOR是什么——因为VECTOR可以是任何包含value_type和allocator_type嵌套类型的类，编译器没有足够的信息确定VECTOR的具体类型，导致模板参数推导失败，因此这个模板不会被选中。

修改方案：让第二个模板能匹配 #

要让第二个模板可以被匹配，需要调整参数形式，让编译器能正确推导出VECTOR，同时确保VECTOR确实是std::vector的实例。以下是两种可行的修改方式：

方式1：使用SFINAE约束（C++11及以上） #

直接将函数参数改为const VECTOR&，然后用std::enable_if和std::is_same约束VECTOR必须是std::vector的实例：

#include <iostream>
#include <vector>
#include <type_traits>

template< typename value_type, typename allocator_type >
std::ostream& operator<<( 
    std::ostream& os, 
    std::vector< value_type, allocator_type >const& v
)
{
    os << "[vector-1]" << std::endl;
    return os;
}

template< typename VECTOR >
std::enable_if_t<
    std::is_same_v<
        VECTOR, 
        std::vector<typename VECTOR::value_type, typename VECTOR::allocator_type>
    >,
    std::ostream&
> operator<<( 
    std::ostream& os, 
    const VECTOR& v
)
{
    os << "[vector-2]" << std::endl;
    return os;
}

int main() {
    std::vector v = {1, 2, 3, 4};
    std::cerr << v; // 注：此时第一个模板因更特化会被优先选中
}

方式2：使用Concept约束（C++20及以上） #

利用C++20的Concept特性，更直观地约束VECTOR是std::vector的实例：

#include <iostream>
#include <vector>
#include <concepts>

template< typename value_type, typename allocator_type >
std::ostream& operator<<( 
    std::ostream& os, 
    std::vector< value_type, allocator_type >const& v
)
{
    os << "[vector-1]" << std::endl;
    return os;
}

template< typename VECTOR >
requires requires {
    typename VECTOR::value_type;
    typename VECTOR::allocator_type;
    requires std::is_same_v<VECTOR, std::vector<typename VECTOR::value_type, typename VECTOR::allocator_type>>;
}
std::ostream& operator<<( 
    std::ostream& os, 
    const VECTOR& v
)
{
    os << "[vector-2]" << std::endl;
    return os;
}

int main() {
    std::vector v = {1, 2, 3, 4};
    std::cerr << v; // 注：第一个模板因更特化会被优先选中
}

注意：如果两个模板都满足匹配条件，第一个模板因为更特化（直接针对std::vector<T,A>）会被编译器优先选中。若想让第二个模板优先，可以调整模板的特化程度，或者移除第一个模板。

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