Question

我有一段代码在运行时因各种奇怪的内存损坏而失败。我把它缩小到这部分代码：

List<CollisionBlock> WorldClient::getCollisionBlocks(RectF const& boundBox, bool doSort, Vec2F sortCenter) const {
  auto res = m_collisionGenerator.getPolys(boundBox);

  if (doSort) {
    sort(res, [=](CollisionBlock const& block1, CollisionBlock const& block2) {
    return magSquared(sortCenter - block1.poly.center()) < magSquared(sortCenter - block2.poly.center());
      });
  }

  return res;
}

如果我从lambda中删除const&，代码工作正常。我不知道为什么。我想知道我是否遇到了编译器错误，或者是否有一些我忽略的东西。

这是CollisionBlock的定义：

struct CollisionBlock {
  PolyF poly;
  // Will never be None
  CollisionKind kind;
  // Normalzied vector encoding the slope of the block we collided with.
  // Always faces right, y component can be positive or negative.
  Vec2F slope;
};

我可以在Linux 32位（g ++版本4.7.0和4.6.3），MacOSX（不确定字大小和g ++版本），Windows 7 64位（g ++版本4.6.3），Windows 7 32-上重现bit（g ++版本4.6.2和4.6.3），但不是Linux 64位（g ++版本4.6.1）。

我正在使用C ++ 11，而不是使用。

Poly::center()

Coord center() const {
  return sum(m_vertexes) / (DataType)m_vertexes.size();
}

sum

template<typename Container>
typename Container::value_type sum(Container const& cont) {
  return reduce(cont, std::plus<typename Container::value_type>());
}

reduce

// Somewhat nicer form of std::accumulate
template<typename Container, typename Function>
typename Container::value_type reduce(Container const& l, Function f) {
  typename Container::const_iterator i = l.begin();
  typename Container::value_type res{};

  if (i == l.end())
    return res;

  res = *i++;
  while (i != l.end())
    res = f(res, *i++);
  return res;
}

sort

template<typename Container, typename Compare>
void sort(Container& c, Compare comp) {
  std::sort(c.begin(), c.end(), comp);
}

这个问题还有很多。对不起，我会试着找一个更小的测试用例。

更新：

使用sum替换Poly::center中std::accumulate的来电无效。

Answer 1

我很确定错误超出了您发布的代码。你可以把我的虚拟代码放在下面＆amp;慢慢将其转换为您的真实代码，直到它开始显示问题。如果你发现它，请告诉我们，我很好奇。

仅供参考，我必须在几个地方编写代码才能获得您正在做的事情。所有这一切都是运用您发布的一小部分代码。

#include <list>
#include <deque>
#include <vector>
#include <algorithm>

typedef double mocish;

typedef int CollisionKind; //is actually enum class
typedef mocish RectF;

class Vec2F {
public:
  Vec2F() {
    vertexes.push_back(0);
    vertexes.push_back(0);
  }
  Vec2F(float a, float b) {
    vertexes.push_back(a);
    vertexes.push_back(b);
  }

  float operator[](unsigned index) const {
    return vertexes[index];
  }

  float operator[](unsigned index) {
    return vertexes[index];
  }

  Vec2F operator+(Vec2F const& other) const {
    return Vec2F(vertexes[0]+other[0], vertexes[1]+other[1]);
  }

  Vec2F operator-(Vec2F const& other) const {
    return Vec2F(vertexes[0]-other[0], vertexes[1]-other[1]);
  }

  Vec2F operator*(float other) const {
    return Vec2F(vertexes[0]*other, vertexes[1]*other);
  }

  Vec2F operator/(float other) const {
    return Vec2F(vertexes[0]/other, vertexes[1]/other);
  }

  Vec2F operator=(Vec2F const& other) {
    vertexes[0] = other[0];
    vertexes[1] = other[1];
    return *this;
  }

private:
  std::deque<float> vertexes;
};

float magSquared(Vec2F const& a) {
  return a[0]*a[0]+a[1]*a[1];
}

typedef Vec2F Coord;

// Somewhat nicer form of std::accumulate
template<typename Container, typename Function>
typename Container::value_type reduce(Container const& l, Function f) {
  typename Container::const_iterator i = l.begin();
  typename Container::value_type res{};

  if (i == l.end())
    return res;

  res = *i++;
  while (i != l.end())
    res = f(res, *i++);
  return res;
}     


template<typename Container>
typename Container::value_type sum(Container const& cont) {
  return reduce(cont, std::plus<typename Container::value_type>());
}


struct PolyF
{
    PolyF()
    {
        m_vertexes.resize(4);
        std::generate( m_vertexes.begin(), m_vertexes.end(), [](){ return Vec2F(std::rand(), std::rand());} );
    }

    std::vector<Coord> m_vertexes;

    Coord center() const 
    {
      return sum(m_vertexes) / (float)m_vertexes.size();
    }
};

struct CollisionBlock 
{
  PolyF poly;
  // Will never be None
  CollisionKind kind;
  // Normalzied vector encoding the slope of the block we collided with.
  // Always faces right, y component can be positive or negative.
  Vec2F slope;
};


template<typename Container, typename Compare>
void sort(Container& c, Compare comp) {
  std::sort(c.begin(), c.end(), comp);
} 

struct CollisionGen
{
    std::deque<CollisionBlock> getPolys( RectF const& ) const
    {
        std::deque<CollisionBlock> collision_block_moc(50);
        return collision_block_moc;
    }
};

struct WorldClient
{
    CollisionGen m_collisionGenerator;


    std::deque<CollisionBlock> getCollisionBlocks(RectF const& boundBox, bool doSort, Vec2F sortCenter) const 
    {
      auto res = m_collisionGenerator.getPolys(boundBox);

    //auto test = magSquared(sortCenter - res.front().poly.center()) < magSquared(sortCenter - res.front().poly.center());

      if (doSort) {
        sort(res, [=](CollisionBlock const& block1, CollisionBlock const& block2) {
        return magSquared(sortCenter - block1.poly.center()) < magSquared(sortCenter - block2.poly.center());
          });
      }

      return res;
    }
};

    int main() 
    {
        WorldClient wc;
        while (true) {
          wc.getCollisionBlocks( 42.0, true, {0,0} );
        }
    }

Answer 2

我的猜测是模板List＆lt;＆gt;上的迭代器不是随机访问迭代器，std :: sort需要，注意std :: list只提供双向迭代。

如果您已经实现了自己的列表，我建议您仔细检查迭代器实现，以确保它是正确的并提供完整的＆amp;正确实现随机访问迭代器的概念。

Answer 3

我注意到你通过说[=]但是使用引用将值传递给lambdas。要么你应该改变它，要么通过使用std :: ref传递值来真正使用对实例本身的预期引用。

Answer 4

你的比较器是一个严格的弱订单吗？它是否一致地命令其输入？我怀疑你实际上并没有在res中初始化reduce，因此center()最终会返回垃圾。这通常很容易检查 - 在声明res之后立即添加assert(f(res,res) == res)。

如果比较器不一致，则使用std::sort运行未定义的行为，这很容易导致崩溃。并且对平台，优化等敏感。

奇怪的lambda问题（编译器错误？）

4 个答案: