Как перегрузить оператор <<, который не принимает или не возвращает ostream

Question

Оригинальный вопрос

Я пишу класс журналирования, цель которого состоит в том, чтобы сделать это:

// thread one
Logger() << "Some string" << std::ios::hex << 45;
// thread two
Logger() << L"Some wide string" << std::endl;

В настоящее время мой заголовок Logger выглядит примерно так:

#pragma once;
#include <ostream>    
class Logger
{
public:
    Logger();
    ~Logger();

    std::ostream* out_stream;
};

template <typename T>
Logger& operator<< (Logger& logger, T thing) {
    *logger.out_stream << thing;
    return logger;
}

Некоторые заметки об этом классе:

1. Межплатформенная совместимость не является проблемой.
2. Внутри Logger.cpp есть одноэлементный класс, который заботится о создании "настоящего" ostream.
3. Конструктор и деконструктор Logger выполняют необходимую блокировку синглтона.

У меня три проблемы:

• Как мне заставить оператора << функционировать как друга или участника, чтобы я мог установить out_stream как личное? </li>
• Как мне заставить оператор << работать на манипуляторах? </li>
• Как я могу добавить специализацию, чтобы, если T был WCHAR * или std :: wstring, он преобразовывал его в char * или std :: string перед передачей его в out_stream? (Я могу сделать преобразование. В моем случае потеря символов с высоким юникодом не проблема.)

Краткое изложение полученных знаний в ответах:

• Поставь шаблон ДО друга, а не после.
• std :: ios :: hex не является манипулятором. std :: hex - манипулятор.

Конечный результат

#pragma once
#include <ostream>
#include <string>

std::string ConvertWstringToString(std::wstring wstr);

class Logger
{
public:
    Logger();
    ~Logger();

    template <typename T>
    Logger& operator<< (T data) {
        *out << data;
        return *this;
    }
    Logger& operator<< (std::wstring data) {
        return *this << ConvertWstringToString(data);
    }
    Logger& operator<< (const wchar_t* data) {
        std::wstring str(data);
        return *this << str;
    }

private:
    std::ostream* out;
};

Answer 1

Вы можете использовать определение друга, которое определит оператор в окружающем пространстве имен класса и сделает его видимым только для разрешения перегрузки операторов (не может быть вызвано вручную с помощью синтаксиса :: operator << ...): </p>

class Logger
{
public:
    Logger();
    ~Logger();

    std::ostream* out_stream;

    template <typename T>
    friend Logger& operator<< (Logger& logger, T thing) {
        *logger.out_stream << thing;
        return logger;
    }

    /* special treatment for std::wstring. just overload the operator! No need
     * to specialize it. */
    friend Logger& operator<< (Logger& logger, const std::wstring & wstr) {
        /* do something here */
    }

};

В качестве альтернативы, чтобы сохранить свой код как есть и просто сделать оператор << шаблон другом, вы добавляете эту строку в определение класса: </p>

template <typename T>
friend Logger& operator<< (Logger& logger, T thing);

Что касается задачи с манипулятором, я просто дам вам свой код, который я написал некоторое время назад:

#include <iostream>
#include <cstdlib>
using namespace std;

template<typename Char, typename Traits = char_traits<Char> >
struct logger{
    typedef std::basic_ostream<Char, Traits> ostream_type;
    typedef ostream_type& (*manip_type)(ostream_type&);
    logger(ostream_type& os):os(os){}
    logger &operator<<(manip_type pfn) {
        if(pfn == static_cast<manip_type>(std::endl)) {
            time_t t = time(0);
            os << " --- " << ctime(&t) << pfn; 
        } else
            os << pfn;
        return *this; 
    }
    template<typename T> 
    logger &operator<<(T const& t) { 
        os << t; 
        return *this;
    }
private:        
    ostream_type & os;
};

namespace { logger<char> clogged(cout); }
int main() { clogged << "something with log functionality" << std::endl; }

};

Обратите внимание, что это std :: hex, но не std :: ios :: hex . Последний используется в качестве флага-манипулятора для функции setf потоков. Обратите внимание, что для вашего примера, специальная обработка манипуляторов не требуется. Вышеуказанная специальная обработка std :: endl необходима только потому, что я добавляю потоковое время, когда используется std :: endl.

Answer 2

Объявление о дружбе не требуется:

class Logger
{
public:
    Logger();
    ~Logger();

template <typename T>
inline Logger& Display(T thing)
{
   *out_stream << thing;
    return *this;
}
private:
    std::ostream* out_stream;
};

template <typename T>
Logger& operator<< (Logger& logger, T thing) 
{
    return logger.Display(thing);
}

Answer 3

Использование шаблона - это верный способ сделать это, но вам просто нужно убедиться, что шаблон находится в файле header (logger.h или как вы его назвали), not в файле реализации (logger.cpp). Это будет автоматически работать для любого типа, для которого operator << определено с std::ostream. Он также будет автоматически работать с объектами потокового манипулятора - это действительно просто функции, которые принимают параметр std::ostream, а operator << просто вызывает функцию на ostream.

Вы можете сделать operator << функцией друга следующим образом:

template <typename T> friend Logger& operator<< (Logger& logger, T thing);

Специализации просты - просто используйте шаблонные специализации (опять же, в заголовочном файле):

template <typename T>
Logger& operator<< (Logger& logger, T thing) {
    *logger.out_stream << thing;
    return logger;
}

// Template specialization - the "template <>" part is necessary
template <>
Logger& operator<< (Logger& logger, const wchar_t *wstr)
{
  // convert wstr to an ANSI string and log it
}

template <>
Logger& operator<< (Logger& logger, const std::wstring & wstr)
{
  // convert wstr to an ANSI string and log it
}

Answer 4

почему бы не сделать это способом printf и использовать многопараметрический метод (с тремя точками ...). Это по-прежнему дает вам большую силу форматирования и не делает его таким беспорядочным, как при использовании <<. </p>

Например:

Logger("This is my log msg %0X", 45);

Подожди на две секунды, и я подожду тебе пример кода.

Edit:

void Logger(const char* format, ...)
{
    char szMsg[3000];

    va_list args;
    va_start( args, format );
    vsnprintf( szMsg, sizeof(szMsg) - 1, format, args );
    va_end(args);

    // code to print szMsg to a file or whatever here
}

Если вы хотите использовать это как класс, а не как отдельную функцию, вы можете перегрузить оператор логгера (), и он будет работать точно так же