Lütfen bu yayının sonundaki güncellemeleri not edin.
Güncelleme: Bu kütüphane için GitHub'da halka açık bir proje oluşturdum !
Bir kez ve herkes için tüm STL kaplarını güzel bir şekilde basmakla ilgilenen tek bir şablona sahip olmak istiyorum operator<<. Sahte kodda, ben böyle bir şey arıyorum:
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;
}Şimdi burada mümkün olduğunu hiç düşünmediğim kadar şablon sihir gördüm, bu yüzden herkes tüm kaplar C ile eşleşen bir şey önerebilir mi merak ediyorum. Belki bir şey gerekli yineleyici olup olmadığını anlayabilecek bir özellik-ish ?
Çok teşekkürler!
Güncelleme (ve çözüm)
Kanal 9'da bu sorunu tekrar gündeme getirdikten sonra getirdikten sonra, Sven Groot'tan, biraz SFINAE tipi özelliklerle birlikte, sorunu tamamen genel ve nesnel bir şekilde çözdüğü fantastik bir cevap aldım. Sınırlayıcılar ayrı ayrı özelleştirilebilir, std :: set için örnek bir uzmanlığın yanı sıra özel sınırlayıcıların kullanımına bir örnek eklenir.
"Wrap_array ()" yardımcısı ham C dizilerini yazdırmak için kullanılabilir. Güncelleme: Çiftler ve tuples baskı için kullanılabilir; varsayılan sınırlayıcılar yuvarlak parantezlerdir.
Enable-if türü özelliği C ++ 0x gerektirir, ancak bazı değişikliklerle bunun C ++ 98 sürümünü yapmak mümkün olmalıdır. Tuples varadik şablonları gerektirir, bu nedenle C ++ 0x.
Sven'i kabul etmek için buraya çözümü göndermesini istedim, ancak bu arada kodu referans olarak kendim göndermek istiyorum. ( Güncelleme: Sven şimdi kodunu gönderdi, bu da kabul edilen cevabı verdim. Kendi kodum benim için çalışan, ancak yineleyiciler sağlayan kapsayıcı olmayan sınıflarda beklenmedik davranışlara neden olabilecek kapsayıcı türü özellikleri kullanıyor.)
Üstbilgi (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);
}
#endifKullanım örneği:
#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
;
}İyileştirmeler için diğer fikirler:
ÇıktıyıGüncelleme: Bu artık SO hakkında ayrı bir soru ! Güncelleme: Bu, Xeo sayesinde şimdi uygulandı!std::tuple<...>aynı şekilde uygulayacağızstd::pair<S,T>.Yardımcı sınıfların genel ad alanına sızmaması için ad alanları ekleyin.Bitti- Özel sınırlayıcı sınıfları veya önişlemci makroları oluşturmayı kolaylaştırmak için şablon takma adları (veya benzer bir şey) ekleyin?
Son güncellemeler:
- Özel çıktı yineleyiciyi yazdırma işlevinde basit bir döngü lehine kaldırdım.
- Tüm uygulama ayrıntıları artık
pretty_printad alanında. Genelpretty_print_arrayad alanında yalnızca genel akış işleçleri ve sarmalayıcı bulunur. - Ad alanı düzeltildi, böylece
operator<<şimdi doğru bir şekilde girilecekstd.
Notlar:
- Çıktı yineleyicinin çıkarılması,
std::copy()güzel baskı almak için kullanmanın bir yolu olmadığı anlamına gelir . Bu istenen bir özellik ise güzel yineleyici eski durumuna getirebilir, ancak Sven'in kodu aşağıdaki uygulamaya sahiptir. - Sınırlayıcıları nesne sabitlerinden ziyade derleme zamanı sabitleri yapmak bilinçli bir tasarım kararıdır. Bu, sınırlayıcıları çalışma zamanında dinamik olarak sağlayamayacağınız anlamına gelir, ancak aynı zamanda gereksiz bir ek yükün olmadığı anlamına gelir. Sven'in aşağıdaki koduna yaptığı yorumda Dennis Zickefoose tarafından nesne tabanlı bir sınırlayıcı yapılandırması önerilmiştir. İstenirse, bu alternatif bir özellik olarak uygulanabilir.
- Şu anda iç içe geçmiş konteyner sınırlayıcılarının nasıl özelleştirileceği açık değildir.
- Bu kütüphanenin amacının sizin için sıfır kodlama gerektiren hızlı konteyner baskı olanaklarına izin vermek olduğunu unutmayın. Çok amaçlı bir biçimlendirme kütüphanesi değil, konteynır incelemesi için kazan plakası kodu yazma ihtiyacını hafifletmek için gelişen bir araçtır.
Katkıda bulunan herkese teşekkürler!
Not: Özel sınırlayıcıları dağıtmanın hızlı bir yolunu arıyorsanız, tür silmeyi kullanmanın bir yolu aşağıdadır. Zaten bir sınırlayıcı sınıf oluşturduğunuzu varsayıyoruz MyDel, örneğin:
struct MyDel { static const pretty_print::delimiters_values<char> values; };
const pretty_print::delimiters_values<char> MyDel::values = { "<", "; ", ">" };Şimdi bu sınırlayıcıları kullanarak std::cout << MyPrinter(v) << std::endl;bazı kaplar için yazabilmek istiyoruz v. MyPrinterşöyle bir tür silme sınıfı olacaktır:
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); }
Kodunuz çalışmaz. konteyner C gibi bir anahtar kelime yok
—
the_drow
@the_drow: OP'nin zaten bildiği anlaşılıyor. Sadece ne aradıklarını gösteriyorlar.
—
Marcelo Cantos
Gerçekten, sadece "ahlaki" sahte kod örneği verdim. (Ayrıca dönüş türünü de bıraktım, dikkat çekiyorum.) Emin olmak için, sınırlayıcıları değiştirilebilir hale nasıl getirebileceğimi bile bilmiyorum.
—
Kerrek SB
Başka bir alternatif, operatörleri
—
David Rodríguez - dribeas
pretty_printad alanına koymak ve kullanıcının yazdırma sırasında kullanması için bir sargı sağlamak olabilir. Kullanıcı açısından: std::cout << pretty_print(v);(muhtemelen farklı bir isimle). Ardından, operatöre sarıcı ile aynı ad alanında sağlayabilir ve daha sonra istediğiniz her şeyi güzel bir şekilde bastırabilirsiniz. Ayırıcıyı ayrıca isteğe bağlı olarak her çağrıda kullanılacak ayırıcıyı tanımlamaya izin vererek geliştirebilirsiniz (tüm uygulama için aynı seçeneği zorlayan özellikleri kullanmak yerine) \
Lütfen "güncelleme" yanıtlarınızı, komik bir soru yerine gerçek cevaplara dönüştürün.
—
einpoklum