Question

在下面的程序中，我将一些信息存储在哈希表（std :: unordered_map）中，键是RectData类的对象，关联的值是元组＆lt; uint，RectData，enum＆gt;并定义了自定义KeyHash和KeyEqual。

插入＆lt;键，值＆gt;没有默认构造函数的对在gcc 4.9.2中给出两页错误。第一个错误的行是：

visited_info[rect0] = info0;

我用MSVC ++ 12.0仔细检查过，我也有错误信息。

当我添加默认构造函数时，编译正常，并且在运行时调用默认构造函数。我无法理解为什么RectData类需要默认构造函数？

使用[]运算符从散列表中检索数据，在编译时也需要默认构造函数，但在运行时不调用它，为什么？

auto info = visited_info[rect];

注意：使用visited_info.emplace（）和visited_info.find（）更改代码可以解决问题，但不回答问题。

感谢您的回答。

完整代码如下。

#include <boost/functional/hash.hpp>
#include <tuple>
#include <vector>
#include <unordered_map>
#include <iostream>

using uint = unsigned int;

enum class Direction : int { left = 0, right = 1, up = 2, down = 3, null = 4 };

class RectData {
 public:
  RectData(uint width, uint height)
      : width_(width), height_(height), datas_(width * height, 0) {
    total_ = width_ * height_;
  }


  // A default constructor must be defined!
  RectData() : RectData(0u, 0u) {
    std::cout << "Calling the default constructor !!!" << std::endl;
  }

  size_t hash() const {
    return boost::hash_value(datas_);
  }

  bool operator==(const RectData &rect) const {
    return (width_ == rect.width_) &&
           (height_ == rect.height_) &&
           (datas_ == rect.datas_);
  }

  struct KeyHash {
    std::size_t operator()(const RectData &rect) const {
      return rect.hash();
    }
  };

  struct KeyEqual {
    std::size_t operator()(const RectData &r1, const RectData &r2) const {
      return r1 == r2;
    }
  };

 private:
  uint width_;
  uint height_;
  std::vector<uint> datas_;
  uint total_;
};

using StoredInfo = std::tuple<uint, RectData, Direction>;

int main() {
  std::unordered_map<RectData, StoredInfo, RectData::KeyHash,
                     RectData::KeyEqual> visited_info;

  RectData rect0(5u, 5u);
  RectData rect1(4u, 4u);
  RectData rect2(3u, 3u);
  RectData rect3(2u, 2u);

  StoredInfo info0 = std::make_tuple(10u, rect1, Direction::up);
  StoredInfo info1 = std::make_tuple(11u, rect2, Direction::down);
  StoredInfo info2 = std::make_tuple(12u, rect3, Direction::left);
  StoredInfo info3 = std::make_tuple(13u, rect0, Direction::right);


  // the line below requires a default RectData constructor!!! 
  visited_info[rect0] = info0;

  // default RectData constructor also needed here !!!
  visited_info[rect1] = std::move(info2);

  // but not needed here
  visited_info.insert(std::make_pair(rect2, info2));

  // and not needed here
  visited_info.emplace(rect3, info3);

  // but needed here and not called!!! 
  StoredInfo i1 = visited_info[rect1];
  std::cout << "Verify (must be 11) = " << std::get<0>(i1)
            << std::endl;

  // but needed here and not called!!! 
  StoredInfo &i2 = visited_info[rect2];
  std::cout << "Verify (must be 12) = " << std::get<0>(i2)
            << std::endl;


  // and not needed here
  auto it = visited_info.find(rect3); 
  std::cout << "Verify (must be 13) = " << std::get<0>(it->second)
            << std::endl;

}

Answer 1

visited_info[rect0] = info0;

嗯，你觉得这怎么样？它是well-documented，左侧评估对地图中存储的项目的引用。如果之前没有该项目，则首先默认构建它。

然后使用复制或移动赋值从表达式的右侧更新默认构造的项目。

如果您想避免现在使用的default-construct-and-assign操作，请改用emplace。

NB。一个可能的混淆源是，例如，Python，其中MyObj[1]可能会转换为__getitem__来电，MyObj[1]=1转换为__setitem__来电。

在C ++中，左手边和右手边的表达式都必须评估某些东西，而不知道它们所处的语句。因此，左手 - side评估为您可以读取或分配的引用 - 但是在您可以获取该引用之前，该对象需要存在。

为什么使用unordered_map和tuple需要默认构造函数？

1 个答案: