Eigenen Logger mit Ableitbaren Klassen für Dateien und Konsole

Guten Abend liebe Leute im Forum,

Ich würde gerne ein Array (in welcher Form auch immer) haben,
dass einen Pointer auf einen Logger (selbstgeschrieben) hat.

Das ist ja noch kein Problem, aber ich würde dort gerne verschiedene
Logger speichern, die z.B. in eine Datei oder Konsole schreiben.

Nun zu meinen Problem:

Wie stelle ich das am besten an, dass ich eine Basisklasse habe,
die im Prinzip noch kein bestimmten Stream hat und sich Ableiten lässt.

In den Abgeleiteten Klassen würde ich einfach ein std::ostream und ein
std::fstream benutzen, nur kann ich da nicht Allgemeine Funktionen schreiben,
weil die Basisklasse ja keinen Stream hat ...

class Logger
{
    void Write(const std::string& text)
    {
        // hier hab ich ja noch keinen Stream
    }

    template<class T> Logger operator<<(T& t)
    {
        // return stream << t;
        // geht ja nicht, weil ich keinen Stream in Logger habe
    }
};

class ConsoleLogger : Logger
{
private:
    std::ostream& stream;
};

class FileLogger : Logger
{
private:
    std::ofstream stream;
}

std::vector<Logger*> logger;
logger.push_back(new Logger());
logger.push_back(new ConsoleLogger());
logger.push_back(new FileLogger());

Ich würde halt jetzt gerne in Logger alle Funktionen definieren
und für die Abgeleiteten nutzen.

Vielen Dank für's Durchlesen, ich hoffe es ist alles verständlich

Gruß
Simon

CStoll

Für solche Probleme wurden virtuelle (bzw pur virtuelle) Methoden erfunden - die Basisklasse liefert nur die abstrakten Methoden deklariert und die abgeleiteten Klassen liefern die konkrete Umsetzung.

Für dich könnte es sogar ausreichen, wenn du eine Methode ostream& getStream()=0; definierst und in den Logger-Methoden verwendest.