C++ std:map中的浮点键

下面的代码应该在

std:：map

中找到存在的键

3.0

。但由于浮点精度，无法找到它

map<double, double> mymap;
mymap[3.0] = 1.0;

double t = 0.0;
for(int i = 0; i < 31; i++)
{
  t += 0.1;
  bool contains = (mymap.count(t) > 0);
}

现在的问题是：

如果我使用

double

键，是否有办法将fuzzyCompare引入

std:：map

？ 浮点数比较的常见解决方案通常类似于

a-b

。但是我看不到一种简单的方法可以用

std:：map

实现这一点。

---

我真的必须将

double

类型封装在一个类中并覆盖

操作符吗？您可以实现自己的比较函数

#include <functional>

class own_double_less : public std::binary_function<double,double,bool>
{
public:
  own_double_less( double arg_ = 1e-7 ) : epsilon(arg_) {}
  bool operator()( const double &left, const double &right  ) const
  {
    // you can choose other way to make decision
    // (The original version is: return left < right;) 
    return (abs(left - right) > epsilon) && (left < right);
  }
  double epsilon;
};
// your map:
map<double,double,own_double_less> mymap;

#包括
类own\u double\u less:public std:：binary\u函数
{
公众：
own_double_less（double arg_=1e-7）：ε（arg_）{
布尔运算符（）（常数双精度和左、常数双精度和右）常数
{
//你可以选择其他方式来做决定
//（原始版本为：返回左<右；）
返回（abs（左-右）>ε）和&（左<右）；
}
双ε；
};
//您的地图：
地图我的地图；

更新：见！
根据建议进行更新。
使用双精度键作为键没有用处。一旦你对这些关键点做了任何运算，你就不知道它们的确切值，因此不能使用它们来索引地图。唯一合理的用法是键是常量。
因为，您可以实现自己的比较功能。他遗漏的是使其工作的关键-您必须确保函数始终返回
false
，返回的值在您的等效公差范围内

return (abs(left - right) > epsilon) && (left < right);

return（abs（左-右）>epsilon）和&（左<右）；

编辑：正如对此答案和其他答案的许多评论中所指出的，如果您提供给它的值是任意分布的，那么结果可能会很糟糕，因为您不能保证
！（a因此在
std:：map
中使用双精度键存在一些问题

首先，
NaN
，它的比较小于它本身是一个问题。如果有可能插入
NaN
，请使用以下方法：

struct safe_double_less {
  bool operator()(double left, double right) const {
    bool leftNaN = std::isnan(left);
    bool rightNaN = std::isnan(right);
    if (leftNaN != rightNaN)
      return leftNaN<rightNaN;
    return left<right;
  }
};

它同时适用于
std:：map
和
std:：set
（和
multi
版本）

（在更现代的代码库中，我希望从
equal_range
函数返回一个
range
对象更好。但现在，我将使它与
equal_range
兼容）

这会发现一系列的东西，它们的键与您所请求的键“足够接近”，而容器在内部保持其排序保证，并且不会执行未定义的行为

要测试是否存在密钥，请执行以下操作：

template<typename Container>
bool key_exists( Container const& container, double target, double epsilon = 0.00001 ) {
  auto range = my_equal_range(container, target, epsilon);
  return range.first != range.second;
}

模板
布尔键_存在（容器常数和容器，双目标，双ε=0.00001）{
自动范围=我的相等范围（容器、目标、ε）；
返回range.first！=range.second；
}

如果您想删除/替换条目，您应该处理可能有多个条目命中的可能性

简短的回答是“不要将浮点值用作
std:：set
和
std:：map
的键”，因为这有点麻烦

如果你对
std:：set
或
std:：map
使用浮点键，几乎肯定不会对它们执行
.find
或
[]
操作，因为这很可能是bug的来源。你可以将其用于自动排序的内容集合，只要准确的顺序无关紧要（即，一个特定的1.0在前面或后面，或与另一个1.0完全在同一点上）。即使如此，我还是会使用多重映射/多重集，因为依赖碰撞或缺少碰撞并不是我所依赖的

关于IEEE浮点值的精确值的推理是困难的，依赖于它的代码的脆弱性是常见的。
下面是一个使用软比较（也称为epsilon或几乎相等）如何导致问题的简化示例

为了简单起见，让
epsilon=2
。将
1
和
4
放入您的
地图中。它现在可能如下所示：

for(int i = 0; i < 31; i++)
{
  t = 0.1 * i;
  bool contains = (mymap.count(t) > 0);
}

// works on both `const` and non-`const` associative containers:
template<class Container>
auto my_equal_range( Container&& container, double target, double epsilon = 0.00001 )
-> decltype( container.equal_range(target) )
{
  auto lower = container.lower_bound( target-epsilon );
  auto upper = container.upper_bound( target+epsilon );
  return std::make_pair(lower, upper);
}

1
 \
  4

所以
1
是树根

现在按顺序输入数字
2
，
3
，
4
。每个数字都将替换根，因为它与根比较相等。因此

4
 \
  4

已经损坏。（假设没有尝试重新平衡树。）我们可以继续使用
5
，
6
，
7
：

7
 \
  4

这一点甚至更糟，因为现在如果我们问
4
是否在其中，它会说“否”，如果我们要求小于
7
的值使用迭代器，它将不包括
4

尽管我必须说，我在过去多次使用基于这个有缺陷的模糊比较运算符的
map
s，而且每当我发现一个bug时，它从来都不是因为这个。这是因为我的应用程序区域中的数据集从来没有真正达到压力测试这个问题的程度。
距离有多近？听起来你可能真的y希望通过舍入键进行存储和查找。与您的解决方法相反，如果浮点数都是指定的数字精度，您可以将这些键存储为整数，浮点数值乘以某个比例因子并按此方式存储。我考虑过这一点，但根据分辨率，我会遇到麻烦ion I可能很容易溢出。您应该知道，即使是您的解决方案也可能失败-您在乘法的舍入方面很幸运。
0.1
无法在基数2中精确表示。请参阅此版本可能会导致未定义的行为，因为它根据参数的顺序给出不一致的结果。如果a==b，则为own\u double\less（a，b）返回true，但它的double（b，a）也会返回true。它们不能都小于彼此！如果您使用此方法，请记住，比较器必须创建严格的弱ord