operator über Zeiger aufrufen

Hallo!
Ich hab da ein kleines Problemchen.
Ich will eine Klasse schreiben, die bei Bedarf ein Logbuch führt.
Die Klasse des Logbuches ist schon fertig und funtioniert ohne Probleme.
Jetzt mein Problem: Wie soll ich das anstellen, dass nur bei Bedarf ein Logbuch geführt wird?

Ich hatte da schon so einen Plan:

class CKlasse
{
private:
    CLog *m_pLog; //Pointer auf Klasse das Logbuches
    BOOL m_bUseLog; //Logbich führen?
public:
    ~CKlasse() { delete m_pLog; }
    CKlasse(BOOL bUseLog)
    {
        if(bUseLog)
            m_pLog=new CLog("Logbuch.txt");
        else
            m_pLog=NULL;
        m_bUseLog=bUseLog;
    }
};

Das würde klappen, bloß: Wie benutzt ich dann überladene Operatoren des Logbuches, wie z.B. operator<<? Bei Funktionen: ->Funktion(...);, bei Operatoren vieleicht ->operator<<...;
Wenn ich statt einem Pointer eine Referenz benutze, wie kann ich dann im Konstruktor ein Objekt anlegen, was nicht gelöscht wird sobald der Konstruktor endet?

CStoll

Du kannst den Zeiger jederzeit dereferenzieren, wenn du seine Member nutzen willst: [c]*m_pLog<<"Log-Ausgabe";/c]

bwbg

Meiner Meinung nach ist das Verwenden von Zeigern hier überflüssig. Das ginge auch mit Referenzen.

Mein Vorschlag:

#include <iostream>
using namespace std;

class Foo
{
private:
    ostream& out;
    bool log;

public:
    Foo()
        : out(std::clog), log(false)
        { }

    Foo(ostream& out, bool log)
        : out(out), log(log)
        { }

    void doSomething()
        {
            // ... do something
            if(log) out << "I've done something" << endl;
        }
};

int main(int argc, char** args)
    {
        Foo foo;
        Foo bar(cout, true);

        foo.doSomething();  // doesn't log
        bar.doSomething();  // does log

        cin.get();
        return 0;
    }

OT: Ich bin immer noch der Meinung dass diese m_-Präfixe den Code "unlesbarer" gestalten.

Grüße...

Heiko