12

我如何从中派生一个类cout，例如，写入它

new_cout << "message";

相当于

cout << __FUNCTION__ << "message" << "end of message" << endl;

4

6 回答 6

36 
class Log
{
public:
    Log(const std::string &funcName)
    {
        std::cout << funcName << ": ";
    }

    template <class T>
    Log &operator<<(const T &v)
    {
        std::cout << v;
        return *this;
    }

    ~Log()
    {
        std::cout << " [end of message]" << std::endl;
    }
};

#define MAGIC_LOG Log(__FUNCTION__)

因此：

MAGIC_LOG << "here's a message";
MAGIC_LOG << "here's one with a number: " << 5;
于 2009-03-23T16:34:05.103 回答
2 
#define debug_print(message) (std::cout << __FUNCTION__ << (message) << std::endl)

这样做的好处是您可以在完成后立即禁用所有调试消息

#define debug_print(message) ()
于 2009-03-23T16:35:45.253 回答
1

进一步从 Mykola 的响应来看，我的代码中有以下实现。用法是

         LOG_DEBUG("print 3 " << 3);

印刷

         DEBUG (f.cpp, 101): print 3 3

您可以修改它以使用FUNCTION沿/代替LINE和FILE

/// Implements a simple logging facility. 
class Logger
{
        std::ostringstream os_;
        static Logger* instance_;
        Logger();
public:
        static Logger* getLogger();
        bool isDebugEnabled() const;
        void log(LogLevelEnum l, std::ostringstream& os, const char* filename, int lineno) const;
        std::ostringstream& getStream()
        { return os_; }
};

void Logger::log(LogLevelEnum l, std::ostringstream& os, const char* filename, int lineno) const
{
        std::cout << logLevelEnumToString(l) << "\t(" << fileName << ": " << lineno << ")\t- " << os.str();
        os.str("");
}

#define LOG_common(level, cptext) do {\
        utility::Logger::getLogger()->getStream() << cptext; \
        utility::Logger::getLogger()->log(utility::level, utility::Logger::getLogger()->getStream(), __FILE__, __LINE__);  \
} while(0); 

enum LogLevelEnum {
        DEBUG_LOG_LEVEL,
        INFO_LOG_LEVEL,
        WARN_LOG_LEVEL,
        ERROR_LOG_LEVEL,
        NOTICE_LOG_LEVEL,
        FATAL_LOG_LEVEL
};

#define LOG_DEBUG(cptext)    LOG_common(DEBUG_LOG_LEVEL, cptext)
#define LOG_INFO(cptext)     LOG_common(INFO_LOG_LEVEL , cptext)
#define LOG_WARN(cptext)     LOG_common(WARN_LOG_LEVEL , cptext)
#define LOG_ERROR(cptext)    LOG_common(ERROR_LOG_LEVEL, cptext)
#define LOG_NOTICE(cptext)   LOG_common(NOTICE_LOG_LEVEL, cptext)
#define LOG_FATAL(cptext)    LOG_common(FATAL_LOG_LEVEL, cptext)

const char* logLevelEnumToString(LogLevelEnum m)
{
        switch(m)
        {
                case DEBUG_LOG_LEVEL:
                        return "DEBUG";
                case INFO_LOG_LEVEL:
                        return "INFO";
                case WARN_LOG_LEVEL:
                        return "WARN";
                case NOTICE_LOG_LEVEL:
                        return "NOTICE";
                case ERROR_LOG_LEVEL:
                        return "ERROR";
                case FATAL_LOG_LEVEL:
                        return "FATAL";
                default:
                        CP_MSG_ASSERT(false, CP_TEXT("invalid value of LogLevelEnum"));
                        return 0;
        }
}
于 2009-03-23T16:35:42.057 回答
1

出于记录目的，我使用类似的东西

#define LOG(x) \
  cout << __FUNCTION__ << x << endl

// ...
LOG("My message with number " << number << " and some more");

您的方法的问题是（正如 Mykola Golybyew 解释的那样）FUNCTION在编译时处理，因此总是使用非预处理器解决方案打印相同的名称。

如果仅用于将 endl 添加到您的消息中，您可以尝试以下操作：

class MyLine {
public:
  bool written;
  std::ostream& stream;
  MyLine(const MyLine& _line) : stream(_line.stream), written(false) { }
  MyLine(std::ostream& _stream) : stream(_stream), written(false) { }
  ~MyLine() { if (!written) stream << "End of Message" << std::endl; }
};

template <class T> MyLine operator<<(MyLine& line, const T& _val) {
  line.stream << _val;
  line.written = true;
  return line;
}

class MyStream {
public:
  std::ostream& parentStream;
  MyStream(std::ostream& _parentStream) : parentStream(_parentStream) { }
  MyLine getLine() { return MyLine(parentStream); }
};

template <class T> MyLine operator<<(MyStream& stream, const T& _val) {
  return (stream.getLine() << _val);
}

int main()
{
      MyStream stream(std::cout);
      stream << "Hello " << 13 << " some more data";
      stream << "This is in the next line " << " 1 ";
    return 0;
}

请注意，重要的是不要从运算符函数返回引用。由于MyLine应该仅作为临时对象存在（因为它的析构函数触发了 的写入endl），所以第一个对象（由getLine()in 中的函数返回MyStream）将在operator<<调用第二个对象之前被破坏。因此，该MyLine对象在每次operator<<创建一个新对象时都会被复制。最后一个对象在没有被写入的情况下被破坏，并将消息的结尾写入其析构函数中。

只需在调试器中尝试一下即可了解发生了什么...

于 2009-03-23T17:00:33.540 回答
0

你必须重写 operator<<()，但你甚至不必继承 std::cout。您也可以创建一个新对象或使用类似的现有对象。

于 2009-03-23T16:28:33.493 回答
-1

您还可以覆盖 operator。它将允许您调用另一个函数或前缀/后缀任何将离开输出缓冲区的任何内容：在您的情况下，您将让它输出一个特定的字符串。

于 2009-03-23T16:27:26.770 回答