基于模板类型的不带输入参数的‘'Overloading’函数

Question

我开始使用模板，遇到了一个需要基于2个模板参数类型调用函数的问题。我正在编写简单的单元库，它将具有定义单元之间比率的辅助getConvertionFactor函数。我希望能够在模板运算符+，-，*，/定义中基于作为参数传递的类型来拾取函数。我知道当这些参数被进一步传递给getConvertionFactor函数时，这是可能的。然后，重载解析将拾取在给定参数类型之间具有指定比率的函数。但据我所知，这种方法将导致不必要地将LHS和RHS参数复制到getConvertionFactor函数中，以执行重载解析。我想避免它，并以某种方式执行基于2个类型的函数查找，而不需要将dummy参数传递给它。

#include <iostream>

struct Kilometer {
    int val = 0;
};
struct NauticalMile {
    int val = 0;
};

template<class FromType, class ToType>
double getConvertionFactor() {
    return FromType::getBaseValue();
}

// How to define such conceptually function pointer lookup based on these 2 types?
// double getConvertionFactor<Kilometer, NauticalMile>() {
//     return 0.1;
// }

// Works but requires copying parameters
double getConvertionFactor(Kilometer km, NauticalMile /*nm*/) {
    return 0.1 * km.val;
}

template<class LHS_Unit, class RHS_Unit>
LHS_Unit operator+(const LHS_Unit& nm, const RHS_Unit& km) {
    LHS_Unit lhs;
    lhs.val = nm.val + getConvertionFactor(nm, km)*km.val;
    return lhs;
}

int main() {
    Kilometer km{100};
    NauticalMile nm{100};

    auto res = km + nm;
    std::cout << res.val << std::endl;

    return 0;
}   

Answer 1

你可以这样做：

template<class FromType, class ToType>
double getConvertionFactor() {
    return 1;
}

template<>
double getConvertionFactor<Kilometer, NauticalMile>() {
    return 1.852;
}

template<>
double getConvertionFactor<NauticalMile, Kilometer>() {
    return 1 / 1.852;
}

template<class LHS_Unit, class RHS_Unit>
LHS_Unit operator+(const LHS_Unit& lhs, const RHS_Unit& rhs) {
    return { lhs.val + getConvertionFactor<LHS_Unit, RHS_Unit>() * rhs.val };
}

但是，实现用户定义的转换运算符可能是一个好主意，这样类型就可以隐式地相互转换。

#include <iostream>

struct Kilometer;
struct NauticalMile;

struct Kilometer {
    double val = 0;

    operator NauticalMile() const;
};
struct NauticalMile {
    double val = 0;

    operator Kilometer() const;
};

Kilometer::operator NauticalMile() const {
    return { val / 1.852 };
}

NauticalMile::operator Kilometer() const {
    return { val * 1.852 };
}

template<class LHS_Unit, class RHS_Unit>
LHS_Unit operator+(const LHS_Unit& lhs, const RHS_Unit& rhs) {
    return { lhs.val + static_cast<LHS_Unit>(rhs).val };
}

int main() {
    Kilometer km{ 100 };
    NauticalMile nm{ 100 };

    auto res = km + nm;
    std::cout << res.val << std::endl;

    return 0;
}