单例被摧毁

Question

我正在编写一个具有可以重写方法的类，问题是当我构造重写这些方法的类时，单例可以工作，而具有重写方法的类仍然存在。如何让新班级保持活力？

基类：

#pragma once

#include <string>

class File
{
    static File *singleton;

public:
    File();
    ~File();

    virtual char *read(std::string path);
    virtual void write(std::string path, const char *buffer);

    static File *get_singleton();
};

#include "File.h"
#include "../OS.h"

File *File::singleton = nullptr;

File::File()
{
    File::singleton = this;
}

File::~File()
{
}

char *File::read(std::string path)
{
    return nullptr;
}

void File::write(std::string path, const char *buffer)
{
}

File* File::get_singleton()
{
    return singleton;
}

我正在使用的代码：

#pragma once

#include <core/os/File.h>

class File_SDL : public File
{
public:
    File_Handler();

    char *read(std::string path) override;
    void write(std::string path, const char *buffer) override;
};

__

#include "File_Handler.h"

#include <core/OS.h>

File_Handler::File_Handler() : File()
{
}

char *File_Handler::read(std::string path)
{
}

void File_Handler::write(std::string path, const char *buffer)
{
}

如何重现该错误：

void other_function()
{
    //Crashes
    File::get_singleton()->write("file.txt", "Hello, World!");
}

void main()
{
   File_Handler handler = File_Handler();
   other_function();
}

单例应该正常工作，因为它们是静态的，但我得到的唯一结果只是地址处的访问冲突。

Answer 1

我遇到的问题是我声明的单例生命周期不够长，所以为了解决这个问题，我将短命单例放入一个在整个程序中都存在的单例中。