printf in C++?



  • Gibt es in C++ eine Pendant zu printf in C? Diese Streams mit cout << etc finde ich ziemlich hässlich und unelegant im Vergleich zu printf.



  • http://www.cplusplus.com/reference/cstdio/printf/

    Das bietet aber keine Typsicherheit. Du als Programmierer bist für die Einghaltung der Richtigkeit der Paramter zuständig.



  • printf
    Wenn du nach "typesafe printf" suchst, findest du sicher auch Implementierungen mit variadic templates, die auf dem C++11 Standard beruhen.



  • Cpppppppp schrieb:

    Diese Streams mit cout << etc finde ich ziemlich hässlich und unelegant im Vergleich zu printf.

    Dieser Eindruck resultiert IMHO aus der schieren Unkenntnis von den Möglichkeiten von std::ostream & Co. 😉



  • Ich meine schon ein sichereres Printf, so wie in Java oder so.

    Werner Salomon schrieb:

    Cpppppppp schrieb:

    Diese Streams mit cout << etc finde ich ziemlich hässlich und unelegant im Vergleich zu printf.

    Dieser Eindruck resultiert IMHO aus der schieren Unkenntnis von den Möglichkeiten von std::ostream & Co. 😉

    Da diese "tollen" Streams in der Form von keiner Programmiersprache für die Ausgabe auf dem Bildschirm kopiert worden sind, gehe ich mal stark davon aus, dass diese Konzept nicht geraden zu den komfortabelsten gehört. Was ich an Formatstrings z.b. toll finde, ist dass ich ganz einfach die ganzen Texte in andere Sprachen übersetzen kann. Ich brauchen nicht für jede Variable gleich die Zeichenkette verlassen, sonder habe alles sehr übersichtlich und strukturiert. Für Dateien mögen diese Streams ok sein, für die Ausgabe eines Textes finde ich sie wirklich schrecklich umständlich.

    Also, gibt es nun ein sicheres Printf für C++ oder nicht?


  • Mod

    Cpppppp schrieb:

    Also, gibt es nun ein sicheres Printf für C++ oder nicht?

    Wie manni66 schon gesagt hat, kann man sich mit variadischen Templates da selber was basteln (sollte nicht zu schwer sein) oder eben nach einer fertigen Implememtierung suchen, falls sich jemand mal die Mühe gemacht haben sollte, so etwas zu veröffentlichen.



  • Cpppppp schrieb:

    Also, gibt es nun ein sicheres Printf für C++ oder nicht?

    .. gibt's alles: http://www.boost.org/doc/libs/1_57_0/libs/format/



  • Cpppppp schrieb:

    Was ich an Formatstrings z.b. toll finde, ist dass ich ganz einfach die ganzen Texte in andere Sprachen übersetzen kann.

    Das kommt dir nur so vor 😉

    https://www.youtube.com/watch?v=0j74jcxSunY



  • Werner Salomon schrieb:

    Cpppppp schrieb:

    Also, gibt es nun ein sicheres Printf für C++ oder nicht?

    .. gibt's alles: http://www.boost.org/doc/libs/1_57_0/libs/format/

    Danke, das ist doch schon mal eine Lösung, wenn auch keine schöne Lösung, aber was an C++ ist schon schön? 😃

    @dot:
    Ja, da ist was wahres dran. Ich sehe den Channel auch immer gerne. 👍



  • Cpppppp schrieb:

    Danke, das ist doch schon mal eine Lösung, wenn auch keine schöne Lösung, aber was an C++ ist schon schön? 😃

    Das hier zum Beispiel.



  • Skym0sh0 schrieb:

    Cpppppp schrieb:

    Danke, das ist doch schon mal eine Lösung, wenn auch keine schöne Lösung, aber was an C++ ist schon schön? 😃

    Das hier zum Beispiel.

    Collections mit Algos gibt es auch in anderen Sprachen und/oder Libs. In C++ ist irgendwie fast alles ein Krampf. C++ ist so schön, dass 18 von 20 Fachbuchautoren es nicht schaffen ein gutes Buch über die Sprache zu schreiben. Man schaue sich auch hier die Fragen in C++ Teil an, da macht doch kaum jemand was richtig in C++. Fast überall gibt es was auszusetzen oder es wird eine der 55 more effective Regeln gebrochen. Dann gab es ein Thema mit Smartpointer, was auch so niemand richtig wusste wie die nun korrekt konvertiert werden usw. Das ist alles typisch C++, ein riesen Konstrukt wo immer mehr Ventile und Leitungen ran geflanscht werden.

    Ich muss derzeit leider C++ lernen und habe schon einige Sprachen durch, aber schön ist anders.



  • Cpppppp schrieb:

    Da diese "tollen" Streams in der Form von keiner Programmiersprache für die Ausgabe auf dem Bildschirm kopiert worden sind ...

    Wenn keine andere Programmiersprache das Stream-Konzept für die Ausgabe kopiert haben soll, dann frage ich mich, wieso System.out in Java in PrintStream ist 😉
    Ich wage zu behaupten, dass dein Mißmut lediglich daher rührt, dass im Unterschied zu Java die Funktion print(...) in C++ operator<<(...) heisst 😃

    Finnegan



  • Also ich kenne auch manche, die diese ">>" und "<<" Operatoren sinnlos finden etc., aber persönlich finde ich die C++ streams echt gut und hatte noch nie Probleme damit.

    Und wie einfach es ist die Ein- und Ausgabeoperatoren für beliebige User-Defined-Types zu überladen. Herrlich.

    Und zu guter letzt will ich sagen: Keine Programmiersprache ist perfekt. So ist das nunmal. Essenziell für C++ ist auf jeden Fall ein gutes Buch.



  • Finnegan schrieb:

    Cpppppp schrieb:

    Da diese "tollen" Streams in der Form von keiner Programmiersprache für die Ausgabe auf dem Bildschirm kopiert worden sind ...

    Wenn keine andere Programmiersprache das Stream-Konzept für die Ausgabe kopiert haben soll, dann frage ich mich, wieso System.out in Java in PrintStream ist 😉
    Ich wage zu behaupten, dass dein Mißmut lediglich daher rührt, dass im Unterschied zu Java die Funktion print(...) in C++ operator<<(...) heisst 😃

    Finnegan

    Lustigerweise find ich die Java-Streams total mies.
    Aus C++ bin ichs gewohnt, dass ich eine EBNF quasi so eins zu eins mit den Streams runterschreiben kann und in Java brech ich mir immer wieder einen aufs neue damit ab.



  • Die Iostreams sind so ziemlich das Letzte. Ich hab mir für mein aktuelles Projekt ein eigenes printf gebaut, das boost.format wrapped.

    namespace detail
    {
    	template <typename Init, typename F>
    	auto foldl(Init&& init, F const&)
    	{
    		return std::forward<Init>(init);
    	}
    
    	template <typename Init, typename F, typename Head, typename... Tail>
    	auto foldl(Init&& init, F const& f, Head&& head, Tail&&... tail)
    	{
    		return foldl(f(std::forward<Init>(init), std::forward<Head>(head)), f, std::forward<Tail>(tail)...);
    	}
    }
    
    template <typename Init, typename BinFn, typename... Args>
    auto foldl(Init&& init, BinFn const& fn, Args&&... args)
    {
    	return detail::foldl(std::forward<Init>(init), fn, std::forward<Args>(args)...);
    }
    
    #define INFIX_OP_FN(_op) \
    	([](auto&& _lhs, auto&& _rhs) -> decltype(auto) \
    	{ \
    		return std::forward<decltype(_lhs)>(_lhs) _op std::forward<decltype(_rhs)>(_rhs); \
    	})
    
    template <typename... Args>
    std::string format(std::string const& fmt, Args const&... args)
    {
    	return foldl(boost::format(fmt), INFIX_OP_FN(%), args...).str();
    }
    

    Viel besser.



  • was ist denn so schlimm an den iostreams?



  • Kellerautomat schrieb:

    Die Iostreams sind so ziemlich das Letzte. Ich hab mir für mein aktuelles Projekt ein eigenes printf gebaut, das boost.format wrapped.

    namespace detail
    {
    	template <typename Init, typename F>
    	auto foldl(Init&& init, F const&)
    	{
    		return std::forward<Init>(init);
    	}
    
    	template <typename Init, typename F, typename Head, typename... Tail>
    	auto foldl(Init&& init, F const& f, Head&& head, Tail&&... tail)
    	{
    		return foldl(f(std::forward<Init>(init), std::forward<Head>(head)), f, std::forward<Tail>(tail)...);
    	}
    }
    
    template <typename Init, typename BinFn, typename... Args>
    auto foldl(Init&& init, BinFn const& fn, Args&&... args)
    {
    	return detail::foldl(std::forward<Init>(init), fn, std::forward<Args>(args)...);
    }
    
    #define INFIX_OP_FN(_op) \
    	([](auto&& _lhs, auto&& _rhs) -> decltype(auto) \
    	{ \
    		return std::forward<decltype(_lhs)>(_lhs) _op std::forward<decltype(_rhs)>(_rhs); \
    	})
    
    template <typename... Args>
    std::string format(std::string const& fmt, Args const&... args)
    {
    	return foldl(boost::format(fmt), INFIX_OP_FN(%), args...).str();
    }
    

    Viel besser.

    Das sieht aus wie ein Teil aus der Matrix. Entweder kann man die Matrix lesen oder nicht 😃
    P.S.: Ich finde die Ausgabestreams auch beschissen und dann noch das Verbiegen mit friend Methoden um eigene Typen darüber auszugeben, einfach schrecklich.


  • Mod

    Da warte ich lieber bis C++1Z und schreibe

    template <typename... Args>
    std::string format(std::string const& fmt, Args const&... args)
    {
        return (boost::format(fmt) %...% args).c_str();
    }
    

    (Evt. kann man das bereits mit dem Clang SVN trunk kompilieren)



  • friend hat mit den streams erstmal nix zu tun. Das hat mit Zugriff auf private Member einer Klasse für außenstehende Funktionen zu tun.


Log in to reply