Specialize member func for integral template arg with c++17

Question

I'm trying to use std::enable_if_t and std::is_integral_v templates to specialize a mem-func of a class. I read this, but it is about common functions instead of member-function.

I mimic it and write my codes as following, but it does NOT work.

namespace oct {

class Class1 {
    template< typename T> T memf();
};

template< typename T>
std::enable_if_t< std::is_integral_v<T>, T> Class1::memf() {
    std::cout << "Integral." << std::endl;
    return 1;
};

template< typename T>
std::enable_if_t < ! std::is_integral_v<T>, T > Class1::memf() {
    std::cout << "None-Integral." << std::endl;
    return T {};
};

};

Compiling Error Msg:

no declaration matches ‘std::enable_if_t<is_integral_v, T> oct::Class1::memf()

You cannot partially specialise a function template. You need to use an overload rather than a specialisation. — n. m. could be an AI, Nov 23 '21 at 06:19

Jason · Answer 1 · 2022-11-05T05:35:18.490

You can do it as shown below:

Version 1

Here we provide the member function implementation outside the class.

#include <iostream>
#include <type_traits>

namespace oct{
class Class1 {
    public:
        template< typename T>
        std::enable_if_t< std::is_integral_v<T>, T> memf() ;
        template< typename T>
        std::enable_if_t < ! std::is_integral_v<T>, T > memf();
};
}
template< typename T>
        std::enable_if_t< std::is_integral_v<T>, T> oct::Class1::memf() {
            std::cout << "Integral." << std::endl;
            return 1;
        }
template< typename T>
        std::enable_if_t < ! std::is_integral_v<T>, T > oct::Class1::memf() {
            std::cout << "None-Integral." << std::endl;
            return T {};
        }
int main()
{
    oct::Class1 f;
    f.memf<int>();//prints "Integral."
    f.memf<int*>();//prints "Non-Integral."
}

Version 2

Here we provide the member function definition inside the class template.

#include <iostream>
#include <type_traits>

namespace oct{
class Class1 {
    public:
        template< typename T>
        std::enable_if_t< std::is_integral_v<T>, T> memf() {
            std::cout << "Integral." << std::endl;
            return 1;
        }
        template< typename T>
        std::enable_if_t < ! std::is_integral_v<T>, T > memf() {
            std::cout << "None-Integral." << std::endl;
            return T {};
        }
};

}
int main()
{
    oct::Class1 f;
    f.memf<int>(); //prints "Integral."
    f.memf<int*>();//prints "Non-Integral."
}

Also, note that function templates cannot be partially specialized.

I have also removed unnecessary ; semicolons that you had in your program.

score 1 · Answer 2 · answered Nov 23 '21 at 09:35

As alternative to SFINAE, you might use if constexpr:

class Class1
{
    template <typename T>
    T memf()
    {
        if constexpr (std::is_integral_v<T>)
        {
            std::cout << "Integral." << std::endl;
            return 1;
        } else {
            std::cout << "Non-Integral." << std::endl;
            return T {};
        }
    }
};

Specialize member func for integral template arg with c++17

2 Answers2