Pretty print any data, containers, pairs and tuples.
To use this module, simply include the pprint
herader file:
#include <pprint/pprint>
The only thing you need to do is call the function print
like this:
pprint::print(xxx /* , xxx, xxx, ... */);
Or using the namespace pprint
then call the print
:
using pprint::print;
print(xxx /* , xxx, xxx, ... */);
Common data, include: int
, double
, char
, string
, pointer
, bool
, enum
and etc can be print:
enum class Color { Red, Green, Blue };
int sampleInt = 123;
double sampleDouble = 123.;
char sampleChar = 'a';
string sampleStr = "abc";
int *samplePtr = nullptr;
bool sampleBool = false;
Color sampleEnum = Color::Red;
/*
123
123
'a'
"abc"
0
false
Color::0
*/
print(sampleInt, sampleDouble, sampleChar, sampleStr, samplePtr, sampleBool, sampleEnum);
Sequence container, include: std::array
, std::vector
, std::list
, std::forward_list
, and std::deque
can be print:
array<int, 3> sampleArray {1, 2, 3};
vector<string> sampleVector {"abc", "def", "ghi"};
list<forward_list<deque<string>>> sampleComplexContainer {{{"abc", "def"}, {"ghi", "jkl"}}, {{"mno", "pqr"}, {"stu", "vwx"}}};
/*
(1, 2, 3)
["abc", "def", "ghi"]
[
[
["abc", "def"],
["ghi", "jkl"],
],
[
["mno", "pqr"],
["stu", "vwx"],
],
]
*/
print(sampleArray, sampleVector, sampleComplexContainer);
Map container, include: std::map
, std::multimap
, std::unordered_map
and std::unordered_multimap
can ba print:
unordered_map<int, string> sampleMap {{1, "abc"}, {2, "def"}, {3, "ghi"}};
unordered_multimap<int, string> sampleMultiMap {{1, "abc"}, {2, "def"}, {3, "ghi"}};
map<int, multimap<int, int>> sampleComplexMap {{1, {{2, 2}, {3, 3}}}, {4, {{5, 5}, {6, 6}}}, {7, {{8, 8}, {9, 9}}}};
/*
{
(3, "ghi"),
(2, "def"),
(1, "abc"),
}
{
(3, "ghi"),
(2, "def"),
(1, "abc"),
}
{
(
1,
{
(2, 2),
(3, 3),
},
),
(
4,
{
(5, 5),
(6, 6),
},
),
(
7,
{
(8, 8),
(9, 9),
},
),
}
*/
print(sampleMap, sampleMultiMap, sampleComplexMap);
Set container, include: std::set
, std::multiset
, std::unordered_set
, and std::unordered_multiset
can be print:
unordered_set<int> sampleSet {1, 2, 3};
unordered_multiset<int> sampleMultiSet {1, 2, 3};
set<multiset<bool>> sampleComplexSet {{true, false}, {false, true}, {true, false, false, true}};
/*
{3, 2, 1}
{3, 2, 1}
{
{false, false, true, true},
{false, true},
}
*/
print(sampleSet, sampleMultiSet, sampleComplexSet);
std::pair
can be print:
pair<int, string> samplePair {1, "abc"};
pair<int, vector<string>> sampleComplexPair {1, {"abc", "def", "ghi"}};
/*
(1, "abc")
(
1,
["abc", "def", "ghi"],
)
*/
print(samplePair, sampleComplexPair);
std::tuple
can be print:
tuple<int, double, char, string> sampleTuple {1, 2., 'a', "abc"};
tuple<int, double, char, string, vector<string>> sampleComplexTuple {1, 2., 'a', "abc", {"abc", "def", "ghi"}};
/*
(1, 2, 'a', "abc")
(
1,
2,
'a',
"abc",
["abc", "def", "ghi"],
)
*/
print(sampleTuple, sampleComplexTuple);
std::stack
can be print:
stack<int> sampleStack;
sampleStack.push(1);
sampleStack.push(2);
sampleStack.push(3);
stack<vector<string>> sampleComplexStack;
sampleComplexStack.push({"abc", "def"});
sampleComplexStack.push({"ghi", "jkl"});
sampleComplexStack.push({"mno", "pqr"});
/*
[1, 2, 3]
Bottom --------> Top
*/
print(sampleStack);
/*
Bottom
[ |
["abc", "def"], |
["ghi", "jkl"], |
["mno", "pqr"], |
] v
Top
*/
print(sampleComplexStack);
std::queue
and std::priority_queue
can be print:
queue<int> sampleQueue;
sampleQueue.push(1);
sampleQueue.push(2);
sampleQueue.push(3);
priority_queue<vector<string>> sampleComplexPriorityQueue;
sampleComplexPriorityQueue.push({"abc", "def"});
sampleComplexPriorityQueue.push({"ghi", "jkl"});
sampleComplexPriorityQueue.push({"mno", "pqr"});
/*
[1, 2, 3]
Front <-------- Back
*/
print(sampleQueue);
/*
Front
[ ^
["mno", "pqr"], |
["ghi", "jkl"], |
["abc", "def"], |
] |
Back
*/
print(sampleComplexPriorityQueue);
Any other type which defined cout << ...
operator can be print:
/*
(1,2)
"6"
*/
print(complex(1, 2), filesystem::path("6"));
struct Coord { double x; double y; };
ostream &operator<<(ostream &os, const Coord &coordObj)
{
return os << '(' << coordObj.x << ", " << coordObj.y << ")\n";
}
// (2, 3)
print(Coord {2, 3});
Otherwise, print will use the default format: <Typename, Pointer>
:
// <std::integer_sequence<unsigned long long, 0ull, 1ull, 2ull>, 0x...>
print(index_sequence_for<int, double, string>());
struct Coord { double x; double y; };
// <Coord, 0x...>
print(Coord {2, 3});