释放内存时的访问冲突 我正在经历加速C++，我正在尝试创建我的CH11版本。当试图通过析构函数释放内存时，无论是创建空的“Vec”还是使用pushback，我都会获得读访问内存。我不确定我错过了什么。 谢谢你的帮助 #include "Vec.h" int main() { Vec<int> v; return 0; } #包括“Vec.h” int main（） { Vec-v； 返回0； }

/////////

#include <algorithm>
#include <cstddef>
#include <memory>


using std::max;

/////////////////////////////
template <class T> class Vec {
public:
    typedef T* iterator;
    typedef const T* const_iterator;
    typedef size_t size_type;
    typedef T value_type;
    typedef T& reference;
    typedef const T& const_reference;

    //Constructor
    Vec() { create();}
    explicit Vec(size_type n, const T& = T()) {create(n,t);}

    //Copy
    Vec(const Vec& v) {create(v.begin(), v.end());}
    //Assignment
    Vec& operator=(const Vec&);
    //Destructor
    ~Vec() { uncreate();}

    //Indexing
    T& operator[](size_type i) {return data[i]; }
    const T& operator[](size_type i) const { return data[i]; }



    //Size
    size_type size() const { return avail - data; } 

    //Return member variables
    iterator begin() { return data; }
    const_iterator begin() const { return data; }

    iterator end() { return avail; }
    const_iterator end() const {return avail; }

    //Uncreate
    void clear() { uncreate(); }
    //Check empty
    bool empty() const { return data == avail; }
//////////////////////
private:
    iterator data; //first
    iterator avail; //(one past) last element
    iterator limit; //(one past) allocated memory

    std::allocator<T> alloc; // object for memory allocation

    //allocate and initialize thorugh constructors
    void create();
    void create( size_type, const T&);
    void create(const_iterator, const_iterator);

    //destory 
    void uncreate();


};
////////////////////////////
template <class T> void Vec<T>::create()
{
    data = avail = limit;
}

template <class T> void Vec<T>::create(size_type n, const T& val)
{
    data = alloc.allocate(n , 0);
    limit = avail = data + n;
    std::uninitialized_fill(data, limit, val);
}

template <class T> void Vec<T>::create(const_iterator i, const_iterator j)
{
    data = alloc.allocate(j - i, 0);
    limit = avail = std::uninitialized_copy(i , j, data);
}

template <class T> void Vec<T>::uncreate()
{
    if(data) {
        iterator it = avail;
        while(it != data)
            alloc.destroy(--it);
        alloc.deallocate(data, limit - data);
    }
    data = limit = avail = 0;
}

#包括
#包括
#包括
使用std：：max；
/////////////////////////////
模板类Vec{
公众：
typedef T*迭代器；
typedef常量T*常量迭代器；
typedef size_t size_type；
类型定义T值_类型；
typedef T&reference；
类型定义常数T和常数U参考；
//建造师
Vec（）{create（）；}
显式Vec（size_type n，const T&=T（））{create（n，T）；}
//抄袭
Vec（const-Vec&v）{create（v.begin（），v.end（））；}
//分配
向量和运算符=（常量向量和）；
//析构函数
~Vec（）{uncreate（）；}
//索引
T&运算符[]（size_type i）{返回数据[i]；}
常量T&运算符[]（size_type i）常量{返回数据[i]；}
//大小
size_type size（）常量{return avail-data；}
//返回成员变量
迭代器begin（）{返回数据；}
常量迭代器begin（）常量{返回数据；}
迭代器end（）{return avail；}
常量迭代器end（）常量{return avail；}
//取消创建
void clear（）{uncreate（）；}
//空头支票
bool empty（）常量{return data==avail；}
//////////////////////
私人：
迭代器数据；//第一个
迭代器avail；/（过去一次）最后一个元素
迭代器限制；//（过去一次）分配的内存
std:：allocator alloc；//内存分配的对象
//分配和初始化thorugh构造函数
void create（）；
创建空心（尺寸类型、常数和）；
void create（常量迭代器，常量迭代器）；
//破坏
void uncreate（）；
};
////////////////////////////
模板void Vec:：create（）
{
数据=有效=限制；
}
模板void Vec:：create（大小\类型n，常数T&val）
{
数据=分配分配（n，0）；
极限=有效=数据+n；
标准：未初始化的填充（数据、限制、val）；
}
模板void Vec:：create（常量迭代器i，常量迭代器j）
{
数据=分配分配（j-i，0）；
limit=avail=std:：未初始化的拷贝（i、j、数据）；
}
模板void Vec:：uncreate（）
{
如果（数据）{
迭代器it=avail；
while（it！=数据）
alloc.destroy（--it）；
分配解除分配（数据，限制-数据）；
}
数据=限值=有效值=0；
}

使用前，两个构造函数都需要在初始值设定项列表中初始化其成员（SB指出，在分配确定值之前，

create（）

中使用了该列表）。当析构函数被激发时，您很可能正在使用一个不确定的指针值，并将其发送给释放

更改此项：

Vec() { create();}
explicit Vec(size_type n, const T& = T()) {create(n,t);}

为此：

Vec() : data(), avail(), limit() { create();}
explicit Vec(size_type n, const T& t = T()) 
    : data(), avail(), limit() {create(n,t);}

---

在

create（）

您在

Vec

的构造函数中尝试过gdb吗？这里引用了

create（n，t）

。参数中未提供此类

t

。请更新此文件，使其可编译。您正在通过

create（）

创建一个不分配任何内存的空

Vec

。在

~Vec（）

中调用

uncreate（）

时，您完全可以释放内存，这一点不奇怪吗？您的

数据

不是

nullptr

。某人。一定是对的。谢谢某人。我没有试过gdb。谢谢你给我指路。不需要在第一个构造函数中调用

create

。或者，由于

create（）

本身已损坏/无意义，另一种修复方法可能是更改它。@MooingDuck，如我所述，我同意。如果OP向

create（）

“family”添加了功能，并且想知道为什么默认的ctor没有拾取它，我想她可以把它放回去。我之所以保留它，是因为它对OP似乎很重要。至于更改它和不使用初始值设定项列表，我不喜欢在成员不确定的对象上调用成员函数（或任何其他函数）。我喜欢他们在任何人对他们有裂缝之前初始化。（但你肯定是对的，这是毫无意义的）谢谢WhozCraig&SB。我一直在阅读这本书，它的源代码没有涉及初始值设定项列表，所以我认为初始值不是问题所在。@Emcy请尝试将它作为大多数变量的习惯。（在某些情况下，如参考文献，这不仅仅是一种习惯；它是必需的）。如果你总是确保你的变量（成员或其他）有确定的值，它将保护你免受成堆的挫折。