类对象与标量差异化行为的函数/运算符模板推导与特化问题

问题描述 #

我正在开发一个基于模板元编程实现静态多态的项目，类之间通过数学运算交互，需要同时识别标量和类对象参数。基础代码如下：

#include <iostream>

template<typename CLASS_T>
class BaseClass {};

template<class DATA_T>
class DerivedType1 : public BaseClass< DerivedType1<DATA_T> > {};

template<class DATA_T>
class DerivedType2 : public BaseClass< DerivedType2<DATA_T> > {};

// 对象-对象乘法运算符模板
template<typename CLASS_T1, typename CLASS_T2>
int operator* (BaseClass<CLASS_T1> const& obj1, BaseClass<CLASS_T2> const& obj2)
{
    // 实际会返回表达式模板，此处仅作示例
    return 0;
}

int main()
{
    DerivedType1<float> obj1;
    DerivedType2<float> obj2;

    int val = obj1*obj2;
    std::cout << val << std::endl;

    return 0;
}

原本代码运行正常，但添加处理标量乘法的模板重载后出现问题：

template<typename CLASS_T, class T>
int operator* (BaseClass<CLASS_T> const& obj, T scalar)
{
    return 1;
}

现在即使是obj1*obj2这类对象间交互，也会优先匹配新的标量模板导致编译失败。需求明确：标量需按值传递（适配字面量）；类对象需按引用传递避免拷贝。

解决方案 #

方法1：SFINAE结合std::is_scalar过滤标量重载 #

利用C++11及以上的std::is_scalar和SFINAE特性，限制标量版本的运算符仅当T是标量类型时才参与重载决议：

#include <type_traits>

// 保留原有的对象-对象乘法重载
template<typename CLASS_T1, typename CLASS_T2>
int operator* (BaseClass<CLASS_T1> const& obj1, BaseClass<CLASS_T2> const& obj2)
{
    return 0;
}

// 仅当T是标量类型时启用此重载
template<typename CLASS_T, class T>
typename std::enable_if<std::is_scalar<T>::value, int>::type
operator* (BaseClass<CLASS_T> const& obj, T scalar)
{
    return 1;
}

当第二个参数是BaseClass派生类对象时，std::is_scalar<DerivedTypeX<float>>::value为false，标量模板会被排除在重载决议之外，编译器会自动选择对象-对象的重载。

方法2：标签分发（Tag Dispatch） #

通过标签分发机制，根据参数类型分发到不同的实现函数，扩展性更强：

#include <type_traits>

// 定义标签类型
struct scalar_tag {};
struct object_tag {};

// 判断类型是否为BaseClass的派生类
template<typename T>
struct is_base_derived {
    // 重载test函数：能匹配BaseClass指针的版本返回true_type
    template<typename U>
    static std::true_type test(const BaseClass<U>*);
    // 兜底版本返回false_type
    static std::false_type test(...);
    // 推导最终结果
    static constexpr bool value = decltype(test(std::declval<const T*>()))::value;
};

// 标量乘法实现
template<typename CLASS_T, typename T>
int multiply_impl(const BaseClass<CLASS_T>& obj, T scalar, scalar_tag)
{
    return 1;
}

// 对象-对象乘法实现
template<typename CLASS_T1, typename CLASS_T2>
int multiply_impl(const BaseClass<CLASS_T1>& obj1, const BaseClass<CLASS_T2>& obj2, object_tag)
{
    return 0;
}

// 对外的运算符，自动判断分发标签
template<typename T1, typename T2>
int operator*(const T1& lhs, const T2& rhs)
{
    using tag = typename std::conditional<
        is_base_derived<T2>::value,
        object_tag,
        scalar_tag
    >::type;
    return multiply_impl(lhs, rhs, tag{});
}

后续扩展其他类型时，只需新增对应的标签和实现函数即可。

方法3：C++20概念（Concepts） #

如果使用C++20及以上版本，用概念直接约束模板参数，代码更简洁直观：

#include <concepts>
#include <type_traits>

// 定义BaseClass派生类的概念
template<typename T>
concept BaseDerived = std::is_base_of_v<BaseClass<std::remove_cvref_t<T>>, T>;

// 对象-对象乘法：仅接受BaseDerived类型的参数
template<BaseDerived CLASS_T1, BaseDerived CLASS_T2>
int operator* (const CLASS_T1& obj1, const CLASS_T2& obj2)
{
    return 0;
}

// 标量乘法：第二个参数必须是标量类型
template<BaseDerived CLASS_T, std::scalar T>
int operator* (const CLASS_T& obj, T scalar)
{
    return 1;
}

概念明确了模板参数的要求，编译器会自动筛选符合条件的重载，可读性和维护性更强。

额外提示 #

• 如果需要支持scalar * obj这类左标量、右对象的运算，需要额外实现对应的运算符重载，同样可以用上述方法约束。
• 若要支持更多非标量且非BaseDerived的类型，可调整is_scalar或概念的判断逻辑，灵活扩展。

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