离开 c++ 时程序崩溃 功能....你认为它是什么？

Question

我有一个c++代码，我使用MSC9来编译它。 它总是随机崩溃。 例如，如果使用 `` 从 Perl 调用它，它会崩溃，但从命令行或 Ultimate++ 调用它时，它不会崩溃。

我的意思是从 Perl 调用它，例如。 f.exe arg1 arg2 arg3

堆栈跟踪没有显示太多内容。 逐行跟踪程序证明，程序在返回时最后失败了...

所以就像

int funcname()
{
    return 0; <-- crashing after that...
}

我猜测堆栈已损坏，堆栈展开后，它崩溃了..

会导致什么原因？ 该程序使用 PCRE、STL 和迭代器。 迭代器可以破坏堆栈吗？ 你会如何捕获这样的错误？

这可能是编译器错误吗？

注意：调试版本不会崩溃，只有发布版本才会崩溃...

该错误似乎与此 pvector 类有关。

我有一个与此类似的结构：

struct complexstr
{
 pvector<int> v;
 string v2;
 hash_map<string> hm;
 vector<string> vs; // similar
 int i;
};

它似乎失败了，因为这一行：

complexstr s1;
complexstr s2;

s2=s1; // it seems to fail here, if this is not there... there is no error.

我认为问题在于下面的类...... std::copy 在 pvector operator=(const pvector &pv) 中是正确的，对吗？

pvector 是一个 perl 兼容的向量...它的索引可以大于向量的分配大小。

更新1： 我收到了作业中存在漏洞的建议。 我改变了任务... 这就是它现在的样子：

 pvector& operator=(const pvector &pv)
  {
    delete [] m_rgArray;  
    m_rgArray=new value_type[pv.allocated];
    m_nIndex=pv.m_nIndex;
    allocated=pv.allocated;
    std::copy(pv.m_rgArray, pv.m_rgArray + pv.allocated, m_rgArray);  
    return *this;
  }

注意：通过添加 & 到返回类型，崩溃依然存在。 不过去掉泄漏后，加上delete[] m_rgArray; , 程序不再崩溃。 我不明白。 据我所知有泄漏 不会造成崩溃。 那么问题似乎已经解决了（？）。 问号显示了我的惊讶。 更新2： 这不，问题又回来了。 它只是消失了一段时间。 Update3：我想我已经找到了。 我使用 Microsoft 调试工具中名为 gflags.exe 和 Windbg.exe 的实用程序来查找确切位置。 我使用 gflags.exe /p /enable myprog.exe /full 来打开堆错误的异常。 目前，我认为该错误是由 FindClose(handle); 引起的。 其中句柄是一个随机值，未初始化。

旧版本：

 template<class _Ty>
  class pvector
  {
    public:
    _Ty * m_rgArray; // Declare array
    int m_nIndex; // Index to array
    int allocated;
    _Ty undefvalue;
    typedef _Ty value_type;
    typedef value_type & reference;
    typedef const value_type & const_reference;
    typedef custom_iterator<_Ty> iterator;
    typedef custom_iterator<_Ty> const_iterator;
    typedef int difference_type;
    typedef int size_type;
    //typedef typename pvector_type_traits<_Ty>::default_value default_value;

    pvector() : m_nIndex(0) 
    { // init index to 0
      m_rgArray = new value_type[10];
      allocated = 10;
      fill(0);
    }

    pvector(size_type s) : m_nIndex(0) 
    { // init index to 0
      size_type defsize = 10;
      if (s>10)
      {
        defsize = s;
      }
      m_rgArray = new value_type[defsize];
      allocated = defsize;
      fill(0);
    }
      pvector(pvector const& pv)
    : m_rgArray(new value_type[pv.allocated]),
    m_nIndex(pv.m_nIndex),allocated(pv.allocated)
    {
     std::copy(pv.m_rgArray, pv.m_rgArray + pv.allocated, m_rgArray);     
    }

    pvector operator=(const pvector &pv)
    {
    m_rgArray=new value_type[pv.allocated];
    m_nIndex=pv.m_nIndex;
    allocated=pv.allocated;
    std::copy(pv.m_rgArray, pv.m_rgArray + pv.allocated, m_rgArray);  
    return *this;
    }
    void clear()
    {
       m_nIndex=0; 
       fill(allocated);    
    }

    ~pvector() {
     delete []m_rgArray; 
    }

    size_type size() const
    { // return length of sequence
      return m_nIndex;
    }

    size_type max_size() const
    { // return maximum possible length of sequence
      return 0;
    }

    void fill(size_type si)
    {
      for (size_type i = si;i<allocated;i ++ )
      {
        m_rgArray[i] = pvector_type_traits<_Ty>::default_value();
      }
    }

    bool empty() const
    { // test if sequence is empty
      return (m_nIndex > 0 ? false : true);
    }

    iterator begin()
    { // return iterator for beginning of mutable sequence
      return iterator(&m_rgArray[0]);
    }

    const_iterator begin() const
    {
      return const_iterator(&m_rgArray[0]); 
    }

    iterator end()
    { // return iterator for end of mutable sequence
      return iterator(&m_rgArray[m_nIndex]);
    }

    const_iterator end() const
    {
      return const_iterator(&m_rgArray[m_nIndex]);
    }
    reference operator[](size_type i)
    {
      if (m_nIndex>i)
      {
        return m_rgArray[i];
      }
      else if (i >= allocated)
        {
          resize(i * 2);
        }
        m_nIndex = i + 1;
      return m_rgArray[i];
    } 
    void resize(size_type s)
    {
      value_type * m_rgArray2;
      size_type old_allocated = allocated;
      allocated = s;
      m_rgArray2 = new value_type[allocated];
        //if (allocated>m_nIndex)
        //{
        // m_nIndex=allocated;
       // }
       // cout <<"m_nIndex" << m_nIndex << "allocated" << allocated << endl;
      if (m_nIndex>allocated)
      {
        m_nIndex=allocated;
      }
      for (size_type i = 0;i<m_nIndex;i ++ )
      {
        m_rgArray2[i] = m_rgArray[i];
      }
      delete []m_rgArray;
      m_rgArray = m_rgArray2;
      fill(old_allocated);
    }

    reference back()
    {
      return &m_rgArray[m_nIndex - 1]; 
    }

    const_reference back() const
    {
      return m_rgArray[m_nIndex - 1]; 
    }

    void push_back(const _Ty &_Val)
    { // insert element at end
      if (size() < allocated)
        m_rgArray[m_nIndex ++ ] = _Val;
      else
        {
        resize(allocated * 2);
        m_rgArray[m_nIndex ++ ] = _Val; 
      }
    }

  };

Answer 1

这可能是缓冲区溢出导致堆栈损坏。 如果在运行函数时在本地定义的缓冲区之外进行写入，则它可以覆盖返回地址，然后从函数返回将触发程序崩溃。

您应该查找使用本地（堆栈分配）变量地址进行操作的语句 - 它们的缓冲区溢出很可能是问题的原因。

Answer 2

我能想到的可能性：

• 不同的迭代器/stl 检查项目和它链接到的内容之间的调试设置。 请参阅调试迭代器支持和检查迭代器。
• 您的项目及其链接到的任何内容之间的 CRT 设置不同。 使用 Dependency Walker 查看不匹配情况。
• 由于函数中的错误代码而导致堆栈损坏，例如写入超出数组或字符串的末尾。
• 导致堆栈或变量损坏的多线程问题。
• 调用约定不匹配（正如您提到的从 Perl 调用它）

Answer 3

这段代码有很多错误：

• 命名 - 我已经指出了 _Ty 的问题，但为什么有些成员以 m_ 开头，而其他成员则不然。 一些局部变量也以m_开头。 不好。

• 赋值操作不返回引用 - 正如已经指出的。

• 赋值操作有内存泄漏，在第一行，您分配给 m_rgArray，它已经有内容 - 这些已泄漏。

  赋值操作有内存

这是对于初学者来说的。 这些都不会导致崩溃，但它们都需要修复。 为了解决所有问题，我会重新开始，一次编写一个函数，并对其进行测试。 运行测试，如果有效，则编写下一个函数、下一个测试，依此类推。 像这样的模板类值得投入大量精力，因为如果它们是正确的，那么它们非常有用，但如果错误，则会带来持续的痛苦。

Answer 4

您是否有任何带有非平凡析构函数的基于堆栈的对象？ 根据您的调试器，可能很难判断它们何时执行。 除了其他评论中提到的所有内容之外，这可能与此相关。

Answer 5

关于您的操作员的另一条评论=

• 您没有处理自我分配正确地
• 在同一个运算符中，我认为您正在泄漏，我建议您使用 boost::scoped_array 而不是普通指针。

我不知道这是否是给您带来问题的原因，但由于您似乎有内存损坏问题，因此可能值得关注。

Answer 6

我假设以下函数有更多代码

int funcname()
{
    return 0; <-- crashing after that...
}

当函数返回时，任何堆栈变量都将调用其析构函数。 崩溃很可能发生在其中一个析构函数中。

如何追踪它：

在函数中声明的任何变量的析构函数中放置断点。 单步执行每个析构函数。 请记住，当析构函数被调用时，来自基类的一整套析构函数将被自动调用，并且损坏可能发生在其中任何一个析构函数中。

Answer 7

在您的函数 (funcname) 或由 funcname 调用的函数之一中，您可能有一些破坏堆栈的代码。

我遇到的大多数“实践”堆栈损坏是内存复制或字符串复制，当分配的目标缓冲区不适合要复制的数据的大小时（使用 sizeof 和元素数量错误计算大小，不考虑结尾）调整目标缓冲区大小以进行字符串复制时的字符串终止符）。

另一种不太常见的可能性是：指针算术，当引用局部变量或数组并通过该指针更改它们时。

Answer 8

您的赋值运算符应该返回一个引用：

pvector& operator=(const pvector &pv)  {

我怀疑这会导致问题，但请尝试一下。

Answer 9

调试器说什么？ 在返回行之后，它会遍历所有超出范围的对象的析构函数，其中一个几乎肯定会搞砸。
因此，在返回行处放置一个断点，然后使用调试器单步执行，直到发生崩溃。

Answer 10

我的猜测是您的 pvector 在调整大小期间超出了数组。 我试图阅读代码来确定这是否属实，但我没有看到任何明显的东西。 如果您真正想要的是一个可以增长以适应所访问的任何索引的向量，那么您不需要自己编写整个内容。 您可以扩展 std::vector 并仅使用 Reserve()/resize() 方法，并让 STL 处理所有复制、内存管理和迭代器。 以下内容应该可以工作：

template<typename StoredType>
class pvector : public std::vector<StoredType>
{
public:
    typedef typename std::vector<StoredType, std::allocator<StoredType> >::reference reference;
    typedef typename std::vector<StoredType, std::allocator<StoredType> >::size_type size_type;

    reference at(size_type n)
    {
        size_type need = n+1;
        if(need > std::vector<StoredType>::capacity())
        {
            std::vector<StoredType>::reserve(need * 2);
            std::vector<StoredType>::resize(need);
        }
        else if(need > std::vector<StoredType>::size())
        {
            std::vector<StoredType>::resize(need);
        }
        return std::vector<StoredType>::at(n);
    }

    reference operator[](size_type n)
    {
        return at(n);
    }
};

我在 Linux 上使用 GCC 4.1.2 对其进行了测试，因此希望它也能在 Windows 上编译。

编辑：这是一个不继承的新版本，因为专家似乎认为这不是一个好主意（我学到了一些新东西，是的）。 您可以实现所需的其余方法并直接传递给 m_vector：

template<typename StoredType>
class pvector
{
public:
    typedef StoredType& reference;
    typedef int size_type;

    reference at(size_type n)
    {
        int need = n+1;
        if(need >= m_vector.capacity())
        {
            m_vector.reserve(need * 2);
            m_vector.resize(need);
        }
        else if(need >= m_vector.size())
        {
            m_vector.resize(need);
        }
        return m_vector.at(n);
    }

    reference operator[](size_type n)
    {
        return at(n);
    }

    size_type capacity() { return m_vector.capacity(); }
    size_type size() { return m_vector.size(); }

private:
    std::vector<StoredType> m_vector;
};

Answer 11

由于您的详细信息并不具体说明崩溃，我建议使用您的 IDE 调试应用程序：
在 ProjectProperties->ConfigurationProperties->Debugging 中将命令和命令参数设置为您的 perl / Ultimate++ 应用程序。 在调试模式下编译并在怀疑崩溃的地方放置断点。 定位问题并就崩溃本身提出有意义的消息应该相当简单。