错误：AddressSanitizer：在pc Y处的地址X上出现堆缓冲区溢出，bp Z，sp W。

Question

错误：AddressSanitizer：在pc Y处的地址X上出现堆缓冲区溢出，bp Z，sp W。

c++constructorheap-memorydynamic-memory-allocationaddress-sanitizer

6

我对动态内存管理和使用Fsanitise标志来查找内存管理问题还很陌生。我不能使用向量存储数据，必须使用原始数组，以及"new"和"delete"来管理堆对象。

当我尝试运行已编译的EuclideanVectorTester程序时，出现了以下错误，但我不确定问题是什么，请问有人可以帮我解决吗？

weill % make
g++ -std=c++14 -Wall -Werror -O2 -fsanitize=address -c EuclideanVectorTester.cpp
g++ -std=c++14 -Wall -Werror -O2 -fsanitize=address -c EuclideanVector.cpp
g++ -fsanitize=address EuclideanVectorTester.o EuclideanVector.o -o EuclideanVectorTester
weill % ./EuclideanVectorTester
1
=================================================================
==15341==ERROR: AddressSanitizer: heap-buffer-overflow on address 0xb59007e0 at pc 0x8048ca7 bp 0xbfb47388 sp 0xbfb4737c
WRITE of size 8 at 0xb59007e0 thread T0
    #0 0x8048ca6 in main (/tmp_amd/kamen/export/kamen/3/z3386180/cs6771/evec/EuclideanVectorTester+0x8048ca6)
    #1 0xb6ecae45 in __libc_start_main (/lib/i386-linux-gnu/i686/cmov/libc.so.6+0x16e45)

0xb59007e0 is located 0 bytes to the right of 16-byte region [0xb59007d0,0xb59007e0)
allocated by thread T0 here:
    #0 0xb722a4c4 in operator new[](unsigned int) (/usr/lib/libasan.so.1+0x524c4)
    #1 0x8048b9a in main (/tmp_amd/kamen/export/kamen/3/z3386180/cs6771/evec/EuclideanVectorTester+0x8048b9a)
    #2 0xb6ecae45 in __libc_start_main (/lib/i386-linux-gnu/i686/cmov/libc.so.6+0x16e45)
    #3 0x8048d8c (/tmp_amd/kamen/export/kamen/3/z3386180/cs6771/evec/EuclideanVectorTester+0x8048d8c)

SUMMARY: AddressSanitizer: heap-buffer-overflow ??:0 main
Shadow bytes around the buggy address:
  0x36b200a0: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
  0x36b200b0: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
  0x36b200c0: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
  0x36b200d0: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
  0x36b200e0: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
=>0x36b200f0: fa fa fa fa fa fa fa fa fa fa 00 00[fa]fa 04 fa
  0x36b20100: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
  0x36b20110: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
  0x36b20120: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
  0x36b20130: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
  0x36b20140: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
Shadow byte legend (one shadow byte represents 8 application bytes):
  Addressable:           00
  Partially addressable: 01 02 03 04 05 06 07 
  Heap left redzone:       fa
  Heap right redzone:      fb
  Freed heap region:       fd
  Stack left redzone:      f1
  Stack mid redzone:       f2
  Stack right redzone:     f3
  Stack partial redzone:   f4
  Stack after return:      f5
  Stack use after scope:   f8
  Global redzone:          f9
  Global init order:       f6
  Poisoned by user:        f7
  Contiguous container OOB:fc
  ASan internal:           fe
==15341==ABORTING
weill %

EuclideanVector.h文件如下：

#ifndef _EuclideanVector_h
#define _EuclideanVector_h

#include <iostream>
#include <algorithm>


namespace even {
    class EuclideanVector {

        public:

            /*
             * A constructor that takes the number of dimensions (as an unsigned int) but no magnitudes, 
             * sets the magnitude in each dimension as 0.0. This is the default constructor, with the default value being 1.
             */
            template <typename NUM>
            EuclideanVector(const NUM dimensions = 1): 
                  EuclideanVector(dimensions, 0.0) {}; // delegating constructor; default constructor that takes in dimensions if there is user input, otherwise dimensions = 1 if it is an empty constructor

            // target constructor for delegating constructor
            template <typename NUM1, typename NUM2> // any numeric types of user input for dimensions and magnitude will be static_cast to unsigned int and double respectively
            EuclideanVector(const NUM1 dimensions, const NUM2 magnitude){

                        // static cast to unsigned int and assign dimensions_ to that
                        dimensions_ = new unsigned int (static_cast<unsigned int>(dimensions));

                        // assign pointer "magnitude_" to dynamically-allocated memory of new unnamed array<double> object of size "dimensions_"
                        magnitude_  =  new double [*dimensions_];

                        // fill the array<double> object "magnitude_" a number of "dimensions_" times, with the <double> value of "magnitude_" for each dimension
                        std::fill_n(magnitude_, dimensions_, static_cast<double>(magnitude));

                  }

            /*
             * Destructor: ~EuclideanVector
             * The destructor deallocates any memory acquired by the constructors. 
             */
            ~EuclideanVector();


            /*
             * Member function: getMagnitude()
             * Returns a double containing the number of dimensions in a particular array.
             */
            const double& getMagnitude () const;


            /*
             * Member function: getNumDimensions()
             * Returns an unsigned int containing the number of dimensions in a particular vector.
             */
            unsigned int getNumDimensions() const;


        private:
        /* Everything from here to the end of the class is private, so
         * not accessible or intended for use for the client */

            unsigned int *dimensions_;
            double *magnitude_;
            //double normal_;
        };
}

#endif

EuclideanVector.cpp文件如下：

#include "EuclideanVector.h"
#include <algorithm>
#include <cmath> // for sqrt
#include <sstream>
#include <iterator>

namespace even {

    unsigned int EuclideanVector::getNumDimensions () const
    {
        return *dimensions_;
    }

    const double& EuclideanVector::getMagnitude () const
    {
        return *magnitude_;
    }

    // destructor
    EuclideanVector::~EuclideanVector() {
        delete dimensions_;
        delete [] magnitude_;
    }
}

而EuclideanVectorTester.cpp文件如下：

#include <iostream>
#include <vector>
#include <list>

#include "EuclideanVector.h"

int main() {

    std::cout << "1" << std::endl;

    evec::EuclideanVector a(2); 


    std::cout << "2" << std::endl;
    std::cout << "3" << std::end;

}

- iteong

3

那位教授的演讲“很棒”（用讽刺的口吻，因为它充满了你知道的内容）。可惜他/她没有就复制构造函数、赋值运算符、析构函数、异常安全等方面进行演讲。你会认为初学者可以自己实现这些 - - 我还没有看到一个初学者能够在没有经验丰富的 C++ 程序员大量帮助的情况下正确地实现它们。 - PaulMcKenzie

使用原始内存的主要原因是为了让每个人都有机会更好地理解和练习移动语义，因为存在原始指针。如果你仔细想一下，用内部数组实现向量的效率永远不会比使用向量低。在我们的情况下，将分配一个单一的一维数组，没有与STL向量相关的额外簿记负担。 - iteong

3

显然你的教授不希望你在他的课程之前阅读Knuth。不想说得太委婉了，他像一个专注于谈论代码而不是写代码的人一样卖弄自己。祝你好运。 - WhozCraig

1

大家好！我意识到了之前代码中指针dimensions_和magnitude_的声明有问题。我忘记在std:fill_n中解除引用dimensions_。这就是为什么会出现分段错误的原因。谢谢！=D - iteong

1

考虑使用“-O0 -g3”进行编译，以获得更好的调试注释输出。 - kfsone

显示剩余11条评论

1个回答

网页内容由stack overflow 提供, 点击上面的

可以查看英文原文，
原文链接

- PaulMcKenzie · Accepted Answer

让我说一下，你的教授所说的有很多不准确之处（至少可以这么说）。

话虽如此，问题在于你声明了 dimensions 为 unsigned int*，但是在这里却像使用普通的 unsigned int 一样使用它：

std::fill_n(magnitude_, dimensions_, static_cast<double>(magnitude));

立即解决方法是这样的：

std::fill_n(magnitude_, *dimensions_, static_cast<double>(magnitude));

然而，这引出了一个问题，为什么一个简单的unsigned int需要成为一个指针，然后使用new进行分配。实际上没有必要这样做，因为使用new比你现在所做的方法更低效。

如果你将dimensions_声明为：

unsigned int dimensions_;

如果不是指针，那么分配给dimensons_的代码将变成这样：

// no call to new is done
dimensions_ = static_cast<unsigned int>(dimensions);

// no dereference of a pointer needs to be done on the two lines below 
magnitude_ = new double[dimensions_];
std::fill_n(magnitude_, dimensions_, static_cast<double>(magnitude));

不需要额外调用分配器，因此该代码立即变得更加高效。

此外，析构函数现在如下所示：

EuclideanVector::~EuclideanVector() 
{
    delete [] magnitude_;
}

但即使这些都已经说明了，仅仅使用给出的答案只能修复当你使用同一个main程序测试时的问题。如果你把main改成下面这样：

even::EuclideanVector a(2);
even::EuclideanVector b = a;

现在你将遇到复制语义不正确的情况。因此，上面的修复仅需要使您的main函数正常工作。将main更改为像上面的示例那样非常简单，您会遇到更多问题。