Xin lưu ý các bản cập nhật ở cuối bài này.
Cập nhật: Tôi đã tạo một dự án công khai trên GitHub cho thư viện này!
Tôi muốn có một mẫu duy nhất một lần và mãi mãi là việc in đẹp tất cả các container STL thông qua operator<<. Trong mã giả, tôi đang tìm kiếm một cái gì đó như thế này:
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;
}Bây giờ tôi đã thấy rất nhiều phép thuật mẫu ở đây trên SO mà tôi chưa bao giờ nghĩ là có thể, vì vậy tôi tự hỏi liệu có ai có thể đề xuất thứ gì đó phù hợp với tất cả các container không. Có lẽ một đặc điểm nào đó có thể tìm ra nếu có thứ gì đó có trình vòng lặp cần thiết ?
Cảm ơn nhiều!
Cập nhật (và giải pháp)
Sau khi nêu lại vấn đề này trên Kênh 9 , tôi đã nhận được câu trả lời tuyệt vời từ Sven Groot, kết hợp với một chút đặc điểm của SFINAE, xuất hiện để giải quyết vấn đề theo cách hoàn toàn chung và có thể lồng được. Các dấu phân cách có thể được chuyên biệt riêng, bao gồm một chuyên môn ví dụ cho std :: set, cũng như một ví dụ về việc sử dụng các dấu phân cách tùy chỉnh.
Trình trợ giúp "quấn_array ()" có thể được sử dụng để in các mảng C thô. Cập nhật: Cặp và bộ dữ liệu có sẵn để in; dấu phân cách mặc định là dấu ngoặc tròn.
Đặc điểm loại enable-if yêu cầu C ++ 0x, nhưng với một số sửa đổi, có thể tạo phiên bản C ++ 98 này. Tuples yêu cầu các mẫu matrixdic, do đó C ++ 0x.
Tôi đã yêu cầu Sven đăng giải pháp ở đây để tôi có thể chấp nhận nó, nhưng trong lúc này tôi muốn tự mình đăng mã để tham khảo. ( Cập nhật: Sven giờ đây đã đăng tải mã của ông dưới đây, mà tôi đưa ra câu trả lời được chấp nhận mã riêng của tôi sử dụng những đặc điểm loại container, mà làm việc cho tôi nhưng có thể gây ra hành vi bất ngờ với các lớp không chứa cung cấp vòng lặp..)
Tiêu đề (beautifulprint.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);
}
#endifVí dụ sử dụng:
#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
;
}Những ý tưởng khác để cải tiến:
Thực hiện đầu ra choCập nhật: Đây là một câu hỏi riêng biệt trên SO ! Upupdate: Điều này hiện đã được thực hiện, nhờ Xeo!std::tuple<...>cùng một cách là chúng tôi có nó chostd::pair<S,T>.Thêm không gian tên để các lớp trình trợ giúp không bị chảy vào không gian tên toàn cầu.Làm xong- Thêm các bí danh mẫu (hoặc một cái gì đó tương tự) để tạo điều kiện cho việc tạo các lớp phân cách tùy chỉnh hoặc có thể là các macro tiền xử lý?
Cập nhật gần đây:
- Tôi đã loại bỏ trình lặp đầu ra tùy chỉnh theo hướng đơn giản cho vòng lặp trong chức năng in.
- Tất cả các chi tiết thực hiện hiện đang ở trong
pretty_printkhông gian tên. Chỉ các toán tử luồng toàn cầu vàpretty_print_arraytrình bao bọc nằm trong không gian tên toàn cục. - Đã sửa lỗi không gian tên để
operator<<bây giờ chính xácstd.
Ghi chú:
- Loại bỏ trình lặp đầu ra có nghĩa là không có cách nào để sử dụng
std::copy()để có được bản in đẹp. Tôi có thể khôi phục trình lặp đẹp nếu đây là một tính năng mong muốn, nhưng mã của Sven bên dưới có triển khai. - Đó là một quyết định thiết kế có ý thức để làm cho các dấu phân cách biên dịch các hằng số thời gian hơn là các hằng số đối tượng. Điều đó có nghĩa là bạn không thể cung cấp các dấu phân cách động trong thời gian chạy, nhưng điều đó cũng có nghĩa là không có chi phí không cần thiết. Một cấu hình dấu phân cách dựa trên đối tượng đã được Dennis Zickefoose đề xuất trong một nhận xét về mã của Sven bên dưới. Nếu muốn, điều này có thể được thực hiện như một tính năng thay thế.
- Hiện tại không rõ ràng làm thế nào để tùy chỉnh các dấu phân cách container lồng nhau.
- Hãy nhớ rằng mục đích của thư viện này là cho phép các cơ sở in container nhanh chóng yêu cầu mã hóa bằng 0 từ phía bạn. Nó không phải là một thư viện định dạng đa mục đích, mà là một công cụ phát triển để giảm bớt sự cần thiết phải viết mã nồi hơi để kiểm tra container.
Cảm ơn tất cả những người đã đóng góp!
Lưu ý: Nếu bạn đang tìm kiếm một cách nhanh chóng để triển khai các dấu phân cách tùy chỉnh, đây là một cách sử dụng kiểu xóa. Chúng tôi giả sử rằng bạn đã xây dựng một lớp phân cách MyDel, như vậy:
struct MyDel { static const pretty_print::delimiters_values<char> values; };
const pretty_print::delimiters_values<char> MyDel::values = { "<", "; ", ">" };Bây giờ chúng tôi muốn có thể viết std::cout << MyPrinter(v) << std::endl;cho một số container vbằng cách sử dụng các dấu phân cách đó. MyPrintersẽ là một lớp xóa kiểu, như vậy:
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); }
Mã của bạn sẽ không hoạt động. không có từ khóa nào như container C
—
the_drow
@the_drow: Có vẻ như OP đã biết điều đó rồi. Họ chỉ cho biết những gì họ đang tìm kiếm.
—
Marcelo Cantos
Thật vậy, tôi chỉ đưa ra một ví dụ mã giả "đạo đức". (Tôi cũng bỏ qua kiểu trả về, tôi đang lưu ý.) Để chắc chắn, tôi thậm chí không biết cách tốt nhất để làm cho các dấu phân cách có thể thay đổi.
—
Kerrek SB
Một cách khác là đặt các toán tử vào
—
David Rodríguez - dribeas
pretty_printkhông gian tên và cung cấp trình bao bọc cho người dùng sử dụng khi in. Từ quan điểm người dùng: std::cout << pretty_print(v);(có thể với một tên khác). Sau đó, bạn có thể cung cấp toán tử trong cùng một không gian tên như trình bao bọc, và sau đó nó có thể mở rộng thành in đẹp bất cứ thứ gì bạn muốn. Bạn cũng có thể nâng cao trình bao bọc cho phép tùy ý xác định dấu phân cách để sử dụng trong mỗi cuộc gọi (thay vì sử dụng các đặc điểm buộc cùng lựa chọn cho toàn bộ ứng dụng) \
Vui lòng đặt câu trả lời "cập nhật" của bạn thành câu trả lời thực tế thay vì có một câu hỏi hóc búa.
—
einpoklum