enum class的operator<<重载失效，编译报错寻求排查方案

我编写了以下C++代码，尝试为FGaugeLogger类内部的enum class LogLevel重载std::ostream的operator<<运算符，但编译时出现错误，提示无法找到匹配的‘operator<<’（操作数类型为std::basic_ostream<char>和FGaugeLogger::LogLevel）。我认为我的代码与相关参考示例一致，请问问题出在哪里？

代码文件 #

logging.hxx #

#include <iostream>
#include <string>
#include <sstream>

#include "singleton.hxx"
#include "utils.hxx"

class FGaugeLogger: public Singleton<FGaugeLogger> {
    public:
        enum class LogLevel: int {
            DEBUG = 0,
            INFO = 1,
            WARNING = 2,
            ERROR = 3,
            FATAL = 4,
        };
        
        FGaugeLogger() {};
        
        template<typename T>
        void log(LogLevel level, const T& msg) {
            if (level >= _level) {
                if (level >= LogLevel::WARNING) {
                    std::cerr << "[" << level << "] " << msg << std::endl;
                } else {
                    std::cout << "[" << level << "] " << msg << std::endl;
                }
            }
        }
    
    private:
        LogLevel _level {LogLevel::DEBUG};
};

std::ostream& operator<<(std::ostream& s, const FGaugeLogger::LogLevel level);

#define LOG(level, expr) \
    std::stringstream ss; \
    ss << expr; \
    std::string str = ss.str(); \
    FGaugeLogger::instance()->log(FGaugeLogger::LogLevel::level, ss.str());

logging.cxx #

#include "logging.hxx"

std::ostream& operator<<(std::ostream& s, FGaugeLogger::LogLevel level) {
    s << "level";
    return s;
}

main.cxx #

#include "logging.hxx"

int main(int argc, char* argv[]) {
    LOG("info message");
    return 0;
}

编译错误信息 #

In file included from /media/frederic/WD-5TB/.fg/Programme/fgauge/src/main.cxx:1:
/media/frederic/WD-5TB/.fg/Programme/fgauge/src/logging.hxx: In member function ‘void FGaugeLogger::log(FGaugeLogger::LogLevel, const T&)’:
/media/frederic/WD-5TB/.fg/Programme/fgauge/src/logging.hxx:27:58: error: no match for ‘operator<<’ (operand types are ‘std::basic_ostream<char>’ and ‘FGaugeLogger::LogLevel’)
   27 |                                         std::cerr << "[" << level << "] " << msg << std::endl;
      |                                         ~~~~~~~~~~~~~~~~ ^~ ~~~~~
      |                                                   |         |
      |                                                   |         FGaugeLogger::LogLevel
      |                                                   std::basic_ostream<char>

问题原因与解决方法 #

核心问题：模板函数的名称查找限制 #

你的log是模板成员函数，编译器在解析模板定义时（而非实例化时），就会尝试解析std::cerr << level这个表达式。但你把operator<<的声明放在了类定义的外部，此时模板定义的上下文里看不到这个重载，导致编译器找不到匹配的运算符。

另外LOG宏还有一个小问题：调用时传参不匹配（宏需要两个参数，但你只传了一个），不过这不是当前编译错误的直接原因。

解决步骤 #

1. 将运算符重载声明为类的友元
   把operator<<的声明移到FGaugeLogger类的public区域内，声明为友元，这样模板函数定义时就能直接看到这个重载：

   class FGaugeLogger: public Singleton<FGaugeLogger> {
       public:
           enum class LogLevel: int {
               DEBUG = 0,
               INFO = 1,
               WARNING = 2,
               ERROR = 3,
               FATAL = 4,
           };
           
           // 声明友元运算符重载
           friend std::ostream& operator<<(std::ostream& s, LogLevel level);
           
           FGaugeLogger() {};
           
           template<typename T>
           void log(LogLevel level, const T& msg) {
               // 原函数内容不变
           }
       
       private:
           LogLevel _level {LogLevel::DEBUG};
   };
   

   同时可以完善logging.cxx中的运算符实现，输出对应日志级别字符串：

   std::ostream& operator<<(std::ostream& s, FGaugeLogger::LogLevel level) {
       switch(level) {
           case FGaugeLogger::LogLevel::DEBUG: s << "DEBUG"; break;
           case FGaugeLogger::LogLevel::INFO: s << "INFO"; break;
           case FGaugeLogger::LogLevel::WARNING: s << "WARNING"; break;
           case FGaugeLogger::LogLevel::ERROR: s << "ERROR"; break;
           case FGaugeLogger::LogLevel::FATAL: s << "FATAL"; break;
           default: s << "UNKNOWN";
       }
       return s;
   }
   

2. 修复LOG宏的调用
   宏需要两个参数，调用时应写成LOG(INFO, "info message")，匹配宏定义的参数要求。

补充说明 #

模板函数遵循两阶段查找规则：第一阶段在模板定义时查找非依赖于模板参数的名称，第二阶段在实例化时查找依赖于模板参数的名称。level是固定的FGaugeLogger::LogLevel类型，不属于模板参数依赖类型，因此编译器在第一阶段就需要找到对应的operator<<，将其声明为类友元就能解决可见性问题。

内容的提问来源于stack exchange，提问作者TheEagle