我创建了一个 Frequency 类模板，旨在与 std::chrono::duration 结合使用. Frequency 对象存储每单位持续时间的周期数(两者都使用其类型的模板参数)。这个想法是将频率乘以持续时间产生一个 Rep 类型的对象。这是类定义。除了相关成员，我已经省略了所有成员。

#include <ratio>
#include <chrono>
using namespace std::chrono;

template <typename Rep, typename Period = std::ratio<1>>
class Frequency
{
public:
    explicit Frequency(Rep cycles) : _cycles{cycles} { }

    friend Rep operator *(const Frequency<Rep, Period>& f, const duration<Rep, Period> d)
    {
        return f._cycles * d.count();
    }
    friend Rep operator *(const duration<Rep, Period> d, const Frequency<Rep, Period>& f)
    {
        return f._cycles * d.count();
    }
private:
    Rep _cycles; ///> The number of cycles per period.
};

问题(我认为)是 std::chrono::duration 也重载了 * 运算符，如下所示:

template< class Rep1, class Period, class Rep2 >
duration<typename std::common_type<Rep1,Rep2>::type, Period>
    constexpr operator*( const duration<Rep1,Period>& d,
                         const Rep2& s );

template< class Rep1, class Rep2, class Period >
duration<typename std::common_type<Rep1,Rep2>::type, Period>
    constexpr operator*( const Rep1& s,
                         const duration<Rep2,Period>& d );

根据 cppreference , 这些方法中的每一个

Converts the duration d to one whose rep is the common type between Rep1 and Rep2, and multiplies the number of ticks after conversion by s.

我相信编译器正在尝试使用这些重载的运算符模板而不是我的重载。当我编写以下代码时:

Frequency<double> f{60.0};
duration<double> d{1.0};
double foo = f * d;

我在 VS2013 中遇到类似以下错误:

C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\INCLUDE\type_traits(1446) : error C2446: ':' : no conversion from 'double' to 'Frequency<double,std::ratio<0x01,0x01>>'
        Constructor for class 'Frequency<double,std::ratio<0x01,0x01>>' is declared 'explicit'
        source_file.cpp(27) : see reference to class template instantiation 'std::common_type<Frequency<double,std::ratio<0x01,0x01>>,Rep>' being compiled
        with
        [
            Rep=double
        ]

而第1446行是std::common_type的VS实现。

那么，有没有办法确保调用我的重载而不是 std::chrono::duration 中的重载？我知道我可以通过不使用运算符重载并改为编写不同命名的方法来解决问题，但如果可能的话，我想更好地了解这里发生的事情。 (加上重载更方便。)

此外，如果这个问题重复，我深表歉意，但我在搜索后找不到任何类似的内容。

最佳答案

在这段代码中:

Frequency<double> f{60.0};
duration<double> d{1.0};
double foo = f * d;

编译器说“哦，我必须找到一个 operator* 接受一个 Frequency<double> 和一个 std::chrono::duration<double> 。operator* 有哪些可能性？它会生成一个可能性列表，主要由这两个组成:

friend Rep operator *(const Frequency<Rep, Period>& f, const duration<Rep, Period> d)
{
    return f._cycles * d.count();
}

template< class Rep1, class Rep2, class Period >
duration<typename std::common_type<Rep1,Rep2>::type, Period>
constexpr operator*( const Rep1& s,
                     const duration<Rep2,Period>& d );

然后，它会尝试准确地找出每个签名是什么。第一个是:

Rep operator *(const Frequency<Rep, Period>& f, const duration<Rep, Period> d)

然后尝试第二个结果:

error C2446: ':' : no conversion from 'double' to 'Frequency<double,std::ratio<0x01,0x01>>'
        Constructor for class 'Frequency<double,std::ratio<0x01,0x01>>' is declared 'explicit'
        source_file.cpp(27) : see reference to class template instantiation 'std::common_type<Frequency<double,std::ratio<0x01,0x01>>,Rep>' being compiled

因为它甚至无法弄清楚签名是什么，所以无法弄清楚选择哪一个，于是放弃了。我认为这是 MSVC 的 operator* 实现中的一个错误。在这种情况下。

明显的解决方法是制作 common_type<Frequency<double>,Rep>能够编译，可能通过删除 explicit对构造函数的限制。 aschepler观察到特化 common_type 可能更聪明、更有用:

namespace std {
    template <typename Rep, typename Period>
    struct common_type<Frequency<Rep,Period>, std::chrono::duration<Rep,Period>>   
    {
        typedef Rep type;
    };
    template <typename Rep, typename Period>
    struct common_type<std::chrono::duration<Rep,Period>, Frequency<Rep,Period>>   
    {
        typedef Rep type;
    };
}

关于c++ - 用户定义的重载运算符 * 与 std::chrono::duration，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/24022142/