C++ 析构函数和分配器：：destroy之间有什么区别

有这门课：

template<class T>
class Vec
{
public:
    typedef T* iterator;
    typedef T* const const_iterator;
    typedef T value_type;

    Vec() {
        create();
    }
    explicit Vec(size_t n, const T& val = T()) {
        create(n, val);
    }
    void clear() //here, I cannnot destroy nither by alloc.destroy, nor i->~T()
    {
        if (data)
        {
            iterator i = avail;
            while (i != data)
            {
                alloc.destroy(--i); //or i->~T()
            }
        }
        avail = data;
    }
    ...
private:
    iterator data;
    iterator avail;
    iterator limit;

    std::allocator<T> alloc;
    void create();
    void create(size_t n, const T &val);
    ...

1.）

---

现在，即使我已经清除了

Vec

类（对其中的所有元素执行析构函数），我仍然可以输出

v[2]->“abc”

甚至认为字符串应该执行析构函数，因此是空字符串

---

2.）我应该使用

alloc.destroy（I）

，其中

I

是

T*

，还是应该使用

I->~T（）

？

销毁对象意味着以后不允许查看它。例如，对于实现来说，没有理由费心将一堆

0

s写入该内存中，因此内存地址通常仍然包含与以前相同的数据。但这并不意味着你可以看它。这被称为。并且

destroy

是否等于

destroct

？“字符串应该执行析构函数，因此是空字符串”是错误结论。正确的是：“因此，我不允许再使用它，这是UB”。你为什么要在销毁时“清除”字符串？这种清洁有什么作用？它只会浪费指令。相同的空间以后可以重复使用。这种情况经常发生，人们设计的东西尽可能的高效。但这是一个无关的实现细节。与此相关的是，在解除分配后不允许访问内存。这一非常好的答案与此密切相关：销毁对象意味着以后不允许查看它。例如，对于实现来说，没有理由费心将一堆

0

s写入该内存中，因此内存地址通常仍然包含与以前相同的数据。但这并不意味着你可以看它。这被称为。并且

destroy

是否等于

destroct

？“字符串应该执行析构函数，因此是空字符串”是错误结论。正确的是：“因此，我不允许再使用它，这是UB”。你为什么要在销毁时“清除”字符串？这种清洁有什么作用？它只会浪费指令。相同的空间以后可以重复使用。这种情况经常发生，人们设计的东西尽可能的高效。但这是一个无关的实现细节。与此相关的是，解除分配后不允许访问内存。这一非常好的答案与此密切相关：

#include "vec2.hpp"
#include <iostream>
#include <string>

using namespace std;

int main()
{
    Vec<string> v(3, "abc");
    v.clear();
    cout << v[2] << endl;
}