如何基于类模板参数条件声明成员函数重载？

问题背景 #

我尝试用std::enable_if根据类模板的模板参数，条件性地定义成员函数重载，但编译报错。

原代码 #

#include <cstddef>
#include <memory>
#include <math.h>
#include <iostream>
#include <type_traits>

//------------------------------------------------------------------------------
class MyDouble {
 public:
    MyDouble(double value_) : value(value_) { /* ... */ };

    operator double() const { return value; };

 protected:
    double value;
};

//------------------------------------------------------------------------------
class Base {
 public:
    explicit Base(double v1_ = 0.0, double v2_ = 0.0, double v3_ = 0.0);

    virtual ~Base() = default;

    virtual void update(double d1, double d2, double d3);

    double v1;
    double v2;
    double v3;

};

Base::Base(double v1_, double v2_, double v3_) :
    v1(v1_), v2(v2_), v3(v3_) {
        /* ... */
}

void Base::update(double d1, double d2, double d3) {
    v1 += d1;
    v2 += d2;
    v3 += d3;
}

//------------------------------------------------------------------------------
template < typename Arg = double >
class Derived : public Base {
 public:
    explicit Derived(Arg extra_);

    virtual ~Derived() = default;

    void update(double d1, double d2, double d3) override;

    // 期望仅当Arg == MyDouble时声明此重载
    template < typename T = Arg, typename = typename std::enable_if< std::is_same< Arg, MyDouble >::value >::type >
    void update(double d1, double d2, double d3, double extra);

    Arg extra;
};

template < typename Arg >
Derived< Arg >::Derived(Arg extra_) :
    Base(0.0, 0.0, 0.0),
    extra(extra_) {
        /* ... */
}

template < typename Arg >
void Derived< Arg >::update(double d1, double d2, double d3) {
    std::cout << "update" << std::endl;
    Base::update(d1, d2, d3);
}

template < typename Arg >
template < typename T, typename >
void Derived< Arg >::update(double d1, double d2, double d3, double extra) {
    std::cout << "MyDouble update" << std::endl;
    // ...
    Base::update(d1, d2, d3);
}


//------------------------------------------------------------------------------
int main(int argc, char const *argv[]) {

    Derived< double > foo(5);
    Derived< MyDouble > bar(10);  

    return 0;
}

编译错误 #

In instantiation of ‘class Derived<double>’:
[...]
error: no type named ‘type’ in ‘struct std::enable_if<false, void>’

错误原因 #

你的写法中，std::enable_if直接依赖类模板的Arg参数。当实例化Derived<double>时，编译器会直接解析所有成员函数声明，此时std::is_same<Arg, MyDouble>::value为false，std::enable_if内部没有type成员，直接触发编译错误。这不符合SFINAE的核心要求：失败必须发生在模板参数推导阶段，而非类实例化阶段。

正确SFINAE写法 #

要让SFINAE生效，需要将条件依赖于成员函数自身的模板参数，而非直接依赖类模板参数。修改方式如下：

1. 把std::enable_if的判断对象从类模板的Arg改成成员函数模板的参数T（默认值仍为Arg）
2. 确保条件判断的是T与MyDouble是否相同，这样在参数推导阶段，条件不满足时编译器会自动忽略该重载，而非报错。

修改后的完整代码 #

#include <cstddef>
#include <memory>
#include <math.h>
#include <iostream>
#include <type_traits>

//------------------------------------------------------------------------------
class MyDouble {
 public:
    MyDouble(double value_) : value(value_) { /* ... */ };

    operator double() const { return value; };

 protected:
    double value;
};

//------------------------------------------------------------------------------
class Base {
 public:
    explicit Base(double v1_ = 0.0, double v2_ = 0.0, double v3_ = 0.0);

    virtual ~Base() = default;

    virtual void update(double d1, double d2, double d3);

    double v1;
    double v2;
    double v3;

};

Base::Base(double v1_, double v2_, double v3_) :
    v1(v1_), v2(v2_), v3(v3_) {
        /* ... */
}

void Base::update(double d1, double d2, double d3) {
    v1 += d1;
    v2 += d2;
    v3 += d3;
}

//------------------------------------------------------------------------------
template < typename Arg = double >
class Derived : public Base {
 public:
    explicit Derived(Arg extra_);

    virtual ~Derived() = default;

    void update(double d1, double d2, double d3) override;

    // 修正：条件依赖成员函数自身的模板参数T
    template < typename T = Arg, typename = typename std::enable_if< std::is_same< T, MyDouble >::value >::type >
    void update(double d1, double d2, double d3, double extra);

    Arg extra;
};

template < typename Arg >
Derived< Arg >::Derived(Arg extra_) :
    Base(0.0, 0.0, 0.0),
    extra(extra_) {
        /* ... */
}

template < typename Arg >
void Derived< Arg >::update(double d1, double d2, double d3) {
    std::cout << "update" << std::endl;
    Base::update(d1, d2, d3);
}

template < typename Arg >
template < typename T, typename >
void Derived< Arg >::update(double d1, double d2, double d3, double extra) {
    std::cout << "MyDouble update" << std::endl;
    // ...
    Base::update(d1, d2, d3);
}


//------------------------------------------------------------------------------
int main(int argc, char const *argv[]) {

    Derived< double > foo(5);
    // foo.update(1,2,3,4); // 编译报错，符合预期：Derived<double>无此重载
    Derived< MyDouble > bar(10);  
    bar.update(1,2,3,4); // 正常调用MyDouble专属重载

    return 0;
}

额外说明 #

• 这种写法利用SFINAE特性：当推导成员函数模板的T参数时，若条件不满足，编译器会丢弃该重载，而非触发编译错误。
• 若使用C++17及以上，也可通过constexpr if在函数内部做分支判断，但这和条件定义重载是不同语义——constexpr if是同一函数内部的分支逻辑，而SFINAE是条件生成不同的函数重载。

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