Question

是否可以使用模板专门化来实现类似的内容？

#include <iostream>

template< typename T, bool a, bool b>
class Test
{
    T value;

public:
    Test() {}
    Test( const T& val ) : value( val ) {}

    void Set( const T& val ) { // [1]
        value = val;
    }

    void Set( const float val ) { // [2] To run just for T != float
        ...
    }
};

int main()
{
    Test<int, true, true> test1;
    test1.Set( 1234 ); // Run [1]

    Test<float, true, true> test2;
    test2.Set( 1.234f ); // Run [1]

    Test<int, true, true> test3;
    test3.Set( 1.234f ); // Run [2]
}

当T与float不同时，是否有语法指定成员函数是要选择的成员函数？

Answer 1

一个干净的选择是使用（非多态）继承来进行专业化，而无需重复所有操作：

namespace detail
{
    template< typename T, bool a, bool b>
    class TestImplBase
    {
    protected:
        T value;

    public:
        TestImplBase() {}
        TestImplBase( const T& val ) : value( val ) {}

        void Set( const T& val ) { // [1]
            value = val;
        }
    };

    // General case
    template< typename T, bool a, bool b>
    class TestImpl : public TestImplBase<T, a, b>
    {
    public:
        using TestImplBase<T, a, b>::TestImplBase; // keep the same constructors
        using TestImplBase<T, a, b>::Set; // See comment by Jarod42

        // Has [1] as well.

        void Set( const float val ) { // [2] To run just for T != float
            //...
        }
    };

    // Specialization for T == float
    template<bool a, bool b>
    class TestImpl<float, a, b> : public TestImplBase<float, a, b>
    {
    public:
        using TestImplBase<float, a, b>::TestImplBase; // keep the same constructors

        // Only has [1], not [2].
    };
}

template< typename T, bool a, bool b>
using Test = detail::TestImpl<T, a, b>;

https://godbolt.org/z/zRieA2

这是一种非常通用的方法，对于您的情况来说可能有点过于笼统，但这很难用这小段代码来说明。

Answer 2

是否可以使用模板专业化来实现类似的功能？

是：专门研究完整的class Test：通用情况，带有“ [2]”，float情况，不带它。

否则，我想您可以在T为float时使用SFINAE禁用“ [2]”

template <typename U = T>
std::enable_if_t<false == std::is_same_v<U, float>> Set( const float val )
 { /* ... */ }

或者也许

template <typename U = T>
std::enable_if_t<false == std::is_same_v<U, float> && true == std::is_same_v<U, T>>
      Set( const float val )
 { /* ... */ }

如果要避免启用Set()，则在float情况下，应复制U模板类型。

Answer 3

使用C ++ 20，这将非常简单：

requires允许“丢弃”方法：

template <typename T, bool a, bool b>
class Test
{
    T value;
public:
    Test() {}
    Test(const T& val) : value( val ) {}

    void Set(const T& val) { value = val; }

    void Set(float val) requires (!std::is_same<T, float>::value) {
        // ...
    }
};

Else SFINAE通常是消除重载的方法（但是需要模板功能，因此您必须制作一个方法模板）。

模板专业化：成员函数的参数不同于T

3 个答案: