我怎样才能创建我的单例常量的实例？

Question

我正在尝试为 Ogre（一个开源 3D 引擎）的标准日志记录类制作一个包装器。 我希望它具有与 std::cerr 相同的语法，并且在 Linux 上运行时也输出到 cerr。 这就是我所拥有的：

#ifndef _LOGGER_H_
#define _LOGGER_H_

#ifndef _XSTRING_
    #include <xstring>
#endif

#ifndef __LogManager_H__
    #include "OgreLogManager.h"
#endif

class Logger
{

public:

    static Logger* m_Instance;
    static Logger* getInstance() { return m_Instance; }
    static const Logger& getInstanceConst() { return *m_Instance; }

    Logger& operator << (const std::string& a_Message)
    {
        m_Log.append(a_Message);
        _CheckNewLine();
        return *m_Instance;
    }

    Logger& operator << (const char* a_Message)
    {
    m_Log += a_Message;
    _CheckNewLine();
    return *m_Instance;
}

private:

    std::string m_Log;

    Logger() 
    {
        m_Log = "";
    }

    void _CheckNewLine()
    {
        if (m_Log.at(m_Log.size() - 1) == '\n')
        {   
            Ogre::LogManager::getSingleton().logMessage(m_Log);

#if OGRE_PLATFORM != PLATFORM_WIN32 && OGRE_PLATFORM != OGRE_PLATFORM_WIN32

            std::cerr << m_Log;

#endif

            m_Log.clear();
        }
    }
};

#endif

现在，这工作正常，并且这个单例在 .cpp 中实例化：

#include "logger.h"

Logger* Logger::m_Instance = new Logger(); 

当我想在多个标头中使用单例时，问题就出现了。 我在 game3d.h 中实例化它，几乎所有标头都包含该文件，如下所示：

Logger awesomelogger = Logger::getInstance();

不幸的是，这会给出有关尝试重新声明 awesomelogger 的标头的多个错误。

我想让它成为一个常量，这将使它消失，但这会引入新的错误。 这就是我尝试过的：

friend Logger& operator << (const Logger& a_Logger, const std::string& a_Message)
{
    a_Logger.m_Log.append(a_Message);
    a_Logger._CheckNewLine();
    return *m_Instance;
}

我的问题是：如何使该类的实例成为常量，或者如何重写该类但仍然能够执行 awesomelogger << “输出”<< s_Stuff <<； “\n”；

Answer 1

与您的问题无关，但请注意，诸如 _LOGGER_H_ 和 __LogManager_H__ 之类的名称在 C++ 中是保留的 - 您不允许在自己的代码中使用它们。 如果您不理解有关名称开头下划线（或任何地方的双下划线）的规则，请不要使用它们。

现在，关于你的问题，记录器显然不是常量。 提供对单例的访问的经典方法是对此的一些变体：

static Logger* getInstance() { 
    static Logger logger;
    return & logger; 
}

Answer 2

您的 get_instance 方法返回 Logger* 而不是 Logger。

Answer 3

创建一个指向 const 对象的 const 指针。

static const Logger * const m_Instance;

而不是

static Logger* m_Instance;

你在课堂上也需要很多相应的更正。

Answer 4

一般来说，您的 Logger“m_Instance”实例应该是私有的。 并且您的函数“GetLogger()”应该检查“m_Instance”是否尚未实例化（如果没有实例化），然后返回m_Instance。

Answer 5

经典的辛格尔顿模式看起来像这样：

#ifndef  THORS_ANVIL_MY_LOGGER_H
#define  THORS_ANVIL_MY_LOGGER_H

class MyLogger
{
  private:
   // Private Constructor
    MyLogger();
   // Stop the compiler generating methods of copy the object
    MyLogger(MyLogger const& copy);           // Not Implemented.
    MyLogger& operator=(MyLogger const& copy); // Not Implemented

  public:
    static MyLogger& getInstance()
    {
        // The only instance
        // Guaranteed to be lazy initialized
        // Guaranteed that it will be destroyed correctly
        static MyLogger instance;
        return instance;
    }
    template<typename T>
    MyLogger& operator<<(T const& data)
    {
          // LOG
          return *this;
    }
};

// continued below.

现在我们已经有了基本的模式。 您需要看起来像全局变量的东西来访问它。 最简单的方法是作弊，不使用全局引用，而是使用本地引用。

因此，在头文件中以及 Logger 类定义中添加以下内容。

namespace
{
    MyLogger&   logger = MyLogger::getInstance();
}
#endif

这在包含标头的每个编译单元中声明了一个文件局部变量。
它已被初始化为引用单例记录器的实例。 因为您需要在使用之前包含该文件，所以它将始终在任何使用之前进行声明，从而保证以正确的顺序进行初始化。

在主文件中：

#include "MyLogger.h"
int main()
{
    logger << "Plop";
}

Answer 6

由此听来：

当我想在多个标头中使用单例时，问题就出现了。 我在 game3d.h 中实例化它，几乎所有标头都包含该文件，如下所示：

 Logger awesomelogger = Logger::getInstance();

您正在包含 game3d.h 的每个模块中创建一个 awesomelogger 的新实例，并且由于此声明具有外部链接时，这些名称将在链接时发生冲突。

请参阅名称与文件范围的链接了解C++ 链接规则的解释。

更好的解决方案是无需创建 awesomelogger 变量，只需在需要的地方直接调用 Logger::getInstance() 即可。