2

今天在工作中出现了这个问题，所以我想我会把它扔给社区。

一位同事（或多或少）编写了以下代码：

#include <algorithm>

double chop(double x) {
    return std::max(0, x);
}

但这甚至无法编译，因为std::max希望它的两个参数具有完全相同的类型。我相信这是因为它可以获取一对引用并返回一个引用，如果您在用户定义的类型上调用它，这很可能是您想要的。很公平。

当然，解决方法是使用std::max(0.0, x).

现在请容忍我一会儿，因为我撒了谎。我的同事实际上写的是这样的：

// Included from a very old header file written by someone long gone
template<class T1, class T2>
inline T1 myMax(T1 x, T2 y) {
    return (x < y) ? y : x;
}

double chop(double x) {
    return myMax(0, x);
}

这编译！但是对于 x 等于 0.25，它会产生相当令人惊讶的结果。我不知道他花了多长时间才找到问题，即使找到了，他也不得不问为什么它不起作用。

我的回答是（a）使用 0.0 而不是 0（修复了错误），以及（b）使用std::max而不是myMax（当你想到它时，它的行为是相当可怕的）。

但他想知道为什么会这样。我的意思是，他可以写0 + xor 0 * xor 0 - x，那为什么不myMax(0, x)呢？

这是我第一次给他他想要的东西：

// this is from the .hh file

// template meta-program to compute the "wider" of two types given as argument
template<class T1, class T2>
struct WiderType {
};

// Partial specialization for case where both types are same
template<class T>
struct WiderType<T, T> {
  typedef T type;
};

// Specialization for first type "int" and second type "double"
template<>
struct WiderType<int, double> {
  typedef double type;
};

template<class T1, class T2>
inline typename WiderType<T1,T2>::type
myMax(T1 a, T2 b) {
  return ((a < b) ? b : a);
}


// this is from the .cc file

double chop(double x) {
  return myMax(0, x);
}

// just to show this still works
int chop(int x) {
  return myMax(0, x);
}

现在，我可以WiderType为每一对整数类型添加一个特化，再加上一些来做其他通常的算术转换。（我想我可以重命名它UsualConversions或类似的东西。）

但是有没有更简单的方法？也就是说，C++ 语言是否为我提供了一种简单的方法来定义我自己的函数，该函数对其参数执行与各种内置算术运算符相同的转换？

4

2 回答 2

7

除了查尔斯贝利的回答，你也可以这样做：

template<typename T1, typename T2>
typename std::common_type<T1, T2>::type max(T1&& a, T2&& b) {
    return a < b ? b : a;
}

common_type其中有一个 typedef type，它是两种类型都可以隐式转换为的类型，因此，例如，如果是doubleand int，它将返回 a double，但如果是intand int，它将返回 an int。

如果你根本不能使用 C++11，那么我唯一能想到的就是：

template<typename T1, typename T2, typename T3>
void max(const T1& a, const T2& b, T3& dst) {
    dst = a < b ? b : a;
}

并像使用它一样

double d;
max(0, 43.12, d);

但是，以这种方式声明变量非常笨拙。如果你觉得它更漂亮，你也可以这样做：

template<typename RetType, typename T1, typename T2>
RetType max(const T1& a, const T2& b) {
    return a < b ? b : a;
}

接着

return max<double>(0, 43.11);
于 2012-05-16T21:32:30.173 回答
4

在 C++11 之前我不知道有什么好方法，但现在你可以做这样的事情。

template<class T, class U>
auto myMax(T&& t, U&& u) -> decltype(t + u)
{
    return t < u ? u : t;
}

decltype(t + u)只需计算出通用类型T和U算术表达式中的通用类型，并将其用作模板的返回类型。

于 2012-05-16T21:29:22.383 回答