Question

我为unordered_set创建了一个自定义类和自定义哈希函数。每次我尝试插入到unordered_set时，都会出现内存错误：

malloc: *** error for object 0x9000000000000000: pointer being freed was not allocated
*** set a breakpoint in malloc_error_break to debug
Abort trap: 6

我必须使用unordered_set。

这是我的自定义类：

template <class T>
class Seed {

  private:
    Point start;
    int seed_size;
    T** data;
    Seed* seed_match;
    T _value;

  public:
    Seed(int x, int y, int s): seed_size(s), data( new T*[s] ), _value( T() ) {
      start = Point(x, y);
      for ( int i = 0; i < seed_size; i++ )
          data[i] = new T[seed_size];

      for ( int i = 0; i < seed_size; i++ ) {
        for ( int j = 0; j < seed_size; j++ ) data[i][j] = NULL;
      }

      seed_match = NULL;
    }

    ~Seed() {
        for ( int x = 0; x < seed_size; x++ ) {
            delete [] data[x];
        }
      delete [] data;
    }

    void add(int x, int y, T color_val) {
      assert( data[x][y] == NULL );
      data[x][y] = color_val;
      _value += color_val;
    }

    bool match ( const Seed &_match ) {
      if ( seed_match == NULL ) {
        seed_match = &_match;
        return true;
      }
      else return false;
    }

    T get_color(int x, int y) const {
      assert( x >= 0 );
      assert( y >= 0 );
      assert( x < seed_size );
      assert( y < seed_size );

      return data[x][y];
    }

    bool operator==( const Seed<T> &b ) {

      for ( int x = 0; x < seed_size; x++ ) {
        for ( int y = 0; y < seed_size; y++ ) {
          if ( get_color(x, y) != b.get_color(x, y) ) return false;
        }
      }

      return true;

    }

    int seed_value() const { return _value; }

};

这些是我的自定义哈希函数：

template <class T>
struct SeedEqualByValue {
public:
    bool operator()(const Seed<T> & seed1, const Seed<T> & seed2) const {

        if (seed1.seed_value() == seed2.seed_value())
            return true;
        else
            return false;
    }
};

template <class T>
struct SeedHashByValue {
public:
    size_t operator()(const Seed<T> & s1) const {
        return std::hash<int>()( s1.seed_value() );
    }
};

在我的主要内容中，我将Seed类的3个实例实例化为3个变量，并实例化了一个接受Seed的unordered_set，其中hash函数作为我的SeedHashByValue结构，我的compare函数作为SeedEqualByValue结构。创建unordered_map后，无论何时将Seed对象插入unordered_map，我都会收到malloc错误，我不知道如何解决这个问题。

这些是我的主要功能的内容：

Seed<int> b(0, 0, 5);
Seed<int> a(0, 0, 5);
Seed<int> c(0, 0, 5);
c.add(4, 4, 100);
a.add(1, 2, 4);
a.add(1, 1, 3);
b.add(1, 1, 3);
unordered_set<Seed<int>, SeedHashByValue<int>, SeedEqualByValue<int> > seeds;
seeds.insert(c);

此外，Point只是一个包含公共成员变量int x和int y的x和y值的类，以防任何人需要澄清。

Answer 1

要跟进@Algirdas所说的内容，我相信发生的事情是Seed被浅层复制到集合中，所以你最终会得到一个双delete相同的父指针，一旦集合超出范围，一旦变量超出范围。

您需要通过在赋值运算符中传输数据或使用std::unique_ptr之类的内容来修改数据的处理方式，并确保分配数据（默认情况下会转移所有权）

插入到unordered_set中的C ++会破坏我的程序

1 个答案: