Da ich die komplette syslog-Nachricht auf einmal schreiben muss, dachte ich, dass ich meine Klasse von std::ostringstream ableiten könnte, so dass die Klasse alle Ausgabe puffert und ich im Destruktor dann mit str() auslese was geschrieben wurde und das an den syslogd schicke. Dabei habe ich ein Problem, dass wenn als erstes ein String auf diese Klasse geschrieben wird, dass ich dann statt dem Text nur die Adresse an der der String steht geschrieben wird.

Ich habe meine Klasse mal auf das wesentliche reduziert:

class logmessage : public std::ostringstream {
    public:
        ~logmessage() {
            std::clog << "Would write to syslog: " << str() << std::endl;
        };

        static logmessage factory() {
            return logmessage();
        };

    private:
        logmessage() {
        };

        logmessage(const logmessage &source) {
        };
};

int main() {
    logmessage::factory() << "Testmessage #" << 1 << " would be this";
}

Statt der erwarteten Ausgabe "Would write to syslog: Testmessage #1 would be this" bekomme ich ein "Would write to syslog: 0x80493a01 would be this".

Wenn das erste was ausgegeben wird kein String (char*) ist, sondern z.B. ein int, dann funktioniert die Ausgabe wie ich sie haben möchte. Ich verstehe nicht, wieso es mit einem String nicht funktioniert.

static logmessage factory() {
            return logmessage();
        };

nicht kompilierbar sein.

logmessage::factory() ist ein rvalue. der operator << für strings ist aber als freie funktion implementiert (und hat folglich eine referenz als linken parameter). dieser kann daher in diesem falle nicht verwendet werden. der operator<<, der ein void* nimmt, ist dagegen eine nichtstatische memberfunktion, und wird angewendet.

Okay, das ist ein Ansatz. Dann versuche ich mal, ob ich mit einen operator<< als member meiner logmessage-Klasse implementieren kann.

camper schrieb:

allerdings sind streams ohnehin nicht kopierbar, insofern sollte bereits

static logmessage factory() {
            return logmessage();
        };

nicht kompilierbar sein.

Deswegen habe ich mir ja einen eigenen Copyconstruktor eingefügt. In meiner Logging-Klasse übernehme ich da einfach den Logging-Level von der alten Instanz und akzeptiere, dass der ostringstream darunter einfach eine neue Instanz ist ohne Übernahme der Daten.

Du solltest nicht vom stream erben, sondern diesen Kapseln.

Dann müsste ich für jeden Typen, den ich in einer Logmessage ausgeben will ja einen eigenen operator<< selbst definieren. Genau das will ich ja aber erben, dass die Ausgabe wir auf Standardstreams automatisch funktioniert.

camper schrieb:

logmessage::factory() ist ein rvalue. der operator << für strings ist aber als freie funktion implementiert (und hat folglich eine referenz als linken parameter). dieser kann daher in diesem falle nicht verwendet werden. der operator<<, der ein void* nimmt, ist dagegen eine nichtstatische memberfunktion, und wird angewendet.

Okay, das ist ein Ansatz. Dann versuche ich mal, ob ich mit einen operator<< als member meiner logmessage-Klasse implementieren kann.

Ich habe jetzt die folgende Methode meiner Klasse hinzugefügt und nun funktioniert ist:

std::ostream &operator<<(const char *text) {
            if (text == NULL)
                return *this;
            for (const char *ptr = text; *ptr != 0; ptr++)
                put(*ptr);
            return *this;
        }

Danke für die Hilfe!

Deswegen habe ich mir ja einen eigenen Copyconstruktor eingefügt.

habe ich übersehen.

mawis schrieb:

Ich habe jetzt die folgende Methode meiner Klasse hinzugefügt und nun funktioniert ist:

std::ostream &operator<<(const char *text) {
            if (text == NULL)
                return *this;
            for (const char *ptr = text; *ptr != 0; ptr++)
                put(*ptr);
            return *this;
        }

warum nicht durch den schon vorhandenen operator implementieren?

std::ostream &operator<<(const char *text) {
            return static_cast<std::ostream&>(*this) << text;
        }

warum nicht durch den schon vorhandenen operator implementieren?

std::ostream &operator<<(const char *text) {
            return static_cast<std::ostream&>(*this) << text;
        }

Ist natürlich schöner. Danke für den Tipp!