Pretty-Print-C ++ - STL-Container

389

Bitte beachten Sie die Updates am Ende dieses Beitrags.

Update: Ich habe ein öffentliches Projekt auf GitHub für diese Bibliothek erstellt!


Ich hätte gerne eine einzige Vorlage, die ein für alle Mal dafür sorgt, dass alle STL-Container über hübsch gedruckt werden operator<<. Im Pseudocode suche ich so etwas:

template<container C, class T, String delim = ", ", String open = "[", String close = "]">
std::ostream & operator<<(std::ostream & o, const C<T> & x)
{
    o << open;
    // for (typename C::const_iterator i = x.begin(); i != x.end(); i++) /* Old-school */
    for (auto i = x.begin(); i != x.end(); i++)
    {
        if (i != x.begin()) o << delim;
        o << *i;
    }
    o << close;
    return o;
}

Jetzt habe ich hier auf SO viel Template-Magie gesehen, die ich nie für möglich gehalten hätte, und ich frage mich, ob jemand etwas vorschlagen kann, das zu allen Containern C passt. Vielleicht etwas, das herausfinden kann, ob etwas den erforderlichen Iterator hat ?

Danke vielmals!


Update (und Lösung)

Nachdem ich dieses Problem auf Kanal 9 erneut angesprochen hatte, erhielt ich eine fantastische Antwort von Sven Groot, die zusammen mit ein wenig SFINAE-Typ-Traiting das Problem auf eine völlig allgemeine und verschachtelbare Weise zu lösen scheint. Die Trennzeichen können individuell spezialisiert sein, eine Beispielspezialisierung für std :: set ist enthalten sowie ein Beispiel für die Verwendung benutzerdefinierter Trennzeichen.

Mit dem Helfer "wrap_array ()" können rohe C-Arrays gedruckt werden. Update: Paare und Tupel stehen zum Drucken zur Verfügung. Standardtrennzeichen sind runde Klammern.

Das Merkmal enable-if erfordert C ++ 0x, aber mit einigen Änderungen sollte es möglich sein, eine C ++ 98-Version davon zu erstellen. Tupel erfordern verschiedene Vorlagen, daher C ++ 0x.

Ich habe Sven gebeten, die Lösung hier zu veröffentlichen, damit ich sie akzeptieren kann, aber in der Zwischenzeit möchte ich den Code selbst als Referenz veröffentlichen. ( Update: Sven hat jetzt seinen Code unten veröffentlicht, auf den ich die akzeptierte Antwort gegeben habe. Mein eigener Code verwendet Containertypmerkmale, die für mich funktionieren, aber bei Nicht-Container-Klassen, die Iteratoren bereitstellen, unerwartetes Verhalten verursachen können.)

Header (prettyprint.h):

#ifndef H_PRETTY_PRINT
#define H_PRETTY_PRINT


#include <type_traits>
#include <iostream>
#include <utility>
#include <tuple>


namespace std
{
    // Pre-declarations of container types so we don't actually have to include the relevant headers if not needed, speeding up compilation time.
    template<typename T, typename TTraits, typename TAllocator> class set;
}

namespace pretty_print
{

    // SFINAE type trait to detect a container based on whether T::const_iterator exists.
    // (Improvement idea: check also if begin()/end() exist.)

    template<typename T>
    struct is_container_helper
    {
    private:
        template<typename C> static char test(typename C::const_iterator*);
        template<typename C> static int  test(...);
    public:
        static const bool value = sizeof(test<T>(0)) == sizeof(char);
    };


    // Basic is_container template; specialize to derive from std::true_type for all desired container types

    template<typename T> struct is_container : public ::std::integral_constant<bool, is_container_helper<T>::value> { };


    // Holds the delimiter values for a specific character type

    template<typename TChar>
    struct delimiters_values
    {
        typedef TChar char_type;
        const TChar * prefix;
        const TChar * delimiter;
        const TChar * postfix;
    };


    // Defines the delimiter values for a specific container and character type

    template<typename T, typename TChar>
    struct delimiters
    {
        typedef delimiters_values<TChar> type;
        static const type values; 
    };


    // Default delimiters

    template<typename T> struct delimiters<T, char> { static const delimiters_values<char> values; };
    template<typename T> const delimiters_values<char> delimiters<T, char>::values = { "[", ", ", "]" };
    template<typename T> struct delimiters<T, wchar_t> { static const delimiters_values<wchar_t> values; };
    template<typename T> const delimiters_values<wchar_t> delimiters<T, wchar_t>::values = { L"[", L", ", L"]" };


    // Delimiters for set

    template<typename T, typename TTraits, typename TAllocator> struct delimiters< ::std::set<T, TTraits, TAllocator>, char> { static const delimiters_values<char> values; };
    template<typename T, typename TTraits, typename TAllocator> const delimiters_values<char> delimiters< ::std::set<T, TTraits, TAllocator>, char>::values = { "{", ", ", "}" };
    template<typename T, typename TTraits, typename TAllocator> struct delimiters< ::std::set<T, TTraits, TAllocator>, wchar_t> { static const delimiters_values<wchar_t> values; };
    template<typename T, typename TTraits, typename TAllocator> const delimiters_values<wchar_t> delimiters< ::std::set<T, TTraits, TAllocator>, wchar_t>::values = { L"{", L", ", L"}" };


    // Delimiters for pair (reused for tuple, see below)

    template<typename T1, typename T2> struct delimiters< ::std::pair<T1, T2>, char> { static const delimiters_values<char> values; };
    template<typename T1, typename T2> const delimiters_values<char> delimiters< ::std::pair<T1, T2>, char>::values = { "(", ", ", ")" };
    template<typename T1, typename T2> struct delimiters< ::std::pair<T1, T2>, wchar_t> { static const delimiters_values<wchar_t> values; };
    template<typename T1, typename T2> const delimiters_values<wchar_t> delimiters< ::std::pair<T1, T2>, wchar_t>::values = { L"(", L", ", L")" };


    // Functor to print containers. You can use this directly if you want to specificy a non-default delimiters type.

    template<typename T, typename TChar = char, typename TCharTraits = ::std::char_traits<TChar>, typename TDelimiters = delimiters<T, TChar>>
    struct print_container_helper
    {
        typedef TChar char_type;
        typedef TDelimiters delimiters_type;
        typedef std::basic_ostream<TChar, TCharTraits> & ostream_type;

        print_container_helper(const T & container)
        : _container(container)
        {
        }

        inline void operator()(ostream_type & stream) const
        {
            if (delimiters_type::values.prefix != NULL)
                stream << delimiters_type::values.prefix;

            for (typename T::const_iterator beg = _container.begin(), end = _container.end(), it = beg; it != end; ++it)
            {
                if (it != beg && delimiters_type::values.delimiter != NULL)
                    stream << delimiters_type::values.delimiter;

                stream << *it;
            }

            if (delimiters_type::values.postfix != NULL)
                stream << delimiters_type::values.postfix;
        }

    private:
        const T & _container;
    };


    // Type-erasing helper class for easy use of custom delimiters.
    // Requires TCharTraits = std::char_traits<TChar> and TChar = char or wchar_t, and MyDelims needs to be defined for TChar.
    // Usage: "cout << pretty_print::custom_delims<MyDelims>(x)".

    struct custom_delims_base
    {
        virtual ~custom_delims_base() { }
        virtual ::std::ostream & stream(::std::ostream &) = 0;
        virtual ::std::wostream & stream(::std::wostream &) = 0;
    };

    template <typename T, typename Delims>
    struct custom_delims_wrapper : public custom_delims_base
    {
        custom_delims_wrapper(const T & t) : t(t) { }

        ::std::ostream & stream(::std::ostream & stream)
        {
          return stream << ::pretty_print::print_container_helper<T, char, ::std::char_traits<char>, Delims>(t);
        }
        ::std::wostream & stream(::std::wostream & stream)
        {
          return stream << ::pretty_print::print_container_helper<T, wchar_t, ::std::char_traits<wchar_t>, Delims>(t);
        }

    private:
        const T & t;
    };

    template <typename Delims>
    struct custom_delims
    {
        template <typename Container> custom_delims(const Container & c) : base(new custom_delims_wrapper<Container, Delims>(c)) { }
        ~custom_delims() { delete base; }
        custom_delims_base * base;
    };

} // namespace pretty_print


template <typename TChar, typename TCharTraits, typename Delims>
inline std::basic_ostream<TChar, TCharTraits> & operator<<(std::basic_ostream<TChar, TCharTraits> & stream, const pretty_print::custom_delims<Delims> & p)
{
    return p.base->stream(stream);
}


// Template aliases for char and wchar_t delimiters
// Enable these if you have compiler support
//
// Implement as "template<T, C, A> const sdelims::type sdelims<std::set<T,C,A>>::values = { ... }."

//template<typename T> using pp_sdelims = pretty_print::delimiters<T, char>;
//template<typename T> using pp_wsdelims = pretty_print::delimiters<T, wchar_t>;


namespace std
{
    // Prints a print_container_helper to the specified stream.

    template<typename T, typename TChar, typename TCharTraits, typename TDelimiters>
    inline basic_ostream<TChar, TCharTraits> & operator<<(basic_ostream<TChar, TCharTraits> & stream,
                                                          const ::pretty_print::print_container_helper<T, TChar, TCharTraits, TDelimiters> & helper)
    {
        helper(stream);
        return stream;
    }

    // Prints a container to the stream using default delimiters

    template<typename T, typename TChar, typename TCharTraits>
    inline typename enable_if< ::pretty_print::is_container<T>::value, basic_ostream<TChar, TCharTraits>&>::type
    operator<<(basic_ostream<TChar, TCharTraits> & stream, const T & container)
    {
        return stream << ::pretty_print::print_container_helper<T, TChar, TCharTraits>(container);
    }

    // Prints a pair to the stream using delimiters from delimiters<std::pair<T1, T2>>.
    template<typename T1, typename T2, typename TChar, typename TCharTraits>
    inline basic_ostream<TChar, TCharTraits> & operator<<(basic_ostream<TChar, TCharTraits> & stream, const pair<T1, T2> & value)
    {
        if (::pretty_print::delimiters<pair<T1, T2>, TChar>::values.prefix != NULL)
            stream << ::pretty_print::delimiters<pair<T1, T2>, TChar>::values.prefix;

        stream << value.first;

        if (::pretty_print::delimiters<pair<T1, T2>, TChar>::values.delimiter != NULL)
            stream << ::pretty_print::delimiters<pair<T1, T2>, TChar>::values.delimiter;

        stream << value.second;

        if (::pretty_print::delimiters<pair<T1, T2>, TChar>::values.postfix != NULL)
            stream << ::pretty_print::delimiters<pair<T1, T2>, TChar>::values.postfix;

        return stream;
    }
} // namespace std

// Prints a tuple to the stream using delimiters from delimiters<std::pair<tuple_dummy_t, tuple_dummy_t>>.

namespace pretty_print
{
    struct tuple_dummy_t { }; // Just if you want special delimiters for tuples.

    typedef std::pair<tuple_dummy_t, tuple_dummy_t> tuple_dummy_pair;

    template<typename Tuple, size_t N, typename TChar, typename TCharTraits>
    struct pretty_tuple_helper
    {
        static inline void print(::std::basic_ostream<TChar, TCharTraits> & stream, const Tuple & value)
        {
            pretty_tuple_helper<Tuple, N - 1, TChar, TCharTraits>::print(stream, value);

            if (delimiters<tuple_dummy_pair, TChar>::values.delimiter != NULL)
                stream << delimiters<tuple_dummy_pair, TChar>::values.delimiter;

            stream << std::get<N - 1>(value);
        }
    };

    template<typename Tuple, typename TChar, typename TCharTraits>
    struct pretty_tuple_helper<Tuple, 1, TChar, TCharTraits>
    {
        static inline void print(::std::basic_ostream<TChar, TCharTraits> & stream, const Tuple & value) { stream << ::std::get<0>(value); }
    };
} // namespace pretty_print


namespace std
{
    template<typename TChar, typename TCharTraits, typename ...Args>
    inline basic_ostream<TChar, TCharTraits> & operator<<(basic_ostream<TChar, TCharTraits> & stream, const tuple<Args...> & value)
    {
        if (::pretty_print::delimiters< ::pretty_print::tuple_dummy_pair, TChar>::values.prefix != NULL)
            stream << ::pretty_print::delimiters< ::pretty_print::tuple_dummy_pair, TChar>::values.prefix;

        ::pretty_print::pretty_tuple_helper<const tuple<Args...> &, sizeof...(Args), TChar, TCharTraits>::print(stream, value);

        if (::pretty_print::delimiters< ::pretty_print::tuple_dummy_pair, TChar>::values.postfix != NULL)
            stream << ::pretty_print::delimiters< ::pretty_print::tuple_dummy_pair, TChar>::values.postfix;

        return stream;
    }
} // namespace std


// A wrapper for raw C-style arrays. Usage: int arr[] = { 1, 2, 4, 8, 16 };  std::cout << wrap_array(arr) << ...

namespace pretty_print
{
    template <typename T, size_t N>
    struct array_wrapper
    {
        typedef const T * const_iterator;
        typedef T value_type;

        array_wrapper(const T (& a)[N]) : _array(a) { }
        inline const_iterator begin() const { return _array; }
        inline const_iterator end() const { return _array + N; }

    private:
        const T * const _array;
    };
} // namespace pretty_print

template <typename T, size_t N>
inline pretty_print::array_wrapper<T, N> pretty_print_array(const T (& a)[N])
{
    return pretty_print::array_wrapper<T, N>(a);
}


#endif

Anwendungsbeispiel:

#include <iostream>
#include <vector>
#include <unordered_map>
#include <map>
#include <set>
#include <array>
#include <tuple>
#include <utility>
#include <string>

#include "prettyprint.h"

// Specialization for a particular container
template<> const pretty_print::delimiters_values<char> pretty_print::delimiters<std::vector<double>, char>::values = { "|| ", " : ", " ||" };

// Custom delimiters for one-off use
struct MyDel { static const delimiters_values<char> values; };
const delimiters_values<char> MyDel::values = { "<", "; ", ">" };

int main(int argc, char * argv[])
{
  std::string cs;
  std::unordered_map<int, std::string> um;
  std::map<int, std::string> om;
  std::set<std::string> ss;
  std::vector<std::string> v;
  std::vector<std::vector<std::string>> vv;
  std::vector<std::pair<int, std::string>> vp;
  std::vector<double> vd;
  v.reserve(argc - 1);
  vv.reserve(argc - 1);
  vp.reserve(argc - 1);
  vd.reserve(argc - 1);

  std::cout << "Printing pairs." << std::endl;

  while (--argc)
  {
    std::string s(argv[argc]);
    std::pair<int, std::string> p(argc, s);

    um[argc] = s;
    om[argc] = s;
    v.push_back(s);
    vv.push_back(v);
    vp.push_back(p);
    vd.push_back(1./double(i));
    ss.insert(s);
    cs += s;

    std::cout << "  " << p << std::endl;
  }

  std::array<char, 5> a{{ 'h', 'e', 'l', 'l', 'o' }};

  std::cout << "Vector: " << v << std::endl
            << "Incremental vector: " << vv << std::endl
            << "Another vector: " << vd << std::endl
            << "Pairs: " << vp << std::endl
            << "Set: " << ss << std::endl
            << "OMap: " << om << std::endl
            << "UMap: " << um << std::endl
            << "String: " << cs << std::endl
            << "Array: " << a << std::endl
  ;

  // Using custom delimiters manually:
  std::cout << pretty_print::print_container_helper<std::vector<std::string>, char, std::char_traits<char>, MyDel>(v) << std::endl;

  // Using custom delimiters with the type-erasing helper class
  std::cout << pretty_print::custom_delims<MyDel>(v) << std::endl;

  // Pairs and tuples and arrays:
  auto a1 = std::make_pair(std::string("Jello"), 9);
  auto a2 = std::make_tuple(1729);
  auto a3 = std::make_tuple("Qrgh", a1, 11);
  auto a4 = std::make_tuple(1729, 2875, std::pair<double, std::string>(1.5, "meow"));
  int arr[] = { 1, 4, 9, 16 };

  std::cout << "C array: " << wrap_array(arr) << std::endl
            << "Pair: " << a1 << std::endl
            << "1-tuple: " << a2 << std::endl
            << "n-tuple: " << a3 << std::endl
            << "n-tuple: " << a4 << std::endl
  ;
}

Weitere Verbesserungsvorschläge:

  • Implementieren Sie die Ausgabe für std::tuple<...>auf die gleiche Weise, für die wir sie haben std::pair<S,T>. Update: Dies ist jetzt eine separate Frage zu SO ! Upupdate: Dies wurde jetzt dank Xeo implementiert!
  • Fügen Sie Namespaces hinzu, damit die Hilfsklassen nicht in den globalen Namespace übergehen. Erledigt
  • Fügen Sie Vorlagen-Aliase (oder ähnliches) hinzu, um das Erstellen benutzerdefinierter Trennzeichenklassen oder möglicherweise Präprozessor-Makros zu erleichtern.

Neueste Updates:

  • Ich habe den benutzerdefinierten Ausgabe-Iterator zugunsten einer einfachen for-Schleife in der Druckfunktion entfernt.
  • Alle Implementierungsdetails befinden sich jetzt im pretty_printNamespace. Nur die globalen Stream-Operatoren und der pretty_print_arrayWrapper befinden sich im globalen Namespace.
  • Der Namespace wurde so korrigiert, dass er operator<<jetzt korrekt angezeigt wird std.

Anmerkungen:

  • Das Entfernen des Ausgabe-Iterators bedeutet, dass es keine Möglichkeit gibt std::copy(), einen hübschen Druck zu erhalten. Ich könnte den hübschen Iterator wieder einsetzen, wenn dies eine gewünschte Funktion ist, aber der folgende Code von Sven hat die Implementierung.
  • Es war eine bewusste Entwurfsentscheidung, die Begrenzer eher zur Konstante der Kompilierungszeit als zu Objektkonstanten zu machen. Das bedeutet, dass Sie zur Laufzeit keine Trennzeichen dynamisch bereitstellen können, aber es bedeutet auch, dass kein unnötiger Overhead entsteht. Eine objektbasierte Begrenzerkonfiguration wurde von Dennis Zickefoose in einem Kommentar zu Svens Code unten vorgeschlagen. Falls gewünscht, könnte dies als alternative Funktion implementiert werden.
  • Es ist derzeit nicht klar, wie verschachtelte Containerbegrenzer angepasst werden sollen.
  • Beachten Sie, dass der Zweck dieser Bibliothek darin besteht, schnelle Containerdruckfunktionen zu ermöglichen , für die Sie keine Codierung benötigen . Es handelt sich nicht um eine Allzweck-Formatierungsbibliothek, sondern um ein Entwicklungswerkzeug, mit dem die Notwendigkeit verringert werden muss, Kesselplattencode für die Behälterinspektion zu schreiben.

Vielen Dank an alle, die dazu beigetragen haben!


Hinweis: Wenn Sie nach einer schnellen Möglichkeit suchen, benutzerdefinierte Trennzeichen bereitzustellen, finden Sie hier eine Möglichkeit zum Löschen von Typen. Wir gehen davon aus, dass Sie bereits eine Trennzeichenklasse erstellt haben MyDel, beispielsweise wie folgt:

struct MyDel { static const pretty_print::delimiters_values<char> values; };
const pretty_print::delimiters_values<char> MyDel::values = { "<", "; ", ">" };

Jetzt möchten wir in der Lage sein, mit diesen Trennzeichen std::cout << MyPrinter(v) << std::endl;für einen Container zu schreiben v. MyPrinterwird eine typlöschende Klasse sein, wie folgt:

struct wrapper_base
{
  virtual ~wrapper_base() { }
  virtual std::ostream & stream(std::ostream & o) = 0;
};

template <typename T, typename Delims>
struct wrapper : public wrapper_base
{
  wrapper(const T & t) : t(t) { }
  std::ostream & stream(std::ostream & o)
  {
    return o << pretty_print::print_container_helper<T, char, std::char_traits<char>, Delims>(t);
  }
private:
  const T & t;
};

template <typename Delims>
struct MyPrinter
{
  template <typename Container> MyPrinter(const Container & c) : base(new wrapper<Container, Delims>(c)) { }
  ~MyPrinter() { delete base; }
  wrapper_base * base;
};

template <typename Delims>
std::ostream & operator<<(std::ostream & o, const MyPrinter<Delims> & p) { return p.base->stream(o); }
Kerrek SB
quelle
Ihr Code funktioniert nicht. Es gibt kein Schlüsselwort wie Container C
the_drow
31
@the_drow: Es sieht so aus, als ob OP das bereits weiß. Sie zeigen nur an, wonach sie suchen.
Marcelo Cantos
In der Tat habe ich nur ein "moralisches" Pseudocode-Beispiel gegeben. (Ich stelle auch den Rückgabetyp weg.) Natürlich weiß ich nicht einmal, wie ich die Trennzeichen am besten austauschbar machen kann.
Kerrek SB
1
Eine andere Alternative wäre, die Operatoren in den pretty_printNamespace einzufügen und einen Wrapper bereitzustellen, den der Benutzer beim Drucken verwenden kann. Aus Anwendersicht: std::cout << pretty_print(v);(wahrscheinlich mit einem anderen Namen). Dann können Sie den Operator im selben Namespace wie den Wrapper bereitstellen und ihn dann erweitern, um alles zu drucken, was Sie wollen. Sie können auch den Wrapper erweitern, indem Sie optional das Trennzeichen definieren, das in jedem Aufruf verwendet werden soll (anstatt Merkmale zu verwenden, die dieselbe Auswahl für die gesamte Anwendung erzwingen). \
David Rodríguez - dribeas
1
Bitte machen Sie Ihre "Update" -Antworten zu tatsächlichen Antworten, anstatt eine humorvolle Frage zu haben.
Einpoklum

Antworten:

82

Diese Lösung wurde mit einigen Änderungen von Marcelos Lösung inspiriert:

#include <iostream>
#include <iterator>
#include <type_traits>
#include <vector>
#include <algorithm>

// This works similar to ostream_iterator, but doesn't print a delimiter after the final item
template<typename T, typename TChar = char, typename TCharTraits = std::char_traits<TChar> >
class pretty_ostream_iterator : public std::iterator<std::output_iterator_tag, void, void, void, void>
{
public:
    typedef TChar char_type;
    typedef TCharTraits traits_type;
    typedef std::basic_ostream<TChar, TCharTraits> ostream_type;

    pretty_ostream_iterator(ostream_type &stream, const char_type *delim = NULL)
        : _stream(&stream), _delim(delim), _insertDelim(false)
    {
    }

    pretty_ostream_iterator<T, TChar, TCharTraits>& operator=(const T &value)
    {
        if( _delim != NULL )
        {
            // Don't insert a delimiter if this is the first time the function is called
            if( _insertDelim )
                (*_stream) << _delim;
            else
                _insertDelim = true;
        }
        (*_stream) << value;
        return *this;
    }

    pretty_ostream_iterator<T, TChar, TCharTraits>& operator*()
    {
        return *this;
    }

    pretty_ostream_iterator<T, TChar, TCharTraits>& operator++()
    {
        return *this;
    }

    pretty_ostream_iterator<T, TChar, TCharTraits>& operator++(int)
    {
        return *this;
    }
private:
    ostream_type *_stream;
    const char_type *_delim;
    bool _insertDelim;
};

#if _MSC_VER >= 1400

// Declare pretty_ostream_iterator as checked
template<typename T, typename TChar, typename TCharTraits>
struct std::_Is_checked_helper<pretty_ostream_iterator<T, TChar, TCharTraits> > : public std::tr1::true_type
{
};

#endif // _MSC_VER >= 1400

namespace std
{
    // Pre-declarations of container types so we don't actually have to include the relevant headers if not needed, speeding up compilation time.
    // These aren't necessary if you do actually include the headers.
    template<typename T, typename TAllocator> class vector;
    template<typename T, typename TAllocator> class list;
    template<typename T, typename TTraits, typename TAllocator> class set;
    template<typename TKey, typename TValue, typename TTraits, typename TAllocator> class map;
}

// Basic is_container template; specialize to derive from std::true_type for all desired container types
template<typename T> struct is_container : public std::false_type { };

// Mark vector as a container
template<typename T, typename TAllocator> struct is_container<std::vector<T, TAllocator> > : public std::true_type { };

// Mark list as a container
template<typename T, typename TAllocator> struct is_container<std::list<T, TAllocator> > : public std::true_type { };

// Mark set as a container
template<typename T, typename TTraits, typename TAllocator> struct is_container<std::set<T, TTraits, TAllocator> > : public std::true_type { };

// Mark map as a container
template<typename TKey, typename TValue, typename TTraits, typename TAllocator> struct is_container<std::map<TKey, TValue, TTraits, TAllocator> > : public std::true_type { };

// Holds the delimiter values for a specific character type
template<typename TChar>
struct delimiters_values
{
    typedef TChar char_type;
    const TChar *prefix;
    const TChar *delimiter;
    const TChar *postfix;
};

// Defines the delimiter values for a specific container and character type
template<typename T, typename TChar>
struct delimiters
{
    static const delimiters_values<TChar> values; 
};

// Default delimiters
template<typename T> struct delimiters<T, char> { static const delimiters_values<char> values; };
template<typename T> const delimiters_values<char> delimiters<T, char>::values = { "{ ", ", ", " }" };
template<typename T> struct delimiters<T, wchar_t> { static const delimiters_values<wchar_t> values; };
template<typename T> const delimiters_values<wchar_t> delimiters<T, wchar_t>::values = { L"{ ", L", ", L" }" };

// Delimiters for set
template<typename T, typename TTraits, typename TAllocator> struct delimiters<std::set<T, TTraits, TAllocator>, char> { static const delimiters_values<char> values; };
template<typename T, typename TTraits, typename TAllocator> const delimiters_values<char> delimiters<std::set<T, TTraits, TAllocator>, char>::values = { "[ ", ", ", " ]" };
template<typename T, typename TTraits, typename TAllocator> struct delimiters<std::set<T, TTraits, TAllocator>, wchar_t> { static const delimiters_values<wchar_t> values; };
template<typename T, typename TTraits, typename TAllocator> const delimiters_values<wchar_t> delimiters<std::set<T, TTraits, TAllocator>, wchar_t>::values = { L"[ ", L", ", L" ]" };

// Delimiters for pair
template<typename T1, typename T2> struct delimiters<std::pair<T1, T2>, char> { static const delimiters_values<char> values; };
template<typename T1, typename T2> const delimiters_values<char> delimiters<std::pair<T1, T2>, char>::values = { "(", ", ", ")" };
template<typename T1, typename T2> struct delimiters<std::pair<T1, T2>, wchar_t> { static const delimiters_values<wchar_t> values; };
template<typename T1, typename T2> const delimiters_values<wchar_t> delimiters<std::pair<T1, T2>, wchar_t>::values = { L"(", L", ", L")" };

// Functor to print containers. You can use this directly if you want to specificy a non-default delimiters type.
template<typename T, typename TChar = char, typename TCharTraits = std::char_traits<TChar>, typename TDelimiters = delimiters<T, TChar> >
struct print_container_helper
{
    typedef TChar char_type;
    typedef TDelimiters delimiters_type;
    typedef std::basic_ostream<TChar, TCharTraits>& ostream_type;

    print_container_helper(const T &container)
        : _container(&container)
    {
    }

    void operator()(ostream_type &stream) const
    {
        if( delimiters_type::values.prefix != NULL )
            stream << delimiters_type::values.prefix;
        std::copy(_container->begin(), _container->end(), pretty_ostream_iterator<typename T::value_type, TChar, TCharTraits>(stream, delimiters_type::values.delimiter));
        if( delimiters_type::values.postfix != NULL )
            stream << delimiters_type::values.postfix;
    }
private:
    const T *_container;
};

// Prints a print_container_helper to the specified stream.
template<typename T, typename TChar, typename TCharTraits, typename TDelimiters>
std::basic_ostream<TChar, TCharTraits>& operator<<(std::basic_ostream<TChar, TCharTraits> &stream, const print_container_helper<T, TChar, TDelimiters> &helper)
{
    helper(stream);
    return stream;
}

// Prints a container to the stream using default delimiters
template<typename T, typename TChar, typename TCharTraits>
typename std::enable_if<is_container<T>::value, std::basic_ostream<TChar, TCharTraits>&>::type
    operator<<(std::basic_ostream<TChar, TCharTraits> &stream, const T &container)
{
    stream << print_container_helper<T, TChar, TCharTraits>(container);
    return stream;
}

// Prints a pair to the stream using delimiters from delimiters<std::pair<T1, T2>>.
template<typename T1, typename T2, typename TChar, typename TCharTraits>
std::basic_ostream<TChar, TCharTraits>& operator<<(std::basic_ostream<TChar, TCharTraits> &stream, const std::pair<T1, T2> &value)
{
    if( delimiters<std::pair<T1, T2>, TChar>::values.prefix != NULL )
        stream << delimiters<std::pair<T1, T2>, TChar>::values.prefix;

    stream << value.first;

    if( delimiters<std::pair<T1, T2>, TChar>::values.delimiter != NULL )
        stream << delimiters<std::pair<T1, T2>, TChar>::values.delimiter;

    stream << value.second;

    if( delimiters<std::pair<T1, T2>, TChar>::values.postfix != NULL )
        stream << delimiters<std::pair<T1, T2>, TChar>::values.postfix;
    return stream;    
}

// Used by the sample below to generate some values
struct fibonacci
{
    fibonacci() : f1(0), f2(1) { }
    int operator()()
    {
        int r = f1 + f2;
        f1 = f2;
        f2 = r;
        return f1;
    }
private:
    int f1;
    int f2;
};

int main()
{
    std::vector<int> v;
    std::generate_n(std::back_inserter(v), 10, fibonacci());

    std::cout << v << std::endl;

    // Example of using pretty_ostream_iterator directly
    std::generate_n(pretty_ostream_iterator<int>(std::cout, ";"), 20, fibonacci());
    std::cout << std::endl;
}

Wie in der Marcelo-Version wird ein Merkmal vom Typ is_container verwendet, das auf alle zu unterstützenden Container spezialisiert sein muss. Es kann möglich sein , ein Merkmal zu verwenden , um zu überprüfen value_type, const_iterator, begin()/ end(), aber ich bin nicht sicher , würde ich das empfehlen , da es Dinge passen könnte, die diese Kriterien entsprechen , sind aber nicht wirklich Container, wie std::basic_string. Ebenso wie in Marcelos Version werden Vorlagen verwendet, die darauf spezialisiert werden können, die zu verwendenden Trennzeichen anzugeben.

Der Hauptunterschied besteht darin, dass ich meine Version um eine herum erstellt habe pretty_ostream_iterator, die ähnlich wie die std::ostream_iteratorfunktioniert, aber nach dem letzten Element kein Trennzeichen druckt. Das Formatieren der Container erfolgt über das print_container_helper, mit dem Container ohne is_container-Merkmal direkt gedruckt oder ein anderer Trennzeichentyp angegeben werden kann.

Ich habe auch is_container und Trennzeichen definiert, damit es für Container mit nicht standardmäßigen Prädikaten oder Allokatoren sowie für char und wchar_t funktioniert. Die Operator << -Funktion selbst ist auch so definiert, dass sie sowohl mit char- als auch mit wchar_t-Streams arbeitet.

Schließlich habe ich verwendet std::enable_if, das als Teil von C ++ 0x verfügbar ist und in Visual C ++ 2010 und g ++ 4.3 (benötigt das Flag -std = c ++ 0x) und höher funktioniert. Auf diese Weise besteht keine Abhängigkeit von Boost.

Sven
quelle
Wenn ich dies richtig lese , müssen Sie einen ganz neuen Typ mit einer Handvoll statischer Elemente definieren, um diesen Typ übergeben zu können, damit ein Paar wie <i, j>in einer Funktion und wie [i j]in einer anderen gedruckt wird print_container_helper. Das scheint zu komplex. Warum nicht mit einem tatsächlichen Objekt arbeiten, mit Feldern, die Sie von Fall zu Fall festlegen können, und den Spezialisierungen, die einfach unterschiedliche Standardwerte bereitstellen?
Dennis Zickefoose
Sehen Sie es so: Wenn es eine Reihe von Trennzeichen gibt, die Sie persönlich mögen, können Sie ein für alle Mal ein paar Klassen mit statischen Mitgliedern erstellen und diese dann einfach verwenden. Natürlich haben Sie Recht, dass die Verwendung print_container_helpernicht so elegant ist wie die operator<<. Sie können natürlich jederzeit die Quelle ändern oder einfach explizite Spezialisierungen für Ihren Lieblingscontainer hinzufügen, z . B. für pair<int, int>und für pair<double, string>. Letztendlich geht es darum, Macht gegen Bequemlichkeit abzuwägen. Verbesserungsvorschläge willkommen!
Kerrek SB
... und um dem nachzugehen, müssen Sie wahrscheinlich ohnehin mindestens einen kleinen Wrapper schreiben , wenn Sie bereits einen Situationsdruck desselben Datentyps in verschiedenen Formatierungen benötigen . Dies ist keine hoch konfigurierbare Formatierungsbibliothek, sondern eine sinnlose Standardbibliothek ohne Aufwand, mit der Sie Container auf magische Weise drucken können, ohne darüber nachzudenken ... (Wenn Sie jedoch mehr globale Flexibilität wünschen , können wir wahrscheinlich einige #macros hinzufügen Die Standardeinstellungen sind leicht zu manipulieren.)
Kerrek SB
Das eigentliche Problem ist, dass, obwohl ich print_container_helper leicht ändern könnte, um Parameter für die benutzerdefinierten Trennzeichen zu verwenden, es keine andere Möglichkeit gibt, Trennzeichen für einen inneren Container (oder ein inneres Paar) anzugeben, als die Trennzeichenvorlage zu spezialisieren. Das zu erreichen wäre sehr kompliziert.
Sven
Ich schaffe es fast, eine bequeme benutzerdefinierte Trennzeichenlösung durch Löschen von Typen zu erreichen. Wenn Sie bereits eine Trennzeichenklasse haben MyDels, kann ich sagen std::cout << CustomPrinter<MyDels>(x);. Was ich im Moment nicht tun kann , ist zu sagen std::cout << CustomDelims<"{", ":", "}">(x);, weil Sie keine const char *Vorlagenargumente haben können . Die Entscheidung, die Kompilierungszeit der Trennzeichen konstant zu halten, schränkt die Benutzerfreundlichkeit dort ein, aber ich denke, es lohnt sich.
Kerrek SB
22

Dies wurde einige Male bearbeitet, und wir haben beschlossen, die Hauptklasse aufzurufen, die eine Sammlung RangePrinter umschließt

Dies sollte automatisch mit jeder Sammlung funktionieren, sobald Sie den einmaligen Operator << overload geschrieben haben, außer dass Sie einen speziellen Operator für Karten benötigen, um das Paar zu drucken, und möglicherweise das Trennzeichen dort anpassen möchten.

Sie können auch eine spezielle "Druck" -Funktion für das Element verwenden, anstatt es nur direkt auszugeben. Ähnlich wie bei STL-Algorithmen können Sie benutzerdefinierte Prädikate übergeben. Mit map würden Sie es auf diese Weise verwenden, mit einem benutzerdefinierten Drucker für das std :: pair.

Ihr "Standard" -Drucker würde es nur in den Stream ausgeben.

Ok, lassen Sie uns an einem benutzerdefinierten Drucker arbeiten. Ich werde meine äußere Klasse in RangePrinter ändern. Wir haben also 2 Iteratoren und einige Trennzeichen, aber nicht angepasst, wie die tatsächlichen Elemente gedruckt werden sollen.

struct DefaultPrinter
{
   template< typename T >
   std::ostream & operator()( std::ostream& os, const T& t ) const
   {
     return os << t;
   }

   // overload for std::pair
   template< typename K, typename V >
   std::ostream & operator()( std::ostream & os, std::pair<K,V> const& p)
   {
      return os << p.first << '=' << p.second;
   }
};

// some prototypes
template< typename FwdIter, typename Printer > class RangePrinter;

template< typename FwdIter, typename Printer > 
  std::ostream & operator<<( std::ostream &, 
        RangePrinter<FwdIter, Printer> const& );

template< typename FwdIter, typename Printer=DefaultPrinter >
class RangePrinter
{
    FwdIter begin;
    FwdIter end;
    std::string delim;
    std::string open;
    std::string close;
    Printer printer;

    friend std::ostream& operator<< <>( std::ostream&, 
         RangePrinter<FwdIter,Printer> const& );

public:
    RangePrinter( FwdIter b, FwdIter e, Printer p,
         std::string const& d, std::string const & o, std::string const& c )
      : begin( b ), end( e ), printer( p ), open( o ), close( c )
    {
    } 

     // with no "printer" variable
    RangePrinter( FwdIter b, FwdIter e,
         std::string const& d, std::string const & o, std::string const& c )
      : begin( b ), end( e ), open( o ), close( c )
    {
    } 

};


template<typename FwdIter, typename Printer>
std::ostream& operator<<( std::ostream& os, 
          RangePrinter<FwdIter, Printer> const& range )
{
    const Printer & printer = range.printer;

    os << range.open;
    FwdIter begin = range.begin, end = range.end;

    // print the first item
    if (begin == end) 
    { 
      return os << range.close; 
    }

    printer( os, *begin );

    // print the rest with delim as a prefix
    for( ++begin; begin != end; ++begin )
    {
       os << range.delim;
       printer( os, *begin );
    }
    return os << range.close;
}

Jetzt funktioniert es standardmäßig für Karten, solange sowohl der Schlüssel- als auch der Wertetyp druckbar sind und Sie Ihren eigenen Spezialdrucker einsetzen können, wenn dies nicht der Fall ist (wie bei jedem anderen Typ) oder wenn Sie dies nicht möchten = als Trennzeichen.

Ich verschiebe die freie Funktion, um diese jetzt bis zum Ende zu erstellen:

Eine freie Funktion (Iterator-Version) würde so aussehen und Sie könnten sogar Standardeinstellungen haben:

template<typename Collection>
RangePrinter<typename Collection::const_iterator> rangePrinter
    ( const Collection& coll, const char * delim=",", 
       const char * open="[", const char * close="]")
{
   return RangePrinter< typename Collection::const_iterator >
     ( coll.begin(), coll.end(), delim, open, close );
}

Sie können es dann für std :: set by verwenden

 std::cout << outputFormatter( mySet );

Sie können auch eine Version mit freien Funktionen schreiben, die einen benutzerdefinierten Drucker und zwei Iteratoren benötigt. In jedem Fall lösen sie die Vorlagenparameter für Sie auf und Sie können sie als temporäre Parameter weitergeben.

Goldesel
quelle
Aha. Das ähnelt der Idee von Marcelo Cantos, nicht wahr? Ich werde versuchen, daraus ein funktionierendes Beispiel zu machen, danke!
Kerrek SB
Ich finde diese Lösung viel sauberer als die von Marcelo und sie bietet die gleiche Flexibilität. Ich mag den Aspekt, dass man die Ausgabe explizit in einen Funktionsaufruf einbinden muss. Um wirklich cool zu sein, könnten Sie Unterstützung für die direkte Ausgabe einer Reihe von Iteratoren hinzufügen, damit ich dies tun kann std::cout << outputFormatter(beginOfRange, endOfRange);.
Björn Pollex
1
@CashCow: Es gibt ein Problem mit dieser Lösung, sie scheint nicht mit rekursiven Sammlungen (dh Sammlungen von Sammlungen) zu funktionieren. std::pairist das grundlegendste Beispiel für "innere Sammlung".
Matthieu M.
Diese Antwort gefällt mir sehr gut, da sie keine Abhängigkeiten aufweist und nicht über die unterstützten Container Bescheid wissen muss. Können wir herausfinden, ob es std::mapleicht mit s umgehen kann und ob es für Sammlungen von Sammlungen funktioniert? Ich bin jedoch versucht, dies als Antwort zu akzeptieren. Ich hoffe, Marcelo macht das nichts aus, seine Lösung funktioniert auch.
Kerrek SB
@Matthieu M. Es hängt davon ab, wie Sie die innere Sammlung drucken. Wenn Sie nur os << open << * iter << close verwenden, haben Sie ein Problem damit. Wenn Sie Ihrem Benutzer jedoch erlauben, einen benutzerdefinierten Drucker zu übergeben, wie ich vorgeschlagen habe, können Sie alles drucken, was Sie möchten.
CashCow
14

Hier ist eine Arbeitsbibliothek, die als komplettes Arbeitsprogramm präsentiert wird und die ich gerade zusammen gehackt habe:

#include <set>
#include <vector>
#include <iostream>

#include <boost/utility/enable_if.hpp>

// Default delimiters
template <class C> struct Delims { static const char *delim[3]; };
template <class C> const char *Delims<C>::delim[3]={"[", ", ", "]"};
// Special delimiters for sets.                                                                                                             
template <typename T> struct Delims< std::set<T> > { static const char *delim[3]; };
template <typename T> const char *Delims< std::set<T> >::delim[3]={"{", ", ", "}"};

template <class C> struct IsContainer { enum { value = false }; };
template <typename T> struct IsContainer< std::vector<T> > { enum { value = true }; };
template <typename T> struct IsContainer< std::set<T>    > { enum { value = true }; };

template <class C>
typename boost::enable_if<IsContainer<C>, std::ostream&>::type
operator<<(std::ostream & o, const C & x)
{
  o << Delims<C>::delim[0];
  for (typename C::const_iterator i = x.begin(); i != x.end(); ++i)
    {
      if (i != x.begin()) o << Delims<C>::delim[1];
      o << *i;
    }
  o << Delims<C>::delim[2];
  return o;
}

template <typename T> struct IsChar { enum { value = false }; };
template <> struct IsChar<char> { enum { value = true }; };

template <typename T, int N>
typename boost::disable_if<IsChar<T>, std::ostream&>::type
operator<<(std::ostream & o, const T (&x)[N])
{
  o << "[";
  for (int i = 0; i != N; ++i)
    {
      if (i) o << ",";
      o << x[i];
    }
  o << "]";
  return o;
}

int main()
{
  std::vector<int> i;
  i.push_back(23);
  i.push_back(34);

  std::set<std::string> j;
  j.insert("hello");
  j.insert("world");

  double k[] = { 1.1, 2.2, M_PI, -1.0/123.0 };

  std::cout << i << "\n" << j << "\n" << k << "\n";
}

Es funktioniert derzeit nur mit vectorund set, kann aber für die meisten Container verwendet werden, indem nur die IsContainerSpezialisierungen erweitert werden. Ich habe nicht viel darüber nachgedacht, ob dieser Code minimal ist, aber ich kann mir nichts vorstellen, was ich als redundant herausnehmen könnte.

EDIT: Nur zum Spaß habe ich eine Version hinzugefügt, die Arrays handhabt. Ich musste char-Arrays ausschließen, um weitere Unklarheiten zu vermeiden. es könnte immer noch in Schwierigkeiten geraten wchar_t[].

Marcelo Cantos
quelle
2
@Nawaz: Wie gesagt, dies ist nur der Anfang einer Lösung. Sie können dies std::map<>entweder durch Spezialisierung des Operators oder durch Definieren eines operator<<for unterstützen std::pair<>.
Marcelo Cantos
Allerdings +1 für die Verwendung der DelimsKlassenvorlage!
Nawaz
@MC: Oh gut. Das sieht sehr vielversprechend aus! (Übrigens benötigen Sie den Rückgabetyp "std :: ostream &", das hatte ich anfangs vergessen.)
Kerrek SB
Hmm, ich bekomme "mehrdeutige Überladung", wenn ich dies auf einem std :: vector <int> und std :: set <std :: string>
versuche
Ja, ich überlege gerade, wie ich die Mehrdeutigkeiten verhindern kann, die durch die Tatsache verursacht werden, dass die operator<<Vorlage mit fast allem übereinstimmt.
Marcelo Cantos
10

Sie können Container sowie Bereiche und Tupel mithilfe der {fmt} -Bibliothek formatieren . Zum Beispiel:

#include <vector>
#include <fmt/ranges.h>

int main() {
  auto v = std::vector<int>{1, 2, 3};
  fmt::print("{}", v);
}

druckt

{1, 2, 3}

zu stdout.

Haftungsausschluss : Ich bin der Autor von {fmt}.

vitaut
quelle
8

Der Code hat sich bereits mehrmals als nützlich erwiesen, und ich bin der Meinung, dass die Kosten für die Anpassung sehr gering sind, da die Nutzung recht gering ist. Daher habe ich beschlossen, es unter MIT- Lizenz freizugeben und ein GitHub-Repository bereitzustellen, in das der Header und eine kleine Beispieldatei heruntergeladen werden können.

http://djmuw.github.io/prettycc

0. Vorwort und Wortlaut

Eine 'Dekoration' in Bezug auf diese Antwort ist eine Reihe von Präfix-Strings, Trennzeichen-Strings und Postfix-Strings. Wo die Präfixzeichenfolge vor und die Postfixzeichenfolge nach den Werten eines Containers in einen Stream eingefügt wird (siehe 2. Zielcontainer). Die Trennzeichenfolge wird zwischen den Werten des jeweiligen Containers eingefügt.

Hinweis: Tatsächlich beantwortet diese Antwort die Frage nicht zu 100%, da die Dekoration nicht streng kompiliert ist, da Laufzeitprüfungen erforderlich sind, um zu überprüfen, ob eine benutzerdefinierte Dekoration auf den aktuellen Stream angewendet wurde. Trotzdem denke ich, dass es einige anständige Eigenschaften hat.

Hinweis 2: Kann kleinere Fehler aufweisen, da es noch nicht gut getestet wurde.

1. Allgemeine Idee / Verwendung

Für die Verwendung ist kein zusätzlicher Code erforderlich

Es ist so einfach zu halten wie

#include <vector>
#include "pretty.h"

int main()
{
  std::cout << std::vector<int>{1,2,3,4,5}; // prints 1, 2, 3, 4, 5
  return 0;
}

Einfache Anpassung ...

... in Bezug auf ein bestimmtes Stream-Objekt

#include <vector>
#include "pretty.h"

int main()
{
  // set decoration for std::vector<int> for cout object
  std::cout << pretty::decoration<std::vector<int>>("(", ",", ")");
  std::cout << std::vector<int>{1,2,3,4,5}; // prints (1,2,3,4,5)
  return 0;
}

oder in Bezug auf alle Streams:

#include <vector>
#include "pretty.h"

// set decoration for std::vector<int> for all ostream objects
PRETTY_DEFAULT_DECORATION(std::vector<int>, "{", ", ", "}")

int main()
{
  std::cout << std::vector<int>{1,2,3,4,5}; // prints {1, 2, 3, 4, 5}
  std::cout << pretty::decoration<std::vector<int>>("(", ",", ")");
  std::cout << std::vector<int>{1,2,3,4,5}; // prints (1,2,3,4,5)
  return 0;
}

Grobe Beschreibung

  • Der Code enthält eine Klassenvorlage, die eine Standarddekoration für jeden Typ bereitstellt
  • Dies kann darauf spezialisiert sein, die Standarddekoration für (a) bestimmte Typen zu ändern
  • Verwenden des privaten Speichers, der ios_basemit xalloc/ bereitgestellt wird pword, um einen Zeiger auf ein pretty::decorObjekt zu speichern, das speziell einen bestimmten Typ in einem bestimmten Stream dekoriert.

Wenn kein pretty::decor<T>Objekt für diesen Stream explizit eingerichtet wurde, pretty::defaulted<T, charT, chartraitT>::decoration()wird aufgerufen, um die Standarddekoration für den angegebenen Typ zu erhalten. Die Klasse pretty::defaultedsoll darauf spezialisiert sein, Standarddekorationen anzupassen.

2. Ziele Objekte / Container

Zielobjekte objfür die 'hübsche Dekoration' dieses Codes sind Objekte mit beidem

  • Überladungen std::beginund std::enddefiniert (einschließlich C-Style-Arrays),
  • mit begin(obj)und end(obj)über ADL verfügbar,
  • sind vom Typ std::tuple
  • oder vom Typ std::pair.

Der Code enthält ein Merkmal zur Identifizierung von Klassen mit Bereichsmerkmalen ( begin/ end). (Es ist jedoch keine Prüfung enthalten, ob begin(obj) == end(obj)es sich um einen gültigen Ausdruck handelt.)

Der Code enthält operator<<s im globalen Namespace, die nur für Klassen gelten, für die keine speziellere Version operator<<verfügbar ist. Daher wird beispielsweise std::stringnicht mit dem Operator in diesem Code gedruckt, obwohl ein gültiges begin/ endPaar vorhanden ist.

3. Nutzung und Anpassung

Dekorationen können für jeden Typ (außer für verschiedene tuples) und jeden Stream (nicht für jeden Stream-Typ!) Separat auferlegt werden . (Dh a std::vector<int>kann unterschiedliche Dekorationen für unterschiedliche Stream-Objekte haben.)

A) Standarddekoration

Das Standardpräfix ist ""(nichts), ebenso wie das Standardpostfix, während das Standardtrennzeichen ", "(Komma + Leerzeichen) ist.

B) Benutzerdefinierte Standarddekoration eines Typs durch Spezialisierung der pretty::defaultedKlassenvorlage

Das struct defaultedhat eine statische decoration()Elementfunktion, die ein decorObjekt zurückgibt, das die Standardwerte für den angegebenen Typ enthält.

Beispiel mit einem Array:

Anpassen des Standard-Array-Drucks:

namespace pretty
{
  template<class T, std::size_t N>
  struct defaulted<T[N]>
  {
    static decor<T[N]> decoration()
    {
      return{ { "(" }, { ":" }, { ")" } };
    }
  };
}

Drucken Sie ein Arry-Array:

float e[5] = { 3.4f, 4.3f, 5.2f, 1.1f, 22.2f };
std::cout << e << '\n'; // prints (3.4:4.3:5.2:1.1:22.2)

Verwenden des PRETTY_DEFAULT_DECORATION(TYPE, PREFIX, DELIM, POSTFIX, ...)Makros für charStreams

Das Makro wird auf erweitert

namespace pretty { 
  template< __VA_ARGS__ >
  struct defaulted< TYPE > {
    static decor< TYPE > decoration() {
      return { PREFIX, DELIM, POSTFIX };
    } 
  }; 
} 

Ermöglichen, dass die obige Teilspezialisierung umgeschrieben wird

PRETTY_DEFAULT_DECORATION(T[N], "", ";", "", class T, std::size_t N)

oder Einfügen einer vollständigen Spezialisierung wie

PRETTY_DEFAULT_DECORATION(std::vector<int>, "(", ", ", ")")

Ein weiteres Makro für wchar_tStreams ist enthalten : PRETTY_DEFAULT_WDECORATION.

C) Bäche dekorieren

Die Funktion pretty::decorationwird verwendet, um einem bestimmten Stream eine Dekoration aufzuerlegen. Es gibt Überladungen, die entweder - ein Zeichenfolgenargument ist das Trennzeichen (das Präfix und Postfix aus der Standardklasse übernimmt) - oder drei Zeichenfolgenargumente, die die vollständige Dekoration zusammensetzen

Komplette Dekoration für den gegebenen Typ und Strom

float e[3] = { 3.4f, 4.3f, 5.2f };
std::stringstream u;
// add { ; } decoration to u
u << pretty::decoration<float[3]>("{", "; ", "}");

// use { ; } decoration
u << e << '\n'; // prints {3.4; 4.3; 5.2}

// uses decoration returned by defaulted<float[3]>::decoration()
std::cout << e; // prints 3.4, 4.3, 5.2

Anpassung des Trennzeichens für den angegebenen Stream

PRETTY_DEFAULT_DECORATION(float[3], "{{{", ",", "}}}")

std::stringstream v;
v << e; // prints {{{3.4,4.3,5.2}}}

v << pretty::decoration<float[3]>(":");
v << e; // prints {{{3.4:4.3:5.2}}}

v << pretty::decoration<float[3]>("((", "=", "))");
v << e; // prints ((3.4=4.3=5.2))

4. Besondere Behandlung von std::tuple

Anstatt eine Spezialisierung für jeden möglichen Tupeltyp zuzulassen, wendet dieser Code jede Dekoration an, die für std::tuple<void*>alle Arten von std::tuple<...>s verfügbar ist .

5. Entfernen Sie die benutzerdefinierte Dekoration aus dem Stream

Verwenden Sie die pretty::clearFunktionsvorlage im Stream, um zur Standarddekoration für einen bestimmten Typ zurückzukehren s.

s << pretty::clear<std::vector<int>>();

5. Weitere Beispiele

Drucken "matrixartig" mit Zeilenumbruch

std::vector<std::vector<int>> m{ {1,2,3}, {4,5,6}, {7,8,9} };
std::cout << pretty::decoration<std::vector<std::vector<int>>>("\n");
std::cout << m;

Druckt

1, 2, 3
4, 5, 6
7, 8, 9

Sehen Sie es auf ideone / KKUebZ

6. Code

#ifndef pretty_print_0x57547_sa4884X_0_1_h_guard_
#define pretty_print_0x57547_sa4884X_0_1_h_guard_

#include <string>
#include <iostream>
#include <type_traits>
#include <iterator>
#include <utility>

#define PRETTY_DEFAULT_DECORATION(TYPE, PREFIX, DELIM, POSTFIX, ...) \
    namespace pretty { template< __VA_ARGS__ >\
    struct defaulted< TYPE > {\
    static decor< TYPE > decoration(){\
      return { PREFIX, DELIM, POSTFIX };\
    } /*decoration*/ }; /*defaulted*/} /*pretty*/

#define PRETTY_DEFAULT_WDECORATION(TYPE, PREFIX, DELIM, POSTFIX, ...) \
    namespace pretty { template< __VA_ARGS__ >\
    struct defaulted< TYPE, wchar_t, std::char_traits<wchar_t> > {\
    static decor< TYPE, wchar_t, std::char_traits<wchar_t> > decoration(){\
      return { PREFIX, DELIM, POSTFIX };\
    } /*decoration*/ }; /*defaulted*/} /*pretty*/

namespace pretty
{

  namespace detail
  {
    // drag in begin and end overloads
    using std::begin;
    using std::end;
    // helper template
    template <int I> using _ol = std::integral_constant<int, I>*;
    // SFINAE check whether T is a range with begin/end
    template<class T>
    class is_range
    {
      // helper function declarations using expression sfinae
      template <class U, _ol<0> = nullptr>
      static std::false_type b(...);
      template <class U, _ol<1> = nullptr>
      static auto b(U &v) -> decltype(begin(v), std::true_type());
      template <class U, _ol<0> = nullptr>
      static std::false_type e(...);
      template <class U, _ol<1> = nullptr>
      static auto e(U &v) -> decltype(end(v), std::true_type());
      // return types
      using b_return = decltype(b<T>(std::declval<T&>()));
      using e_return = decltype(e<T>(std::declval<T&>()));
    public:
      static const bool value = b_return::value && e_return::value;
    };
  }

  // holder class for data
  template<class T, class CharT = char, class TraitT = std::char_traits<CharT>>
  struct decor
  {
    static const int xindex;
    std::basic_string<CharT, TraitT> prefix, delimiter, postfix;
    decor(std::basic_string<CharT, TraitT> const & pre = "",
      std::basic_string<CharT, TraitT> const & delim = "",
      std::basic_string<CharT, TraitT> const & post = "")
      : prefix(pre), delimiter(delim), postfix(post) {}
  };

  template<class T, class charT, class traits>
  int const decor<T, charT, traits>::xindex = std::ios_base::xalloc();

  namespace detail
  {

    template<class T, class CharT, class TraitT>
    void manage_decor(std::ios_base::event evt, std::ios_base &s, int const idx)
    {
      using deco_type = decor<T, CharT, TraitT>;
      if (evt == std::ios_base::erase_event)
      { // erase deco
        void const * const p = s.pword(idx);
        if (p)
        {
          delete static_cast<deco_type const * const>(p);
          s.pword(idx) = nullptr;
        }
      }
      else if (evt == std::ios_base::copyfmt_event)
      { // copy deco
        void const * const p = s.pword(idx);
        if (p)
        {
          auto np = new deco_type{ *static_cast<deco_type const * const>(p) };
          s.pword(idx) = static_cast<void*>(np);
        }
      }
    }

    template<class T> struct clearer {};

    template<class T, class CharT, class TraitT>
    std::basic_ostream<CharT, TraitT>& operator<< (
      std::basic_ostream<CharT, TraitT> &s, clearer<T> const &)
    {
      using deco_type = decor<T, CharT, TraitT>;
      void const * const p = s.pword(deco_type::xindex);
      if (p)
      { // delete if set
        delete static_cast<deco_type const *>(p);
        s.pword(deco_type::xindex) = nullptr;
      }
      return s;
    }

    template <class CharT> 
    struct default_data { static const CharT * decor[3]; };
    template <> 
    const char * default_data<char>::decor[3] = { "", ", ", "" };
    template <> 
    const wchar_t * default_data<wchar_t>::decor[3] = { L"", L", ", L"" };

  }

  // Clear decoration for T
  template<class T>
  detail::clearer<T> clear() { return{}; }
  template<class T, class CharT, class TraitT>
  void clear(std::basic_ostream<CharT, TraitT> &s) { s << detail::clearer<T>{}; }

  // impose decoration on ostream
  template<class T, class CharT, class TraitT>
  std::basic_ostream<CharT, TraitT>& operator<<(
    std::basic_ostream<CharT, TraitT> &s, decor<T, CharT, TraitT> && h)
  {
    using deco_type = decor<T, CharT, TraitT>;
    void const * const p = s.pword(deco_type::xindex);
    // delete if already set
    if (p) delete static_cast<deco_type const *>(p);
    s.pword(deco_type::xindex) = static_cast<void *>(new deco_type{ std::move(h) });
    // check whether we alread have a callback registered
    if (s.iword(deco_type::xindex) == 0)
    { // if this is not the case register callback and set iword
      s.register_callback(detail::manage_decor<T, CharT, TraitT>, deco_type::xindex);
      s.iword(deco_type::xindex) = 1;
    }
    return s;
  }

  template<class T, class CharT = char, class TraitT = std::char_traits<CharT>>
  struct defaulted
  {
    static inline decor<T, CharT, TraitT> decoration()
    {
      return{ detail::default_data<CharT>::decor[0],
        detail::default_data<CharT>::decor[1],
        detail::default_data<CharT>::decor[2] };
    }
  };

  template<class T, class CharT = char, class TraitT = std::char_traits<CharT>>
  decor<T, CharT, TraitT> decoration(
    std::basic_string<CharT, TraitT> const & prefix,
    std::basic_string<CharT, TraitT> const & delimiter,
    std::basic_string<CharT, TraitT> const & postfix)
  {
    return{ prefix, delimiter, postfix };
  }

  template<class T, class CharT = char,
  class TraitT = std::char_traits < CharT >>
    decor<T, CharT, TraitT> decoration(
      std::basic_string<CharT, TraitT> const & delimiter)
  {
    using str_type = std::basic_string<CharT, TraitT>;
    return{ defaulted<T, CharT, TraitT>::decoration().prefix,
      delimiter, defaulted<T, CharT, TraitT>::decoration().postfix };
  }

  template<class T, class CharT = char,
  class TraitT = std::char_traits < CharT >>
    decor<T, CharT, TraitT> decoration(CharT const * const prefix,
      CharT const * const delimiter, CharT const * const postfix)
  {
    using str_type = std::basic_string<CharT, TraitT>;
    return{ str_type{ prefix }, str_type{ delimiter }, str_type{ postfix } };
  }

  template<class T, class CharT = char,
  class TraitT = std::char_traits < CharT >>
    decor<T, CharT, TraitT> decoration(CharT const * const delimiter)
  {
    using str_type = std::basic_string<CharT, TraitT>;
    return{ defaulted<T, CharT, TraitT>::decoration().prefix,
      str_type{ delimiter }, defaulted<T, CharT, TraitT>::decoration().postfix };
  }

  template<typename T, std::size_t N, std::size_t L>
  struct tuple
  {
    template<class CharT, class TraitT>
    static void print(std::basic_ostream<CharT, TraitT>& s, T const & value,
      std::basic_string<CharT, TraitT> const &delimiter)
    {
      s << std::get<N>(value) << delimiter;
      tuple<T, N + 1, L>::print(s, value, delimiter);
    }
  };

  template<typename T, std::size_t N>
  struct tuple<T, N, N>
  {
    template<class CharT, class TraitT>
    static void print(std::basic_ostream<CharT, TraitT>& s, T const & value,
      std::basic_string<CharT, TraitT> const &) {
      s << std::get<N>(value);
    }
  };

}

template<class CharT, class TraitT>
std::basic_ostream<CharT, TraitT> & operator<< (
  std::basic_ostream<CharT, TraitT> &s, std::tuple<> const & v)
{
  using deco_type = pretty::decor<std::tuple<void*>, CharT, TraitT>;
  using defaulted_type = pretty::defaulted<std::tuple<void*>, CharT, TraitT>;
  void const * const p = s.pword(deco_type::xindex);
  auto const d = static_cast<deco_type const * const>(p);
  s << (d ? d->prefix : defaulted_type::decoration().prefix);
  s << (d ? d->postfix : defaulted_type::decoration().postfix);
  return s;
}

template<class CharT, class TraitT, class ... T>
std::basic_ostream<CharT, TraitT> & operator<< (
  std::basic_ostream<CharT, TraitT> &s, std::tuple<T...> const & v)
{
  using deco_type = pretty::decor<std::tuple<void*>, CharT, TraitT>;
  using defaulted_type = pretty::defaulted<std::tuple<void*>, CharT, TraitT>;
  using pretty_tuple = pretty::tuple<std::tuple<T...>, 0U, sizeof...(T)-1U>;
  void const * const p = s.pword(deco_type::xindex);
  auto const d = static_cast<deco_type const * const>(p);
  s << (d ? d->prefix : defaulted_type::decoration().prefix);
  pretty_tuple::print(s, v, d ? d->delimiter : 
    defaulted_type::decoration().delimiter);
  s << (d ? d->postfix : defaulted_type::decoration().postfix);
  return s;
}

template<class T, class U, class CharT, class TraitT>
std::basic_ostream<CharT, TraitT> & operator<< (
  std::basic_ostream<CharT, TraitT> &s, std::pair<T, U> const & v)
{
  using deco_type = pretty::decor<std::pair<T, U>, CharT, TraitT>;
  using defaulted_type = pretty::defaulted<std::pair<T, U>, CharT, TraitT>;
  void const * const p = s.pword(deco_type::xindex);
  auto const d = static_cast<deco_type const * const>(p);
  s << (d ? d->prefix : defaulted_type::decoration().prefix);
  s << v.first;
  s << (d ? d->delimiter : defaulted_type::decoration().delimiter);
  s << v.second;
  s << (d ? d->postfix : defaulted_type::decoration().postfix);
  return s;
}


template<class T, class CharT = char,
class TraitT = std::char_traits < CharT >>
  typename std::enable_if < pretty::detail::is_range<T>::value,
  std::basic_ostream < CharT, TraitT >> ::type & operator<< (
    std::basic_ostream<CharT, TraitT> &s, T const & v)
{
  bool first(true);
  using deco_type = pretty::decor<T, CharT, TraitT>;
  using default_type = pretty::defaulted<T, CharT, TraitT>;
  void const * const p = s.pword(deco_type::xindex);
  auto d = static_cast<pretty::decor<T, CharT, TraitT> const * const>(p);
  s << (d ? d->prefix : default_type::decoration().prefix);
  for (auto const & e : v)
  { // v is range thus range based for works
    if (!first) s << (d ? d->delimiter : default_type::decoration().delimiter);
    s << e;
    first = false;
  }
  s << (d ? d->postfix : default_type::decoration().postfix);
  return s;
}

#endif // pretty_print_0x57547_sa4884X_0_1_h_guard_
Pixelchemist
quelle
4

Ich werde hier eine weitere Antwort hinzufügen, da ich einen anderen Ansatz als meinen vorherigen entwickelt habe, nämlich die Verwendung von Gebietsschema-Facetten.

Die Grundlagen sind hier

Im Wesentlichen tun Sie Folgendes:

  1. Erstellen Sie eine Klasse, die von abgeleitet ist std::locale::facet. Der kleine Nachteil ist, dass Sie irgendwo eine Kompilierungseinheit benötigen, um ihre ID zu speichern. Nennen wir es MyPrettyVectorPrinter. Sie würden ihm wahrscheinlich einen besseren Namen geben und auch einen für Paar und Karte erstellen.
  2. In Ihrer Stream-Funktion überprüfen Sie std::has_facet< MyPrettyVectorPrinter >
  3. Wenn dies true zurückgibt, extrahieren Sie es mit std::use_facet< MyPrettyVectorPrinter >( os.getloc() )
  4. Ihre Facettenobjekte haben Werte für die Begrenzer und Sie können sie lesen. Wenn die Facette nicht gefunden wird, operator<<bietet Ihre Druckfunktion ( ) Standardfunktionen. Beachten Sie, dass Sie beim Lesen eines Vektors dasselbe tun können.

Ich mag diese Methode, weil Sie einen Standarddruck verwenden können, während Sie dennoch eine benutzerdefinierte Überschreibung verwenden können.

Die Nachteile sind eine Bibliothek für Ihre Facette, wenn sie in mehreren Projekten verwendet wird (also nicht nur Header) und die Tatsache, dass Sie sich vor den Kosten für die Erstellung eines neuen Gebietsschemaobjekts hüten müssen.

Ich habe dies als neue Lösung geschrieben, anstatt meine andere zu modifizieren, da ich glaube, dass beide Ansätze korrekt sein können und Sie Ihre Wahl treffen.

Goldesel
quelle
Lassen Sie mich das klarstellen: Muss ich bei diesem Ansatz jeden Containertyp, den ich verwenden möchte, aktiv auf die Whitelist setzen?
Kerrek SB
Nun, eigentlich sollte man std nicht anders als für die eigenen Typen erweitern, aber Sie schreiben eine Überladung des Operators << für jeden Containertyp (Vektor, Karte, Liste, Deque) plus Paar, das Sie drucken möchten. Natürlich können einige eine Facette gemeinsam haben (z. B. möchten Sie vielleicht trotzdem Liste, Vektor und Deque drucken). Sie stellen eine "Standard" -Druckmethode bereit, ermöglichen es Benutzern jedoch, vor dem Drucken eine Facette und ein Gebietsschema zu erstellen und zu durchdringen. Ein bisschen wie die Art und Weise, wie Boost ihre date_time druckt. Sie können ihre Facette auch in das globale Gebietsschema laden, um auf diese Weise standardmäßig zu drucken.
CashCow
2

Das Ziel hier ist es, ADL zu verwenden, um die Art und Weise anzupassen, wie wir hübsch drucken.

Sie übergeben ein Formatierungs-Tag und überschreiben 4 Funktionen (vor, nach, zwischen und absteigend) im Namespace des Tags. Dies ändert, wie der Formatierer beim Durchlaufen von Containern "Verzierungen" druckt.

Ein Standardformatierer {(a->b),(c->d)}für Karten, (a,b,c)Tupleoide und "hello"Zeichenfolgen.[x,y,z] alles andere.

Es sollte "nur mit iterierbaren Typen von Drittanbietern funktionieren" (und sie wie "alles andere" behandeln).

Wenn Sie benutzerdefinierte Verzierungen für Ihre Iterables von Drittanbietern wünschen, erstellen Sie einfach Ihr eigenes Tag. Es wird ein wenig Arbeit erfordern, um den Kartenabstieg zu handhaben (Sie müssen überladen, pretty_print_descend( your_tagum zurückzukehrenpretty_print::decorator::map_magic_tag<your_tag> ). Vielleicht gibt es einen saubereren Weg, nicht sicher.

Eine kleine Bibliothek zum Erkennen von Iterierbarkeit und Tupelhaftigkeit:

namespace details {
  using std::begin; using std::end;
  template<class T, class=void>
  struct is_iterable_test:std::false_type{};
  template<class T>
  struct is_iterable_test<T,
    decltype((void)(
      (void)(begin(std::declval<T>())==end(std::declval<T>()))
      , ((void)(std::next(begin(std::declval<T>()))))
      , ((void)(*begin(std::declval<T>())))
      , 1
    ))
  >:std::true_type{};
  template<class T>struct is_tupleoid:std::false_type{};
  template<class...Ts>struct is_tupleoid<std::tuple<Ts...>>:std::true_type{};
  template<class...Ts>struct is_tupleoid<std::pair<Ts...>>:std::true_type{};
  // template<class T, size_t N>struct is_tupleoid<std::array<T,N>>:std::true_type{}; // complete, but problematic
}
template<class T>struct is_iterable:details::is_iterable_test<std::decay_t<T>>{};
template<class T, std::size_t N>struct is_iterable<T(&)[N]>:std::true_type{}; // bypass decay
template<class T>struct is_tupleoid:details::is_tupleoid<std::decay_t<T>>{};

template<class T>struct is_visitable:std::integral_constant<bool, is_iterable<T>{}||is_tupleoid<T>{}> {};

Eine Bibliothek, mit der wir den Inhalt eines iterierbaren Objekts oder eines Objekts vom Typ Tupel besuchen können:

template<class C, class F>
std::enable_if_t<is_iterable<C>{}> visit_first(C&& c, F&& f) {
  using std::begin; using std::end;
  auto&& b = begin(c);
  auto&& e = end(c);
  if (b==e)
      return;
  std::forward<F>(f)(*b);
}
template<class C, class F>
std::enable_if_t<is_iterable<C>{}> visit_all_but_first(C&& c, F&& f) {
  using std::begin; using std::end;
  auto it = begin(c);
  auto&& e = end(c);
  if (it==e)
      return;
  it = std::next(it);
  for( ; it!=e; it = std::next(it) ) {
    f(*it);
  }
}

namespace details {
  template<class Tup, class F>
  void visit_first( std::index_sequence<>, Tup&&, F&& ) {}
  template<size_t... Is, class Tup, class F>
  void visit_first( std::index_sequence<0,Is...>, Tup&& tup, F&& f ) {
    std::forward<F>(f)( std::get<0>( std::forward<Tup>(tup) ) );
  }
  template<class Tup, class F>
  void visit_all_but_first( std::index_sequence<>, Tup&&, F&& ) {}
  template<size_t... Is,class Tup, class F>
  void visit_all_but_first( std::index_sequence<0,Is...>, Tup&& tup, F&& f ) {
    int unused[] = {0,((void)(
      f( std::get<Is>(std::forward<Tup>(tup)) )
    ),0)...};
    (void)(unused);
  }
}
template<class Tup, class F>
std::enable_if_t<is_tupleoid<Tup>{}> visit_first(Tup&& tup, F&& f) {
  details::visit_first( std::make_index_sequence< std::tuple_size<std::decay_t<Tup>>{} >{}, std::forward<Tup>(tup), std::forward<F>(f) );
}
template<class Tup, class F>
std::enable_if_t<is_tupleoid<Tup>{}> visit_all_but_first(Tup&& tup, F&& f) {
  details::visit_all_but_first( std::make_index_sequence< std::tuple_size<std::decay_t<Tup>>{} >{}, std::forward<Tup>(tup), std::forward<F>(f) );
}

Eine hübsche Druckbibliothek:

namespace pretty_print {
  namespace decorator {
    struct default_tag {};
    template<class Old>
    struct map_magic_tag:Old {}; // magic for maps

    // Maps get {}s. Write trait `is_associative` to generalize:
    template<class CharT, class Traits, class...Xs >
    void pretty_print_before( default_tag, std::basic_ostream<CharT, Traits>& s, std::map<Xs...> const& ) {
      s << CharT('{');
    }

    template<class CharT, class Traits, class...Xs >
    void pretty_print_after( default_tag, std::basic_ostream<CharT, Traits>& s, std::map<Xs...> const& ) {
      s << CharT('}');
    }

    // tuples and pairs get ():
    template<class CharT, class Traits, class Tup >
    std::enable_if_t<is_tupleoid<Tup>{}> pretty_print_before( default_tag, std::basic_ostream<CharT, Traits>& s, Tup const& ) {
      s << CharT('(');
    }

    template<class CharT, class Traits, class Tup >
    std::enable_if_t<is_tupleoid<Tup>{}> pretty_print_after( default_tag, std::basic_ostream<CharT, Traits>& s, Tup const& ) {
      s << CharT(')');
    }

    // strings with the same character type get ""s:
    template<class CharT, class Traits, class...Xs >
    void pretty_print_before( default_tag, std::basic_ostream<CharT, Traits>& s, std::basic_string<CharT, Xs...> const& ) {
      s << CharT('"');
    }
    template<class CharT, class Traits, class...Xs >
    void pretty_print_after( default_tag, std::basic_ostream<CharT, Traits>& s, std::basic_string<CharT, Xs...> const& ) {
      s << CharT('"');
    }
    // and pack the characters together:
    template<class CharT, class Traits, class...Xs >
    void pretty_print_between( default_tag, std::basic_ostream<CharT, Traits>&, std::basic_string<CharT, Xs...> const& ) {}

    // map magic. When iterating over the contents of a map, use the map_magic_tag:
    template<class...Xs>
    map_magic_tag<default_tag> pretty_print_descend( default_tag, std::map<Xs...> const& ) {
      return {};
    }
    template<class old_tag, class C>
    old_tag pretty_print_descend( map_magic_tag<old_tag>, C const& ) {
      return {};
    }

    // When printing a pair immediately within a map, use -> as a separator:
    template<class old_tag, class CharT, class Traits, class...Xs >
    void pretty_print_between( map_magic_tag<old_tag>, std::basic_ostream<CharT, Traits>& s, std::pair<Xs...> const& ) {
      s << CharT('-') << CharT('>');
    }
  }

  // default behavior:
  template<class CharT, class Traits, class Tag, class Container >
  void pretty_print_before( Tag const&, std::basic_ostream<CharT, Traits>& s, Container const& ) {
    s << CharT('[');
  }
  template<class CharT, class Traits, class Tag, class Container >
  void pretty_print_after( Tag const&, std::basic_ostream<CharT, Traits>& s, Container const& ) {
    s << CharT(']');
  }
  template<class CharT, class Traits, class Tag, class Container >
  void pretty_print_between( Tag const&, std::basic_ostream<CharT, Traits>& s, Container const& ) {
    s << CharT(',');
  }
  template<class Tag, class Container>
  Tag&& pretty_print_descend( Tag&& tag, Container const& ) {
    return std::forward<Tag>(tag);
  }

  // print things by default by using <<:
  template<class Tag=decorator::default_tag, class Scalar, class CharT, class Traits>
  std::enable_if_t<!is_visitable<Scalar>{}> print( std::basic_ostream<CharT, Traits>& os, Scalar&& scalar, Tag&&=Tag{} ) {
    os << std::forward<Scalar>(scalar);
  }
  // for anything visitable (see above), use the pretty print algorithm:
  template<class Tag=decorator::default_tag, class C, class CharT, class Traits>
  std::enable_if_t<is_visitable<C>{}> print( std::basic_ostream<CharT, Traits>& os, C&& c, Tag&& tag=Tag{} ) {
    pretty_print_before( std::forward<Tag>(tag), os, std::forward<C>(c) );
    visit_first( c, [&](auto&& elem) {
      print( os, std::forward<decltype(elem)>(elem), pretty_print_descend( std::forward<Tag>(tag), std::forward<C>(c) ) );
    });
    visit_all_but_first( c, [&](auto&& elem) {
      pretty_print_between( std::forward<Tag>(tag), os, std::forward<C>(c) );
      print( os, std::forward<decltype(elem)>(elem), pretty_print_descend( std::forward<Tag>(tag), std::forward<C>(c) ) );
    });
    pretty_print_after( std::forward<Tag>(tag), os, std::forward<C>(c) );
  }
}

Testcode:

int main() {
  std::vector<int> x = {1,2,3};

  pretty_print::print( std::cout, x );
  std::cout << "\n";

  std::map< std::string, int > m;
  m["hello"] = 3;
  m["world"] = 42;

  pretty_print::print( std::cout, m );
  std::cout << "\n";
}

Live-Beispiel

Dies verwendet zwar C ++ 14-Funktionen (einige _tAliase und auto&&Lambdas), aber keine sind wesentlich.

Yakk - Adam Nevraumont
quelle
@ KerrekSB Arbeitsversion, mit einigen Änderungen. Der Großteil des Codes besteht aus allgemeinen "Besuchstupeln / Iterablen" und ausgefallenen Formatierungen (einschließlich ->der pairs von maps) an dieser Stelle. Der Kern der hübschen Druckbibliothek ist schön klein, was sehr schön ist. Ich habe versucht, es leicht erweiterbar zu machen, nicht sicher, ob es mir gelungen ist.
Yakk - Adam Nevraumont
1

Meine Lösung ist simple.h , die Teil des scc- Pakets ist. Alle Standardcontainer, Karten, Sets und C-Arrays können gedruckt werden.

Leonid Volnitsky
quelle
Interessant. Ich mag den Template-of-Template-Ansatz für Container, aber funktioniert er für benutzerdefinierte Container und STL-Container mit nicht standardmäßigen Prädikaten oder Allokatoren? (Ich habe etwas Ähnliches getan, um zu versuchen, eine Bimap in C ++ 0x mithilfe verschiedener Vorlagen zu implementieren .) Außerdem scheinen Sie Iteratoren nicht generisch für Ihre Druckroutinen zu verwenden. warum die explizite Verwendung eines Zählers i?
Kerrek SB
Was ist ein Container mit nicht standardmäßigen Prädikaten? Benutzerdefinierte Container, die mit der Signatur übereinstimmen, werden gedruckt. Nicht-Standard-Allokatoren werden derzeit nicht unterstützt, sind jedoch leicht zu beheben. Ich brauche das jetzt einfach nicht.
Leonid Volnitsky
Es gibt keinen guten Grund, Index anstelle von Iteratoren zu verwenden. Historische Gründe. Wird es reparieren, wenn ich Zeit habe.
Leonid Volnitsky
Mit "Container mit nicht standardmäßigen Prädikaten" meine ich so etwas wie einen std::setmit einem benutzerdefinierten Komparator oder eine ungeordnete Karte mit einer benutzerdefinierten Gleichheit. Es wäre sehr wichtig, diese Konstruktionen zu unterstützen.
Kerrek SB
1

Als ich aus einer der ersten BoostCon (jetzt CppCon) herauskam, arbeiteten ich und zwei andere an einer Bibliothek, um genau dies zu tun. Der Hauptknackpunkt war die Erweiterung des Namespace std. Das stellte sich als No-Go für eine Boost-Bibliothek heraus.

Leider funktionieren die Links zum Code nicht mehr, aber in den Diskussionen finden Sie möglicherweise einige interessante Details (zumindest diejenigen, die nicht darüber sprechen, wie sie heißen sollen!).

http://boost.2283326.n4.nabble.com/explore-Library-Proposal-Container-Streaming-td2619544.html

Jeffrey Faust
quelle
0

Hier ist meine Version der Implementierung aus dem Jahr 2016

Alles in einem Header, daher ist es einfach, https://github.com/skident/eos/blob/master/include/eos/io/print.hpp zu verwenden

/*! \file       print.hpp
 *  \brief      Useful functions for work with STL containers. 
 *          
 *  Now it supports generic print for STL containers like: [elem1, elem2, elem3]
 *  Supported STL conrainers: vector, deque, list, set multiset, unordered_set,
 *  map, multimap, unordered_map, array
 *
 *  \author     Skident
 *  \date       02.09.2016
 *  \copyright  Skident Inc.
 */

#pragma once

// check is the C++11 or greater available (special hack for MSVC)
#if (defined(_MSC_VER) && __cplusplus >= 199711L) || __cplusplus >= 201103L
    #define MODERN_CPP_AVAILABLE 1
#endif


#include <iostream>
#include <sstream>
#include <vector>
#include <deque>
#include <set>
#include <list>
#include <map>
#include <cctype>

#ifdef MODERN_CPP_AVAILABLE
    #include <array>
    #include <unordered_set>
    #include <unordered_map>
    #include <forward_list>
#endif


#define dump(value) std::cout << (#value) << ": " << (value) << std::endl

#define BUILD_CONTENT                                                       \
        std::stringstream ss;                                               \
        for (; it != collection.end(); ++it)                                \
        {                                                                   \
            ss << *it << elem_separator;                                    \
        }                                                                   \


#define BUILD_MAP_CONTENT                                                   \
        std::stringstream ss;                                               \
        for (; it != collection.end(); ++it)                                \
        {                                                                   \
            ss  << it->first                                                \
                << keyval_separator                                         \
                << it->second                                               \
                << elem_separator;                                          \
        }                                                                   \


#define COMPILE_CONTENT                                                     \
        std::string data = ss.str();                                        \
        if (!data.empty() && !elem_separator.empty())                       \
            data = data.substr(0, data.rfind(elem_separator));              \
        std::string result = first_bracket + data + last_bracket;           \
        os << result;                                                       \
        if (needEndl)                                                       \
            os << std::endl;                                                \



////
///
///
/// Template definitions
///
///

//generic template for classes: deque, list, forward_list, vector
#define VECTOR_AND_CO_TEMPLATE                                          \
    template<                                                           \
        template<class T,                                               \
                 class Alloc = std::allocator<T> >                      \
        class Container, class Type, class Alloc>                       \

#define SET_TEMPLATE                                                    \
    template<                                                           \
        template<class T,                                               \
                 class Compare = std::less<T>,                          \
                 class Alloc = std::allocator<T> >                      \
            class Container, class T, class Compare, class Alloc>       \

#define USET_TEMPLATE                                                   \
    template<                                                           \
template < class Key,                                                   \
           class Hash = std::hash<Key>,                                 \
           class Pred = std::equal_to<Key>,                             \
           class Alloc = std::allocator<Key>                            \
           >                                                            \
    class Container, class Key, class Hash, class Pred, class Alloc     \
    >                                                                   \


#define MAP_TEMPLATE                                                    \
    template<                                                           \
        template<class Key,                                             \
                class T,                                                \
                class Compare = std::less<Key>,                         \
                class Alloc = std::allocator<std::pair<const Key,T> >   \
                >                                                       \
        class Container, class Key,                                     \
        class Value/*, class Compare, class Alloc*/>                    \


#define UMAP_TEMPLATE                                                   \
    template<                                                           \
        template<class Key,                                             \
                   class T,                                             \
                   class Hash = std::hash<Key>,                         \
                   class Pred = std::equal_to<Key>,                     \
                   class Alloc = std::allocator<std::pair<const Key,T> >\
                 >                                                      \
        class Container, class Key, class Value,                        \
        class Hash, class Pred, class Alloc                             \
                >                                                       \


#define ARRAY_TEMPLATE                                                  \
    template<                                                           \
        template<class T, std::size_t N>                                \
        class Array, class Type, std::size_t Size>                      \



namespace eos
{
    static const std::string default_elem_separator     = ", ";
    static const std::string default_keyval_separator   = " => ";
    static const std::string default_first_bracket      = "[";
    static const std::string default_last_bracket       = "]";


    //! Prints template Container<T> as in Python
    //! Supported containers: vector, deque, list, set, unordered_set(C++11), forward_list(C++11)
    //! \param collection which should be printed
    //! \param elem_separator the separator which will be inserted between elements of collection
    //! \param first_bracket data before collection's elements (usual it is the parenthesis, square or curly bracker '(', '[', '{')
    //! \param last_bracket data after collection's elements (usual it is the parenthesis, square or curly bracker ')', ']', '}')
    template<class Container>
    void print( const Container& collection
              , const std::string& elem_separator   = default_elem_separator
              , const std::string& first_bracket    = default_first_bracket
              , const std::string& last_bracket     = default_last_bracket
              , std::ostream& os = std::cout
              , bool needEndl = true
            )
    {
        typename Container::const_iterator it = collection.begin();
        BUILD_CONTENT
        COMPILE_CONTENT
    }


    //! Prints collections with one template argument and allocator as in Python.
    //! Supported standard collections: vector, deque, list, forward_list
    //! \param collection which should be printed
    //! \param elem_separator the separator which will be inserted between elements of collection
    //! \param keyval_separator separator between key and value of map. For default it is the '=>'
    //! \param first_bracket data before collection's elements (usual it is the parenthesis, square or curly bracker '(', '[', '{')
    //! \param last_bracket data after collection's elements (usual it is the parenthesis, square or curly bracker ')', ']', '}')
    VECTOR_AND_CO_TEMPLATE
    void print( const Container<Type>& collection
              , const std::string& elem_separator   = default_elem_separator
              , const std::string& first_bracket    = default_first_bracket
              , const std::string& last_bracket     = default_last_bracket
              , std::ostream& os = std::cout
              , bool needEndl = true
            )
    {
        typename Container<Type>::const_iterator it = collection.begin();
        BUILD_CONTENT
        COMPILE_CONTENT
    }


    //! Prints collections like std:set<T, Compare, Alloc> as in Python
    //! \param collection which should be printed
    //! \param elem_separator the separator which will be inserted between elements of collection
    //! \param keyval_separator separator between key and value of map. For default it is the '=>'
    //! \param first_bracket data before collection's elements (usual it is the parenthesis, square or curly bracker '(', '[', '{')
    //! \param last_bracket data after collection's elements (usual it is the parenthesis, square or curly bracker ')', ']', '}')
    SET_TEMPLATE
    void print( const Container<T, Compare, Alloc>& collection
              , const std::string& elem_separator   = default_elem_separator
              , const std::string& first_bracket    = default_first_bracket
              , const std::string& last_bracket     = default_last_bracket
              , std::ostream& os = std::cout
              , bool needEndl = true
            )
    {
        typename Container<T, Compare, Alloc>::const_iterator it = collection.begin();
        BUILD_CONTENT
        COMPILE_CONTENT
    }


    //! Prints collections like std:unordered_set<Key, Hash, Pred, Alloc> as in Python
    //! \param collection which should be printed
    //! \param elem_separator the separator which will be inserted between elements of collection
    //! \param keyval_separator separator between key and value of map. For default it is the '=>'
    //! \param first_bracket data before collection's elements (usual it is the parenthesis, square or curly bracker '(', '[', '{')
    //! \param last_bracket data after collection's elements (usual it is the parenthesis, square or curly bracker ')', ']', '}')
    USET_TEMPLATE
    void print( const Container<Key, Hash, Pred, Alloc>& collection
              , const std::string& elem_separator   = default_elem_separator
              , const std::string& first_bracket    = default_first_bracket
              , const std::string& last_bracket     = default_last_bracket
              , std::ostream& os = std::cout
              , bool needEndl = true
            )
    {
        typename Container<Key, Hash, Pred, Alloc>::const_iterator it = collection.begin();
        BUILD_CONTENT
        COMPILE_CONTENT
    }

    //! Prints collections like std:map<T, U> as in Python
    //! supports generic objects of std: map, multimap
    //! \param collection which should be printed
    //! \param elem_separator the separator which will be inserted between elements of collection
    //! \param keyval_separator separator between key and value of map. For default it is the '=>'
    //! \param first_bracket data before collection's elements (usual it is the parenthesis, square or curly bracker '(', '[', '{')
    //! \param last_bracket data after collection's elements (usual it is the parenthesis, square or curly bracker ')', ']', '}')
    MAP_TEMPLATE
    void print(   const Container<Key, Value>& collection
                , const std::string& elem_separator   = default_elem_separator
                , const std::string& keyval_separator = default_keyval_separator
                , const std::string& first_bracket    = default_first_bracket
                , const std::string& last_bracket     = default_last_bracket
                , std::ostream& os = std::cout
                , bool needEndl = true
        )
    {
        typename Container<Key, Value>::const_iterator it = collection.begin();
        BUILD_MAP_CONTENT
        COMPILE_CONTENT
    }

    //! Prints classes like std:unordered_map as in Python
    //! \param collection which should be printed
    //! \param elem_separator the separator which will be inserted between elements of collection
    //! \param keyval_separator separator between key and value of map. For default it is the '=>'
    //! \param first_bracket data before collection's elements (usual it is the parenthesis, square or curly bracker '(', '[', '{')
    //! \param last_bracket data after collection's elements (usual it is the parenthesis, square or curly bracker ')', ']', '}')
    UMAP_TEMPLATE
    void print(   const Container<Key, Value, Hash, Pred, Alloc>& collection
                , const std::string& elem_separator   = default_elem_separator
                , const std::string& keyval_separator = default_keyval_separator
                , const std::string& first_bracket    = default_first_bracket
                , const std::string& last_bracket     = default_last_bracket
                , std::ostream& os = std::cout
                , bool needEndl = true
        )
    {
        typename Container<Key, Value, Hash, Pred, Alloc>::const_iterator it = collection.begin();
        BUILD_MAP_CONTENT
        COMPILE_CONTENT
    }

    //! Prints collections like std:array<T, Size> as in Python
    //! \param collection which should be printed
    //! \param elem_separator the separator which will be inserted between elements of collection
    //! \param keyval_separator separator between key and value of map. For default it is the '=>'
    //! \param first_bracket data before collection's elements (usual it is the parenthesis, square or curly bracker '(', '[', '{')
    //! \param last_bracket data after collection's elements (usual it is the parenthesis, square or curly bracker ')', ']', '}')
    ARRAY_TEMPLATE
    void print(   const Array<Type, Size>& collection
                , const std::string& elem_separator   = default_elem_separator
                , const std::string& first_bracket    = default_first_bracket
                , const std::string& last_bracket     = default_last_bracket
                , std::ostream& os = std::cout
                , bool needEndl = true
            )
    {
        typename Array<Type, Size>::const_iterator it = collection.begin();
        BUILD_CONTENT
        COMPILE_CONTENT
    }

    //! Removes all whitespaces before data in string.
    //! \param str string with data
    //! \return string without whitespaces in left part
    std::string ltrim(const std::string& str);

    //! Removes all whitespaces after data in string
    //! \param str string with data
    //! \return string without whitespaces in right part
    std::string rtrim(const std::string& str);

    //! Removes all whitespaces before and after data in string
    //! \param str string with data
    //! \return string without whitespaces before and after data in string
    std::string trim(const std::string& str);



    ////////////////////////////////////////////////////////////
    ////////////////////////ostream logic//////////////////////
    /// Should be specified for concrete containers
    /// because of another types can be suitable
    /// for templates, for example templates break
    /// the code like this "cout << string("hello") << endl;"
    ////////////////////////////////////////////////////////////



#define PROCESS_VALUE_COLLECTION(os, collection)                            \
    print(  collection,                                                     \
            default_elem_separator,                                         \
            default_first_bracket,                                          \
            default_last_bracket,                                           \
            os,                                                             \
            false                                                           \
    );                                                                      \

#define PROCESS_KEY_VALUE_COLLECTION(os, collection)                        \
    print(  collection,                                                     \
            default_elem_separator,                                         \
            default_keyval_separator,                                       \
            default_first_bracket,                                          \
            default_last_bracket,                                           \
            os,                                                             \
            false                                                           \
    );                                                                      \

    ///< specialization for vector
    template<class T>
    std::ostream& operator<<(std::ostream& os, const std::vector<T>& collection)
    {
        PROCESS_VALUE_COLLECTION(os, collection)
        return os;
    }

    ///< specialization for deque
    template<class T>
    std::ostream& operator<<(std::ostream& os, const std::deque<T>& collection)
    {
        PROCESS_VALUE_COLLECTION(os, collection)
        return os;
    }

    ///< specialization for list
    template<class T>
    std::ostream& operator<<(std::ostream& os, const std::list<T>& collection)
    {
        PROCESS_VALUE_COLLECTION(os, collection)
        return os;
    }

    ///< specialization for set
    template<class T>
    std::ostream& operator<<(std::ostream& os, const std::set<T>& collection)
    {
        PROCESS_VALUE_COLLECTION(os, collection)
        return os;
    }

    ///< specialization for multiset
    template<class T>
    std::ostream& operator<<(std::ostream& os, const std::multiset<T>& collection)
    {
        PROCESS_VALUE_COLLECTION(os, collection)
        return os;
    }

#ifdef MODERN_CPP_AVAILABLE
    ///< specialization for unordered_map
    template<class T>
    std::ostream& operator<<(std::ostream& os, const std::unordered_set<T>& collection)
    {
        PROCESS_VALUE_COLLECTION(os, collection)
        return os;
    }

    ///< specialization for forward_list
    template<class T>
    std::ostream& operator<<(std::ostream& os, const std::forward_list<T>& collection)
    {
        PROCESS_VALUE_COLLECTION(os, collection)
        return os;
    }

    ///< specialization for array
    template<class T, std::size_t N>
    std::ostream& operator<<(std::ostream& os, const std::array<T, N>& collection)
    {
        PROCESS_VALUE_COLLECTION(os, collection)
        return os;
    }
#endif

    ///< specialization for map, multimap
    MAP_TEMPLATE
    std::ostream& operator<<(std::ostream& os, const Container<Key, Value>& collection)
    {
        PROCESS_KEY_VALUE_COLLECTION(os, collection)
        return os;
    }

    ///< specialization for unordered_map
    UMAP_TEMPLATE
    std::ostream& operator<<(std::ostream& os, const Container<Key, Value, Hash, Pred, Alloc>& collection)
    {
        PROCESS_KEY_VALUE_COLLECTION(os, collection)
        return os;
    }
}
Skident
quelle