如何基于实例的模板类型过载函数

Question

（我认为这不是模板成员模板类的功能专业化，而无需指定类模板参数 阅读有点困难，所以我可能错了。我还没有发现其他可能的相关问题）

是否有一种方法可以根据实例模板类型过载功能？

就我而言，我有一个数字类，可以实现模型操作员

template <typename X>
class Operand
{
private:
        X _val;
public:
        Operand *operator% (const Operand &other_number ) const
    {
       //here, i would like use fmod for floats and doubles, and % for integers
    }
];

，当然，总有一种解决方案，将所有内容施放成长双打，使用FMOD并将其铸造回X，但感觉

• 非常效率非常低
• ，非常尴尬
• 并不是很谨慎，对C ++
• 和C ++和可能以某种方式容易出现问题

Answer 1

您在寻找这样的东西吗？

if constexpr (std::is_same_v<int, X>) {
    // use %
} else if constexpr (std::is_same_v<double, X> || std::is_same_v<float, X>) {
    // use fmod
} else {
    static_assert(!std::is_same_v<int, X>
               && !std::is_same_v<double, X>
               && !std::is_same_v<float, X>,
            "Unsupported type");
}

丑陋的解决方案，但也许这是您想要的。我的意思是，如果案件的数量不会改变，那么可能还可以。

但是，我会质疑总体设计并寻找诸如 CPO 。

---

如果您寻找一种“基于过载的”解决方案，那么您可以将所需的各种类型的 operator％专业化：

template <typename X>
class Operand
{
private:
        X _val;
public:
    Operand *operator% (const Operand &other_number ) const;
};

template<>
Operand<int> *Operand<int>::operator%(const Operand<int> &) const {
    // impl
}
template<>
Operand<double> *Operand<double>::operator%(const Operand<double> &) const {
    // impl
}
template<>
Operand<float> *Operand<float>::operator%(const Operand<float> &) const {
    // impl
}

不用说，这也是一个丑陋的解决方案。

Answer 2

当我提到cpos 在另一个答案中，我指的是Taht Taht tht the href =“ https://stackoverflow.com/questions/63818871/why-does-tag-ing-invoke-pattern-need-the-niebloid-s-niebloid-stdtag-invoke-at-al-all”>在这里。

但是，即使不遵循这些长度，我们也可以汲取一些灵感：

• 实现操作数＆lt; t＆gt; :: operator％根据 helper function 在 _VAL s 上作用于 operator％的参数，并传递给 helper ，
• Overload/template-specialize helper （ _VAL ）您要启用的类型>;
• 在操作员％中，调用 helper 应为 不合格的 ，它具有可以依靠ADL的优势只要匹配的助手过载和至少一个参数类型在同一命名空间中定义（不一定是相同；用于详细信息的ADL），就可以成功呼叫。
• 要考虑到有时您不能在与要使用的参数相同的名称空间中定义 helper （例如，如果您打算使用 Operand＆lt＆std :: vector＆lt ; int＆gt;＆gt; ，您无法在 namespace std {/ * shere */} 中定义 helper ，因为那是非法），令助手采用类型操作数的第一个additonal参数，该参数可作为标签，允许您在中定义 helper 操作数的名称空间。

这是一个粗略的尝试：

#include <math.h>
#include <iostream>

namespace operations { // namespace where Operand lives
template <typename X>
class Operand {
private:
public:
    struct Tag {};
    X _val;
    Operand() {};
    Operand(X v) : _val{v} {};
    Operand* operator% (Operand const& other_number ) const {
        std::cout << "dispatches to: ";
        return new Operand{helper(*this, this->_val, other_number._val)};
    }
};
}

using operations::Operand;

namespace operations {
// for builtin types, we need to resort to the namespace
// where Operand (the tag) is defined

// non-templated overload for int specifically
int helper(Operand<int> const&, int a, int b) {
    std::cout << "int" << std::endl;
    return a % b;
}

// same holds for those templates which we expect
// to instatiate for builtin types or types in std::

// templated overload for non-integrals
template<typename T, std::enable_if_t<!std::is_integral_v<T>, bool> = true>
auto helper(Operand<T> const&, T a, T b) {
    std::cout << "non-integrals" << std::endl;
    return std::fmod(a, b);
}

// templated overload for integrals
template<typename T, std::enable_if_t<std::is_integral_v<T>, bool> = true>
auto helper(Operand<T> const&, T a, T b) {
    std::cout << "other integrals" << std::endl;
    return a % b;
}
}

namespace myspace {
struct MyType {
    MyType(int) {}
};

// can be implemented in the namespace where MyType lives

// overload for MyType
MyType helper(Operand<MyType> const&, MyType const&, MyType const&) {
    std::cout << "MyType" << std::endl;
    return 0;
}
}

int main() {
    Operand<int> i1{15};
    Operand<int> i2{6};
    Operand<unsigned int> u1{15};
    Operand<unsigned int> u2{6};
    Operand<double> d1{15};
    Operand<double> d2{6};
    Operand<float> f1{15};
    Operand<float> f2{6};
    Operand<myspace::MyType> m1{0};
    Operand<myspace::MyType> m2{0};

    (i1 % i2); // dispatches to: int
    (u1 % u2); // dispatches to: other integrals
    (d1 % d2); // dispatches to: non-integrals
    (f1 % f2); // dispatches to: non-integrals
    (m1 % m2); // dispatches to: MyType
}

---

但是我真的建议您通过我链接的那些读物以及从那里链接的那些读物。 CPO在通用编程中最重要。

Answer 3

由于C ++ 17，因此使用如果ConstexPr 非常实用。但是，如果您有很多差异，则可能需要将浮点实现与积分类型实现分开。

以下所有实现都需要 #include＆lt; type_traits＆gt; ，也应遵循此免费功能：

template<class X>
Operand<X> operator%(const Operand<X>& l, const Operand<X>& r) {
    Operand rv{l};
    rv %= r;
    return rv;
}

一种方法是使用

template<class, bool> struct impl;

template<template<class> class O, class X>
struct impl<O<X>, true> { // specialization for floating point types
    using op_type = O<X>;
    // implement all special floating point behavior here:
    op_type& operator%=(const op_type& other) {
        op_type* This = static_cast<op_type*>(this);
        This->val = std::fmod(This->val, other.val);
        return *This;
    }
};

template<template<class> class O, class X>
struct impl<O<X>, false> { // specialization for integral types
    using op_type = O<X>;
    // implement all special functions for integral types here:
    op_type& operator%=(const op_type& other) {        
        auto This = static_cast<op_type*>(this);
        This->val %= other.val;
        return *This;
    }
};

template <class X, std::enable_if_t<std::is_arithmetic_v<X>, int> = 0>
class Operand : public impl<Operand<X>, std::is_floating_point_v<X>> {
private:
    using impl_type = impl<Operand<X>, std::is_floating_point_v<X>>;
    friend  impl_type;
    X val;
public:
    Operand() = default;
    Operand(X v) : val(v) {}
    // implement functions common to integral and floating point types here
};

​CRTP，看起来可能是这样的：

template<class, bool> struct impl;

template<class X>
struct impl<X, true> { // specialization for floating point types
    X remainder(X l, X r) const {
        return std::fmod(l, r);
    }
};

template<class X>
struct impl<X, false> { // specialization for integral types
    X remainder(X l, X r) const {
        return l % r;
    }
};

template <class X, std::enable_if_t<std::is_arithmetic_v<X>, int> = 0>
class Operand : private impl<X, std::is_floating_point_v<X>> {
private:
    X val;
public:
    Operand& operator%=(const Operand& other) {
        val = remainder(val, other.val);
        return *this;
    }
};

如果您想使用：

template <class X, std::enable_if_t<std::is_arithmetic_v<X>, int> = 0>
class Operand {
private:
    X val{};
public:
    Operand() = default;
    Operand(X v) : val(v) {}

    template<class Y = X, std::enable_if_t<std::is_same_v<X, Y>, int> = 0>
    std::enable_if_t<std::is_floating_point_v<Y>, Operand&>
    operator%=(const Operand& other) {
        val = std::fmod(val, other.val);
        return *this;
    }
    template<class Y = X, std::enable_if_t<std::is_same_v<X, Y>, int> = 0>
    std::enable_if_t<std::is_integral_v<Y>, Operand&>
    operator%=(const Operand& other) {
        val %= other.val;
        return *this;
    }
};

由于C ++ 17，使用 constexpr，如果 通常比sfinae方法更喜欢：

template <class X, std::enable_if_t<std::is_arithmetic_v<X>, int> = 0>
class Operand {
private:
    X val{};
public:
    Operand() = default;
    Operand(X v) : val(v) {}

    Operand& operator%=(const Operand& other) {
        if constexpr (std::is_floating_point_v<X>) {
            val = std::fmod(val, other.val);
        } else {
            val %= other.val;
        }        
        return *this;
    }
};

Answer 4

我认为，基于模板类型的函数超载的最干净的方法是使用C ++ 20约束。您可以执行以下操作：

template <typename X>
class Operand
{
    private:
        X val;
    public:
        Operand(X val): val{val} {}

        template<typename Y>
        requires std::same_as<Y, int>
        friend Operand operator% (const Operand<Y> lhs, const Operand<Y> &rhs ) {
            //here, Y is int
            return Operand<Y> { lhs.val % rhs.val };
        }

        template<typename Y>
        requires std::same_as<Y, float>
        friend Operand operator% (const Operand<Y> lhs, const Operand<Y> &rhs ) {
            //here, Y is float
            return Operand<Y> { std::fmod(lhs.val, rhs.val) };
        }
};

请注意，这也使用非成员的朋友定义，在我看来，这更像是对称性，更易于阅读。

如果您没有C ++ 20编译器，则可以使用 std :: Enable_if 进行完全相同的效果（但是，如果找不到匹配的操作员，则使用丑陋的编译器错误消息）。 std :: enable_if 可以以各种方式使用，我更喜欢以下一个：

template<typename Y, typename std::enable_if<std::is_same<Y, int>::value, bool>::type = true>
friend Operand operator% (const Operand<Y> lhs, const Operand<Y> &rhs ) {
    //here, Y is int
    //...
}

如果您发现自己为更多运算符/函数进行此操作，则应该完全分开针对不同类型的实现，如Ted Lyngmo的答案中所示。