Table of Contents

Introduction

std::vector<std::vector<int>> my_vector{{3,5,8,9,7}, {9,3,2,3,8}};cpp_dump(my_vector);

Features

A wide variety of supported types

bool my_bool =true;double my_double =3.141592;int my_int =65;char my_char ='a', LF_char ='\n'; std::string my_string ="This is a string.";int *int_ptr = &my_int;void *void_ptr = &my_int;std::vector<std::vector<int>> my_vector{{3,5,8,9,7}, {9,3,2,3,8}};std::set<char> my_set{'A','p','p','l','e'};std::map<int,int> my_map{{2,6}, {4,6}, {5,3}};std::multiset<char> my_multiset{'A','p','p','l','e'};std::multimap<int,int> my_multimap{{2,4}, {4,6}, {5,3}, {4,7}};std::pair<int,char> my_pair{8,'a'};std::tuple<int,double, std::string> my_tuple{7,4.5,"This is a string."};std::queue<int> my_queue;std::priority_queue<int> my_priority_queue;std::stack<int> my_stack;for (auto v : {1,2,3,4,5}) my_queue.push(v), my_priority_queue.push(v), my_stack.push(v);std::bitset<8>my_bitset(0x3a);std::complex<double> my_complex{1.0, -1.0};std::optional<int> my_optional{15};std::variant<int, std::string> my_variant{"This is a string."};std::vector<std::pair<int, std::string>> vector_of_pairs{{1,"apple"}, {3,"banana"}};std::clog <<"\n// Basic Type" << std::endl;cpp_dump(my_bool, my_double, my_int); cpp_dump(my_string, my_char, LF_char);cpp_dump(int_ptr, void_ptr,nullptr);std::clog <<"\n// Container" << std::endl;cpp_dump(my_vector);std::clog <<"\n// Set/Map" << std::endl;cpp_dump(my_set); cpp_dump(my_map);std::clog <<"\n// Multiset/Multimap" << std::endl;cpp_dump(my_multiset); cpp_dump(my_multimap);std::clog <<"\n// Tuple" << std::endl;cpp_dump(my_tuple); cpp_dump(my_pair);std::clog <<"\n// FIFO/LIFO" << std::endl;cpp_dump(my_queue); cpp_dump(my_priority_queue); cpp_dump(my_stack);std::clog <<"\n// Other" << std::endl;cpp_dump(my_bitset); cpp_dump(my_complex);cpp_dump(my_optional, std::nullopt); cpp_dump(my_variant);std::clog <<"\n// Combination" << std::endl;cpp_dump(vector_of_pairs);

Auto indent

cpp_dump(my_vector);my_vector.push_back("This is a test string.");cpp_dump(my_vector);

Filename and line can be printed instead of[dump]

// Print the filename and line instead of [dump]CPP_DUMP_SET_OPTION(log_label_func, cp::log_label::filename());// Print along with the function nameCPP_DUMP_SET_OPTION(log_label_func, cp::log_label::filename(true));

Customizable output color

// Use more colorsCPP_DUMP_SET_OPTION(es_value.log,"\x1b[02m");// log: darkCPP_DUMP_SET_OPTION(es_value.expression,"\x1b[34m");// expression: blueCPP_DUMP_SET_OPTION(es_value.reserved,"\x1b[38;5;39m");// reserved: light blueCPP_DUMP_SET_OPTION(es_value.number,"\x1b[38;5;150m");// number: light greenCPP_DUMP_SET_OPTION(es_value.character,"\x1b[38;5;172m");// character: orangeCPP_DUMP_SET_OPTION(es_value.escaped_char,"\x1b[38;5;220m");// escaped_char: light orangeCPP_DUMP_SET_OPTION(es_value.op,"\x1b[02m");// op: darkCPP_DUMP_SET_OPTION(es_value.identifier,"\x1b[32m");// identifier:  greenCPP_DUMP_SET_OPTION(es_value.member,"\x1b[96m");// member: light cyanCPP_DUMP_SET_OPTION(es_value.unsupported,"\x1b[31m");// unsupported: redCPP_DUMP_SET_OPTION(es_value.bracket_by_depth, (std::vector<std::string>{"\x1b[33m",// bracket_by_depth[0]: yellow"\x1b[35m",// bracket_by_depth[1]: magenta"\x1b[36m",// bracket_by_depth[2]: cyan}));CPP_DUMP_SET_OPTION(es_value.class_op,"\x1b[02m");// class_op: darkCPP_DUMP_SET_OPTION(es_value.member_op,"\x1b[02m");// member_op: darkCPP_DUMP_SET_OPTION(es_value.number_op,"");// number_op: default// Use the 'class_op'/'member_op'/'number_op' color for operators// in class names, members, and numbers (::, <>, (), -, +, etc...).CPP_DUMP_SET_OPTION(detailed_class_es,true);CPP_DUMP_SET_OPTION(detailed_member_es,true);CPP_DUMP_SET_OPTION(detailed_number_es,true);// Use a color scheme closer to standard syntax highlighting.// CPP_DUMP_SET_OPTION(es_style, cp::types::es_style_t::by_syntax);

// Turn off output coloringCPP_DUMP_SET_OPTION(es_style, cp::types::es_style_t::no_es);

Can print even user-defined types

CPP_DUMP_DEFINE_EXPORT_OBJECT_GENERIC(i, str());

Advanced Feature

20+ Manipulators to change the display style

Requirement

Installation

Simplest solution

git clone https://github.com/philip82148/cpp-dump

#include"path/to/cpp-dump/cpp-dump.hpp"

With CMake

Runcmake --install to copy the headers to/usr/local/include/ or equivalent

git clone https://github.com/philip82148/cpp-dumpcd cpp-dumpcmake -S. -B build# No configuration is needed because the library is header-only.sudo cmake --install build# (The 'cpp-dump' folder can be removed after this.)

#include<cpp-dump.hpp>

UseFetchContent

set(CMAKE_EXPORT_COMPILE_COMMANDSON)# Generate compile_commands.json (optional)include(FetchContent)# Fetch cpp-dumpFetchContent_Declare(cpp-dump    GIT_REPOSITORY https://github.com/philip82148/cpp-dump    GIT_TAG main)FetchContent_MakeAvailable(cpp-dump)

#include<cpp-dump.hpp>

Configuration (as needed)

#ifdef DEBUGGING#include"path/to/cpp-dump/cpp-dump.hpp"namespacecp= cpp_dump;// You can use this in both a header file and a source file,// but make sure not to use it more than once for the same option.CPP_DUMP_SET_OPTION_GLOBAL(max_line_width,100);// To ensure proper instantiation of templates,// include these in at least one translation unit where cpp_dump(...) prints each type.// One way is to write them in a header file and then include it wherever needed.CPP_DUMP_DEFINE_EXPORT_OBJECT(my_class, member1, member2());CPP_DUMP_DEFINE_EXPORT_OBJECT_GENERIC(member3, member4());CPP_DUMP_DEFINE_EXPORT_ENUM(my_enum, my_enum::a, my_enum::b, my_enum::c);CPP_DUMP_DEFINE_EXPORT_ENUM_GENERIC(member_a, member_b, member_c);#else#definecpp_dump(...)#defineCPP_DUMP_SET_OPTION(...)#endif

#include"path/to/custom-cpp-dump.hpp"intmain() {cpp_dump(vec |cp::back());}

#include"path/to/custom-cpp-dump.hpp"voidfunc() {CPP_DUMP_SET_OPTION(print_expr,false);cpp_dump(vec |cp::back());CPP_DUMP_SET_OPTION(print_expr,true);}

Configuration options

max_line_width

max_depth

max_iteration_count

cont_indent_style

enable_asterisk

print_expr

log_label_func

es_style

es_value

detailed_class_es

detailed_member_es

detailed_number_es

Detailed usage

Macros

/** * Print string representations of expressions and results to std::clog or other configurable outputs. * If you want to change the output, define an explicit specialization of cpp_dump::write_log(). * This macro uses cpp_dump::export_var() internally.*/#definecpp_dump(expressions...)/** * Make cpp_dump::export_var() support type T. * Member functions to be displayed must be const.*/#defineCPP_DUMP_DEFINE_EXPORT_OBJECT(T, members...)/** * Make cpp_dump::export_var() support every type that has the specified members. * Member functions to be displayed must be const. * Compile errors in this macro, such as ambiguous function calls, are never reported due to SFINAE.*/#defineCPP_DUMP_DEFINE_EXPORT_OBJECT_GENERIC(members...)/** * Make cpp_dump::export_var() support enum T.*/#defineCPP_DUMP_DEFINE_EXPORT_ENUM(T, members...)/** * Make cpp_dump::export_var() support every enum type that has the specified members. * Compile errors in this macro, such as ambiguous function calls, are never reported due to SFINAE.*/#defineCPP_DUMP_DEFINE_EXPORT_ENUM_GENERIC(members...)/** * Set a value to a variable in cpp_dump::options namespace.*/#defineCPP_DUMP_SET_OPTION(variable, value)/** * Set a value to a variable in cpp_dump::options namespace. * Use this if you want to run it in the global namespace, meaning before the main starts.*/#defineCPP_DUMP_SET_OPTION_GLOBAL(variable, value)

Types

namespacecpp_dump::types {/** * Type of cpp_dump::options::cont_indent_style. * cpp_dump::export_var() supports this type.*/enumclasscont_indent_style_t { minimal, when_nested, when_non_tuples_nested, always };/** * Type of cpp_dump::options::es_style. * cpp_dump::export_var() supports this type.*/enumclasses_style_t { no_es, original, by_syntax };/** * Type of cpp_dump::options::es_value. * cpp_dump::export_var() supports this type.*/structes_value_t {  std::string log ="\x1b[02m";// dark  std::string expression ="\x1b[36m";// cyan  std::string reserved{};// default  std::string number{};// default  std::string character{};// default  std::string escaped_char ="\x1b[02m";// dark  std::string op ="\x1b[02m";// dark  std::string identifier ="\x1b[32m";// green  std::string member ="\x1b[36m";// cyan  std::string unsupported ="\x1b[31m";// red  std::vector<std::string> bracket_by_depth{"\x1b[02m"};// dark  std::string class_op ="\x1b[02m";// dark  std::string member_op ="\x1b[02m";// dark  std::string number_op{};// default};usinglog_label_func_t = std::function<std::string(std::string_view, std::size_t, std::string_view)>;}// namespace cpp_dump::types

Variables

namespacecpp_dump::options {/** * Maximum line width of the strings returned by cpp_dump() and cpp_dump::export_var().*/inline std::size_t max_line_width =160;/** * Maximum number of times cpp_dump::export_var() is called recursively.*/inline std::size_t max_depth =4;/** * Maximum number of iterations of cpp_dump::export_var() over an iterator. * Note that in a single call, cpp_dump::export_var() calls itself at most * (max_iteration_count^(max_depth+1)-1)/(max_iteration_count-1) times.*/inline std::size_t max_iteration_count =16;/** * Style of indents of the Container, Set and Map categories (See 'Supported types')*/inline types::cont_indent_style_t cont_indent_style = types::cont_indent_style_t::when_nested;/** * Whether cpp_dump() prints types of the Asterisk category (See 'Supported types').*/inlinebool enable_asterisk =false;/** * Whether cpp_dump() prints the expressions.*/inlinebool print_expr =true;/** * Function that returns the label that cpp_dump() prints at the beginning of the output.*/inline types::log_label_func_t log_label_func = log_label::default_func;/** * Style of the escape sequences (output coloring).*/inline types::es_style_t es_style = types::es_style_t::original;/** * Values of the escape sequences (output coloring).*/inline types::es_value_t es_value;/** * If true, the 'es_value.class_op' color is used for operators in class names (::, <>, etc...).*/inlinebool detailed_class_es =false;/** * If true, the 'es_value.member_op' color is used for operators in members ((), etc...).*/inlinebool detailed_member_es =false;/** * If true, the 'es_value.number_op' color is used for operators in numbers (-, +, etc...).*/inlinebool detailed_number_es =false;}// namespace cpp_dump::options

Functions

namespacecpp_dump {/** * Return a string representation of a variable. * cpp_dump() uses this function internally.*/template<typename T>std::stringexport_var(const T &value);/** * cpp_dump() uses this function to print logs. * Define an explicit specialization with 'void' to customize this function.*/template<typename =void>voidwrite_log(std::string_view output) {  std::clog << output << std::endl;}// Manipulators (See 'Formatting with manipulators' for details.)front(std::size_t iteration_count = options::max_iteration_count);middle(std::size_t iteration_count = options::max_iteration_count);back(std::size_t iteration_count = options::max_iteration_count);both_ends(std::size_t half_iteration_count = options::max_iteration_count /2);index();int_style(int base,int digits = -1,int chunk =0,bool space_fill =false,bool make_unsigned_or_no_space_for_minus =false);bin(int digits = -1,int chunk =0,bool space_fill =false);oct(int digits = -1,int chunk =0,bool space_fill =false);hex(int digits = -1,int chunk =0,bool space_fill =false);dec(int digits = -1,int chunk =0,bool space_fill =true);ubin(int digits = -1,int chunk =0,bool space_fill =false);uoct(int digits = -1,int chunk =0,bool space_fill =false);uhex(int digits = -1,int chunk =0,bool space_fill =false);udec(int digits = -1,int chunk =0,bool space_fill =true);map_k(return_value_of_manipulator);map_v(return_value_of_manipulator);map_kv(return_value_of_manipulator_for_key, return_value_of_manipulator_for_value);format(constchar *f);bw(bool left =false);boolnum();stresc();charhex();addr(std::size_t depth =0);}// namespace cpp_dump// See 'Customize "[dump]"'.namespacecpp_dump::log_label {std::stringdefault_func(std::string_view, std::size_t, std::string_view);types::log_label_func_tline(bool show_func =false,int min_width =0);types::log_label_func_tbasename(bool show_func =false,int min_width =0);types::log_label_func_tfilename(bool show_func =false,int min_width =0);types::log_label_func_tfullpath(int substr_start,bool show_func =false,int min_width =0);types::log_label_func_tfixed_length(int min_width,int max_width,int substr_start,bool show_func =false);}// namespace cpp_dump::log_label

How to print a user-defined type with cpp-dump

Method 1. UseCPP_DUMP_DEFINE_EXPORT_OBJECT() macro

// Somewhere accessible from the global scope (not private or defined in a function)structclass_A {int i;  std::stringstr()const {returnstd::to_string(i); }};// In the global scope// CPP_DUMP_DEFINE_EXPORT_OBJECT(type_name, members...)CPP_DUMP_DEFINE_EXPORT_OBJECT(class_A, i, str());// In a functionclass_A my_class_A{10};cpp_dump(my_class_A);

// Somewhere accessible from the global scope (not private or defined in a function)enumclassenum_A { member_a, member_b, member_c };// In the global scope// CPP_DUMP_DEFINE_EXPORT_ENUM(enum_name, members...)CPP_DUMP_DEFINE_EXPORT_ENUM(enum_A, enum_A::member_a, enum_A::member_b, enum_A::member_c);// In a functionenum_A my_enum_A = enum_A::member_c;cpp_dump(my_enum_A);

Method 2. UseCPP_DUMP_DEFINE_EXPORT_OBJECT_GENERIC() macro

// In the global scope// CPP_DUMP_DEFINE_EXPORT_OBJECT_GENERIC(members...)CPP_DUMP_DEFINE_EXPORT_OBJECT_GENERIC(i, str());// Anywherestructclass_A {int i;  std::stringstr()const {returnstd::to_string(i); }};// In a functionclass_A my_class_A{10};cpp_dump(my_class_A);

// In the global scope// CPP_DUMP_DEFINE_EXPORT_ENUM_GENERIC(members...)CPP_DUMP_DEFINE_EXPORT_ENUM(member_a, member_b, member_c);// Anywhereenumclassenum_A { member_a, member_b, member_c };// In a functionenum_A my_enum_A = enum_A::member_c;cpp_dump(my_enum_A);

Method 3. Definestd::ostream& operator<<(std::ostream&, const T &) operator

// Somewhere accessible from the global scope (not private or defined in a function)structclass_A {int i;  std::stringstr()const {returnstd::to_string(i); }};// In the global scopestd::ostream &operator<<(std::ostream &os,const class_A &a) {  os <<"class_A{ i=" << a.i <<", str()=\"" << a.str() <<"\" }";return os;}// In a functionclass_A my_class_A{10};cpp_dump(my_class_A);

Customize[dump]

namespacecpp_dump::types {usinglog_label_func_t =  std::function<std::string(std::string_view fullpath, std::size_t line, std::string_view func_name)>;}// namespace cpp_dump::typesnamespacecpp_dump::log_label {// Default function assigned to cpp_dump::options::log_label_func.std::stringdefault_func(std::string_view, std::size_t, std::string_view) {return"[dump]";}// Functions that create a function that can be assigned to cpp_dump::options::log_label_func.types::log_label_func_tline(bool show_func =false,int min_width =0);types::log_label_func_tbasename(bool show_func =false,int min_width =0);types::log_label_func_tfilename(bool show_func =false,int min_width =0);types::log_label_func_tfullpath(int substr_start,bool show_func =false,int min_width =0);types::log_label_func_tfixed_length(int min_width,int max_width,int substr_start,bool show_func =false);}// namespace cpp_dump::log_labelnamespacecpp_dump::options {inline types::log_label_func_t log_label_func = log_label::default_func;}// namespace cpp_dump::options

Formatting with manipulators

// Show the last 10 elements for the 1st dimension, the first 5 and the last 5 for the 2nd dimension.cpp_dump(some_huge_vector | cp::back(10) | cp::both_ends(5) | cp::dec(2));

CPP_DUMP_SET_OPTION(max_iteration_count,5);// Show the indexes of the vector.cpp_dump(some_huge_vector | cp::dec(2) | cp::index());

// Show integers in binary, minimum 16 digits, separated by every 4 characters.cpp_dump(0x3e8u | cp::bin(16,4));// Show integers in octal, minimum 6 digits, separated by every 3 characters.cpp_dump(0x3e8u | cp::oct(6,3));// Show integers in hexadecimal, minimum 4 digits, separated by every 2 characters.cpp_dump(0x3e8u | cp::hex(4,2));// Show integers in minimum 4 digits.cpp_dump(0x3e8u | cp::dec(4));

How to use manipulators

cpp_dump(variable | manipulatorA() | manipulatorB());cpp_dump(manipulatorA() << manipulatorB() << variable);

front(),middle(),back(),both_ends() manipulators

namespacecpp_dump {front(std::size_t iteration_count = options::max_iteration_count);middle(std::size_t iteration_count = options::max_iteration_count);back(std::size_t iteration_count = options::max_iteration_count);both_ends(std::size_t half_iteration_count = options::max_iteration_count /2);}// namespace cpp_dump

// Show the last 10 elements for the 1st dimension, the first 5 and the last 5 for the 2nd dimension.cpp_dump(some_huge_vector | cp::back(10) | cp::both_ends(5) | cp::dec(2));

index() manipulator

cpp_dump::index();

cpp_dump(some_huge_vector | cp::dec(2) | cp::index());

int_style() and its alias manipulators

namespacecpp_dump {int_style(int base,int digits = -1,int chunk =0,bool space_fill =false,bool make_unsigned_or_no_space_for_minus =false);bin(int digits = -1,int chunk =0,bool space_fill =false) {returnint_style(2, digits, chunk, space_fill,false);}oct(int digits = -1,int chunk =0,bool space_fill =false) {returnint_style(8, digits, chunk, space_fill,false);}hex(int digits = -1,int chunk =0,bool space_fill =false) {returnint_style(16, digits, chunk, space_fill,false);}dec(int digits = -1,int chunk =0,bool space_fill =true) {returnint_style(10, digits, chunk, space_fill,false);}ubin(int digits = -1,int chunk =0,bool space_fill =false) {returnint_style(2, digits, chunk, space_fill,true);}uoct(int digits = -1,int chunk =0,bool space_fill =false) {returnint_style(8, digits, chunk, space_fill,true);}uhex(int digits = -1,int chunk =0,bool space_fill =false) {returnint_style(16, digits, chunk, space_fill,true);}udec(int digits = -1,int chunk =0,bool space_fill =true) {returnint_style(10, digits, chunk, space_fill,true);}}// namespace cpp_dump

// Show integers in binary, minimum 16 digits, separated by every 4 characters.cpp_dump(0x3e8u | cp::bin(16,4));// Show integers in octal, minimum 6 digits, separated by every 3 characters.cpp_dump(0x3e8u | cp::oct(6,3));// Show integers in hexadecimal, minimum 4 digits, separated by every 2 characters.cpp_dump(0x3e8u | cp::hex(4,2));// Show integers in minimum 4 digits.cpp_dump(0x3e8u | cp::dec(4));

cpp_dump(signed_int_vector | cp::front(2) | cp::hex(2));cpp_dump(unsigned_int_vector | cp::front(2) | cp::hex(2));cpp_dump(signed_int_vector | cp::front(2) | cp::dec(2));cpp_dump(unsigned_int_vector | cp::front(2) | cp::dec(2));

cpp_dump(signed_int_vector | cp::front(2) | cp::uhex());cpp_dump(unsigned_int_vector | cp::front(2) | cp::uhex(2));cpp_dump(signed_int_vector | cp::front(2) | cp::udec(2));cpp_dump(unsigned_int_vector | cp::front(2) | cp::udec(2));

format() manipulator

cpp_dump::format(constchar *f);

cpp_dump(pi | cp::format("%.10f"));

bw(),boolnum() manipulators

cpp_dump::bw(bool left =false);cpp_dump::boolnum();

cpp_dump(bool_vector | cp::bw());cpp_dump(bool_vector | cp::bw(true));cpp_dump(bool_vector | cp::boolnum());

stresc() manipulator

cpp_dump::stresc();

cpp_dump("\a\t\\\"\n\x7f need to be escaped.");cpp_dump("\a\t\\\"\n\x7f need to be escaped." | cp::stresc());

charhex() manipulator

cpp_dump::charhex();

for (auto c :"\a\t\\\"\n\x7f ABC") cpp_dump(c | cp::charhex());

addr() manipulator

cpp_dump::addr(std::size_t depth =0);

int my_int =15;int *int_ptr = &my_int;int **int_ptr_ptr = &int_ptr;cpp_dump(int_ptr_ptr);cpp_dump(int_ptr_ptr | cp::addr());cpp_dump(int_ptr_ptr | cp::addr(1));

map_*() manipulators

namespacecpp_dump {map_k(return_value_of_manipulator);map_v(return_value_of_manipulator);map_kv(return_value_of_manipulator_for_key, return_value_of_manipulator_for_value);}// namespace cpp_dump

cpp_dump(cp::front() << cp::map_kv(cp::hex(), cp::back()) << map);cpp_dump(map | cp::front() | cp::map_kv(cp::hex(), cp::back()));

Change the output destination from the standard error output

// You can write this in a header file.// If you write it in a source file, you can remove the inline keyword.template<>inlinevoidcpp_dump::write_log(std::string_view output) {  elsewhere << output << std::endl;}

How to pass complex expressions tocpp_dump(...)

Expressions with commas

cpp_dump(std::is_same_v<T, U>);// Compile error!cpp_dump((std::is_same_v<T, U>));// Correct

Variadic template arguments

template<typename... Args>voidvariadic_template_func(Args &&...args) {int i =0;cpp_dump(args..., i);// Compile error!cpp_dump(args...),cpp_dump(i);// Correct}

For competitive programming use

#ifdef DEFINED_ONLY_IN_LOCAL#include"./cpp-dump/cpp-dump.hpp"#definedump(...) cpp_dump(__VA_ARGS__)namespacecp= cpp_dump;CPP_DUMP_SET_OPTION_GLOBAL(max_line_width,80);CPP_DUMP_SET_OPTION_GLOBAL(log_label_func, cp::log_label::filename());CPP_DUMP_SET_OPTION_GLOBAL(enable_asterisk,true);#else#definedump(...)#defineCPP_DUMP_SET_OPTION(...)#defineCPP_DUMP_DEFINE_EXPORT_OBJECT(...)#defineCPP_DUMP_DEFINE_EXPORT_OBJECT_GENERIC(...)#defineCPP_DUMP_DEFINE_EXPORT_ENUM(...)#defineCPP_DUMP_DEFINE_EXPORT_ENUM_GENERIC(...)#endif#include<bits/stdc++.h>#definerep(i, n)for (int i =0; i < (int)(n); ++i)usingnamespacestd;intmain() {int N;  cin >> N;  vector<int>X(N);rep(i, N) { cin >> X[i]; }dump(X);// To be continued...}

g++ ./main.cpp -D DEFINED_ONLY_IN_LOCAL

clang++ ./main.cpp -D DEFINED_ONLY_IN_LOCAL

Supported types

Display example

#Arithmetictrue, 'c', 1, 3.140000#String"A normal string"`A string with '"' or newline(s)`#Container[ value1, value2, ... ]#Map{ key1: value1, key2: value2, ... },{ key1 (multiplicity1): [ value1a, value1b, ... ], key2 (multiplicity2): [ ... ], ... }#Set{ value1, value2, ... },{ value1 (multiplicity1), value2 (multiplicity2), ... }#Tuple( value1, value2, ... )#FIFO/LIFOstd::queue{ size()= integer, front()= value, back()= value }#Pointer*valuenullptr0x7fff2246c4d8#(The address will be displayed when the pointertype is void*#or thetype the pointer points to is not supported.)#Referencetrue, 'c', 1, 3.140000#(No change)#Exceptionstd::logic_error{ what()= "Error Message" }#Asterisk*value