在C＆＃x2B;＆＃x2B;中访问堆上的数据

Question

我一直在尝试更深入地研究指针的局限性，以了解它们如何在幕后影响程序。我的研究导致我提出的一件事是，指示器创建的变量必须用C ++等语言删除，否则数据仍将在内存上。

我的问题涉及在功能生命周期结束后访问数据。如果我在函数中创建一个指针变量，然后该函数即可到达适当的关闭，那么如何访问数据？实际上，这只是垃圾占用空间吗？还是应该有一种在不存储地址在另一个变量中的情况下仍然引用它的方法？

Answer 1

没有自动垃圾收集。如果您将句柄（指针，参考，索引，...）丢给了您的资源，您的资源将实时 ad vitamæternam。

如果您希望自己的资源在将其手柄范围范围内停止时停止生活，那么RAII和智能指针就是您所需的工具。

如果您希望自己的资源在其手柄不在范围之后继续寿命，则需要复制手柄并将其传递。

Answer 2

使用标准智能指针 std :: simelor_ptr 和和 std :: sharde_ptr 当指针脱离范围时，释放了内存。范围末端后对象立即被销毁+释放，并且无法再访问它。除非您将指针从范围中移出到更大的范围，否则它将被删除。

但是，实施懒惰的垃圾收集器并不难。与您在各处使用智能指针一样，但Lazey变体也一样。现在，当指针脱离范围时，其对象不会立即被销毁+释放，而是将其委派给了懒惰的垃圾收集器，后者将在稍后在单独的线程中销毁+将其释放。正是我在下面的代码中实现的这种懒惰行为。

我仅出于娱乐而实现了以下代码，作为您的演示，没有重要的一点，为什么不使用 std :: simelor_ptr 和 std :: shared_ptr的标准贪婪释放技术/代码>。尽管有一个非常重要的用例-STD :: shared_ptr构造代码中的对象，当您调用构造函数时，并且您知道构造时间，但是在代码和时间的不同未定义点上摧毁了对象，因为有共享共享指针的副本。因此，您可能会在未预测的时间点上长期破坏延误，这可能会损害实时高性能代码。另外，破坏时间可能太大了。懒惰的删除将破坏移动到单独的线程中，可以以自己的节奏删除它。

尽管智能指针在范围内懒惰地处置，但是在一些纳米秒（甚至是微型秒）中，您可能仍然可以访问其未播放的/未经遗产的内存，但不能保证时间。这只是意味着真正的破坏可能比范围末端晚得多，因此是懒惰垃圾收集器的名称。您甚至可以调整这种懒惰的垃圾收集器，以便它确实删除了对象，请说1毫米之后，它们的智能指针被摧毁了。

真正的垃圾收集器正在做类似的事情，它们会在更晚的时间内释放对象，并且通常通过在内存中找到看起来像真正的堆指针的字节来自动这样做。

我的代码中有一个 test（）函数，该功能显示了我如何使用标准指针的懒惰变体。同样，当代码运行时，您可能会在控制台输出中看到它显示的内容类似：

Construct Obj(  592)
Construct Obj( 1264)
LazyDeleter Dispose( 1264)
LazyDeleter Dispose(  592)
Test finished
Destroy ~Obj( 1264)
Destroy ~Obj(  592)

在括号中，它显示了对象的ID（其指针的较低位）。您可能会看到处置和破坏是按照建筑顺序完全相反的顺序进行的。在测试完成之前，将懒垃圾收集器处置为懒惰垃圾收集器。虽然实际破坏在测试完成后稍后在单独的线程中发生。

在线尝试！

#include <deque>
#include <atomic>
#include <mutex>
#include <thread>
#include <array>
#include <memory>
#include <iostream>
#include <iomanip>


using DelObj = void (void *);
void Dispose(void * obj, DelObj * del);

template <typename T>
struct LazyDeleter {
    void operator ()(T * ptr) const {
        struct SDel { static void Del(void * ptr) { delete (T*)ptr; } };
        std::cout << "LazyDeleter Dispose(" << std::setw(5) << uintptr_t(ptr) % (1 << 16) << ")" << std::endl;
        Dispose(ptr, &SDel::Del);
    }
};

template <typename T>
using lazy_unique_ptr = std::unique_ptr<T, LazyDeleter<T>>;

template <typename T>
std::shared_ptr<T> make_lazy_shared(T * ptr) {
    return std::shared_ptr<T>(ptr, LazyDeleter<T>{});
}

void Dispose(void * obj, DelObj * del) {
    class AtomicMutex {
    public:
        auto Locker() { return std::lock_guard<AtomicMutex>(*this); }
        void lock() { while (f_.test_and_set(std::memory_order_acquire)) {} }
        void unlock() { f_.clear(std::memory_order_release); }
        auto & Flag() { return f_; }
    private:
        std::atomic_flag f_ = ATOMIC_FLAG_INIT;
    };

    class DisposeThread {
        struct Entry {
            void * obj = nullptr;
            DelObj * del = nullptr;
        };
    public:
        DisposeThread() : thr_([&]{
            size_t constexpr block = 32;
            while (!finish_.load(std::memory_order_relaxed)) {
                while (true) {
                    std::array<Entry, block> cent{};
                    size_t cent_cnt = 0;
                    {
                        auto lock = mux_.Locker();
                        if (entries_.empty())
                            break;
                        cent_cnt = std::min(block, entries_.size());
                        std::move(entries_.begin(), entries_.begin() + cent_cnt, cent.data());
                        entries_.erase(entries_.begin(), entries_.begin() + cent_cnt);
                    }
                    for (size_t i = 0; i < cent_cnt; ++i) {
                        auto & entry = cent[i];
                        try { (*entry.del)(entry.obj); } catch (...) {}
                    }
                }
                std::this_thread::yield();
            }
        }) {}
        ~DisposeThread() {
            while (!entries_.empty())
                std::this_thread::yield();
            finish_.store(true, std::memory_order_relaxed);
            thr_.join();
        }
        void Add(void * obj, DelObj * del) {
            auto lock = mux_.Locker();
            entries_.emplace_back(Entry{obj, del});
        }
    private:
        AtomicMutex mux_{};
        std::thread thr_{};
        std::deque<Entry> entries_;
        std::atomic<bool> finish_ = false;
    };

    static DisposeThread dt{};
    dt.Add(obj, del);
}

void Test() {
    struct Obj {
        Obj() { std::cout << "Construct Obj(" << std::setw(5) << uintptr_t(this) % (1 << 16) << ")" << std::endl << std::flush; }
        ~Obj() { std::cout << "Destroy ~Obj(" << std::setw(5) << uintptr_t(this) % (1 << 16) << ")" << std::endl << std::flush; }
    };
    {
        lazy_unique_ptr<Obj> uptr(new Obj());
        std::shared_ptr<Obj> sptr = make_lazy_shared(new Obj());
        auto sptr2 = sptr;
    }
    std::cout << "Test finished" << std::endl;
}

int main() {
    Test();    
}