为什么在自定义 STL、C++ VS2019 中创建 2 个变量会导致崩溃？

Question

您好，我正在尝试重写我自己的内存管理器和 STL（没什么花哨的，只是一些基本的向量和字符串功能），但我遇到了一个奇怪的行为。我正在努力获得内存管理领域的经验，因为我是一名高中生，有空余时间。问题是，当我创建第一个变量时，一切都很顺利，但是在创建第二个变量后，程序在创建第一个变量时崩溃。

String.h/.cpp

    class String {
        char* pointer_toBuffer = nullptr;
        size_t buffer_length = 0;
        IAllocator* Allocator;
    public:
        String(const char* text, IAllocator* Allocator);}

    String::String(const char* text, TuranAPI::MemoryManagement::IAllocator* MemoryAllocator) : Allocator(MemoryAllocator) {
        std::cout << "String creation has started: " << text << std::endl;
        unsigned int i = 0;
        while (text[i] != 0) {
            i++;
        }
        buffer_length = i + 1;
        pointer_toBuffer = (char*)Allocator->Allocate_MemoryBlock(buffer_length * sizeof(char));//When I write the Second String part, FirstString crashes directly. I use VSDebug and it says access violation here while creating FirstString. It is successful if I delete the SecondString part.
        for (unsigned int letterindex = 0; letterindex < i; letterindex++) {
            pointer_toBuffer[letterindex] = text[letterindex];
        }
        pointer_toBuffer[i] = 0;
    }

内存管理.h/cpp

    TAPIMemoryAllocator::TAPIMemoryAllocator(MemoryBlockInfo MemoryPool_toUse){
        std::cout << "TAPIMemoryAllocator is created!\n";
        std::cout << "MemoryPool's start pointer: " << MemoryPool_toUse.address << std::endl;
        MemoryPool.address = MemoryPool_toUse.address;
        MemoryPool.size = MemoryPool_toUse.size;
        SELF = this;
    }
    void* TAPIMemoryAllocator::Allocate_MemoryBlock(size_t size) {
        std::cout << "MemoryPool's start pointer: " << MemoryPool.address << std::endl;
        std::cout << "A buffer of " << size << " bytes allocation request found in TAPIMemoryAllocator!\n";
        if (SELF == nullptr) {
            TMemoryManager First(1024 * 1024 * 1024 * 1);
            MemoryBlockInfo FirstMemoryBlock;
            FirstMemoryBlock.address = SELF->MemoryPool.address;
            FirstMemoryBlock.size = size;
            Allocated_MemoryBlocks[0] = FirstMemoryBlock;
            return (char*)SELF->MemoryPool.address;
        }
        void* finaladdress = SELF->MemoryPool.address;
        for (unsigned int blockindex = 0; blockindex < MAX_MEMORYBLOCKNUMBER; blockindex++) {
            MemoryBlockInfo& MemoryBlock = Allocated_MemoryBlocks[blockindex];
            finaladdress = (char*)finaladdress + MemoryBlock.size;
            if (size <= MemoryBlock.size && MemoryBlock.address == nullptr) {
                std::cout << "Intended block's size is less than found memory block!\n";
                MemoryBlock.address = finaladdress;
                //You shouldn't change Memory Block's size because all of the allocations before this are based upon the previous size!
                //You should move all the previous allocated memory to set the size (which is not ideal!)
                //If I'd want to find memory leaks causing this, I could write code here to log the leaks!
                return MemoryBlock.address;
            }
            else if (MemoryBlock.size == 0 && MemoryBlock.address == nullptr) {
                std::cout << "An empty block is created for intended block! Block's Array index is: " << blockindex << "\n";
                std::cout << "MemoryPool's start pointer: " << MemoryPool.address << std::endl << "MemoryBlock's pointer: " << finaladdress << std::endl;
                //This means this index in the Allocated_MemoryBlocks has never been used, so we can add the data here!
                MemoryBlock.address = finaladdress;
                MemoryBlock.size = size;
                return MemoryBlock.address;
            }
        }
        //If you arrive here, that means there is no empty memory block in the Allocated_MemoryBlocks array!
        std::cout << "There is no empty memory block in the Allocated_MemoryBlocks array, so nullptr is returned!\n";
        return nullptr;
    }

    TMemoryManager::TMemoryManager(size_t Main_MemoryBlockSize) {
        if (SELF != nullptr) {
            std::cout << "You shouldn't create a MemoryManager!";
            return;
        }
        std::cout << "TMemoryManager is created!\n";
        MainMemoryBlock.address = malloc(Main_MemoryBlockSize);
        MainMemoryBlock.size = Main_MemoryBlockSize;
        SELF = this;
        std::cout << "Main Memory Block's start pointer: " << MainMemoryBlock.address << std::endl;

        MemoryBlockInfo TuranAPI_MemoryPool;
        TuranAPI_MemoryPool.address = MainMemoryBlock.address;
        std::cout << "TuranAPI_MemoryPool.address: " << TuranAPI_MemoryPool.address << std::endl;
        TuranAPI_MemoryPool.size = 1024 * 1024 * 10;
        TAPIMemoryAllocator Create(TuranAPI_MemoryPool);
    }
    TMemoryManager* TMemoryManager::SELF = nullptr;
    TMemoryManager First(1024 * 1024 * 1024 * 1);

Main.cpp

String FirstString("How are you?", TAPIMemoryAllocator::SELF);
std::cout << FirstString << std::endl; //If I delete the below, it prints "How are you?" as expected
String SecondString("I'm fine, thanks!", TAPIMemoryAllocator::SELF);
std::cout << SecondString << std::endl; 

Answer 1

已解决：问题出在分配器中。当分配器超出范围时，它的 Allocate_MemoryBlock 函数（它是一个虚函数，不是静态的）被删除。我不知道为什么只创建一个字符串（可能是编译器优化）但存储分配器本身（所有变量都已经是静态的）并将 SELF 作为存储的指针解决了这个问题。