Нужно знать, как проверить, завершилась ли введенная строка в потокобезопасном регистраторе на С++.

Я не совсем уверен, что понимаю ситуацию, но похоже, что вам нужен прокси:

class LogSingleton
{
public:
    LogSingleton& instance() { /* ... */ }

    void lock(); // lock mutex
    void unlock(); // unlock mutex

    template <typename T>
    friend LogSingleton& operator<<(LogSingleton& pLog, const T& pX)
    {
        // needs to be locked first
        assert(is_locked()); 

        /* output pX however */

        return pLog;
    }
};

class LogProxy
{
public:
    LogProxy()
    {
        // manage lock in proxy
        LogSingleton::instance().lock();            
    }

    ~LogProxy()
    {
        LogSingleton::instance().unlock();            
    }
};

// forward input into the proxy to the log, knowing it's locked
template <typename T>
LogProxy& operator<<(LogProxy& pProxy, const T& pX)
{
    LogSingleton::instance() << pX;

    return pProxy;
}

// now expose proxy
typedef LogProxy log;

И вы бы сделали это:

log() << "its locked now" << "and the temporary will die" << "here ->";

Блокировка выполняется в конструкторе и деструкторе, а деструктор вызывается в конце.

Как правильно отмечает Тони, это излишне долго удерживает блокировку. Блокировка нужна только для "окончательного" вывода в LogSingleton. Представьте себе это:

log() << "this next function takes 5 minutes"
        << my_utterly_crappy_function() << "ouch";

Ничего не регистрируется, но мьютекс заблокирован в течение длительного времени. Лучше было бы буферизовать вывод, а затем выводить все сразу:

class LogProxy
{
public:
    ~LogProxy()
    {
        // manage lock in proxy
        LogSingleton::instance().lock();

        // no-throw, or wrap mutex use in a scoped-lock
        LogSingleton::instance() << mBuffer.rdbuf();

        LogSingleton::instance().unlock();            
    }

    // buffer output
    template <typename T>
    friend LogProxy& operator<<(LogProxy& pProxy, const T& pX)
    {
        mBuffer << pX;

        return pProxy;
    }

private:
    std::ostringstream mBuffer;
};

Теперь никакие блокировки не устанавливаются до тех пор, пока буфер не будет готов к выводу.

Как правило, блокировать мьютекс в одной функции и разблокировать в другой — плохая идея. Он должен быть заблокирован и разблокирован в одной и той же функции.

Я создал что-то подобное, и обычно я создал класс C++ с именем Error.

Таким образом, пользователь создает объект Error, и этот объект ошибки обрабатывает все элементы завершения. Затем объект ошибки отправляется в очередь ErrorLogger, и регистратор ошибок завершает работу, когда очередь ErrorLogger пуста. Тогда вам не придется беспокоиться о мьютексах, потому что ErrorLogger успевает обработать вне очереди.

Проверьте https://web.archive.org/web/1/http://articles.techrepublic%2ecom%2ecom/5100-10878_11-5072104.html

Идея состоит в том, чтобы создать локальные для потока «прокси», которые будут вызывать фактическую функцию ведения журнала, безопасную для потоков.