fork download
copy 
  1. #include <iostream>
  2. #include <string>
  3. #include <tuple>
  4.  
  5. template<std::size_t> struct int_{};
  6.  
  7. struct nil {};
  8.  
  9. template<typename T, class Tuple>
  10. struct concat_tuple_type;
  11.  
  12. template< typename T
  13.         , typename T1, typename T2, typename T3
  14.         , typename T4, typename T5 >
  15. struct concat_tuple_type< T, std::tuple<T1, T2, T3, T4, T5> >
  16. {
  17.     typedef std::tuple<T, T1, T2, T3, T4, T5>               result_type;
  18. };
  19.  
  20. template< typename T, class Tuple>
  21. typename concat_tuple_type<const T*,Tuple>::result_type concat_tuple(const T& obj, const Tuple& tuple)
  22. {
  23. 	typedef typename concat_tuple_type<const T*, Tuple>::result_type
  24. 	                                                        result_type;
  25. 	result_type result( obj, tuple);
  26. }
  27.  
  28. ////////////////////////////////////////////////////////////////////////////////
  29.  
  30. template<class Tuple>
  31. struct expression
  32. {
  33. 	Tuple expr;
  34.  
  35. 	expression(const Tuple& x)                            : expr(x) {}
  36. };
  37.  
  38. template<>
  39. struct expression<nil>
  40. {
  41. };
  42.  
  43. template<typename Tuple, typename T>
  44. expression< typename concat_tuple_type<const T*, Tuple>::result_type > operator<<(const expression<Tuple>& x, const T& obj)
  45. {
  46. 	typedef expression<typename concat_tuple_type<const T*, Tuple>::result_type>
  47. 	                                                        result_type;
  48. 	return result_type( concat_tuple(&obj, x.expr) );
  49. }
  50.  
  51. template<typename T>
  52. expression< std::tuple<const T*> > operator<<(const expression<nil>&, const T& obj)
  53. {
  54. 	return std::tuple<const T*>(&obj);
  55. }
  56.  
  57. ////////////////////////////////////////////////////////////////////////////////
  58.  
  59. template<typename Tuple, std::size_t I>
  60. void print_expression(std::ostream& os, const expression<Tuple>& x, int_<I>)
  61. {
  62. 	print_expression(os, x, int_<I-1>());
  63. 	os << ", " /*<< I << ": "*/ << *std::get<I>(x.expr);
  64. }
  65.  
  66. template<typename Tuple>
  67. void print_expression(std::ostream& os, const expression<Tuple>& x, int_<0>)
  68. {
  69. 	os /*<< "0: "*/ << *std::get<0>(x.expr);
  70. }
  71.  
  72. template<class Tuple>
  73. std::ostream& operator<<(std::ostream& os, const expression<Tuple>& x)
  74. {
  75. 	os << '(';
  76. 	print_expression( os, x, int_<std::tuple_size<Tuple>::value-1>() );
  77. 	os << ')';
  78. 	return os;
  79. }
  80.  
  81. ////////////////////////////////////////////////////////////////////////////////
  82.  
  83. int main()
  84. {
  85.     expression<nil> lhs;
  86.  
  87. 	int i = 42;
  88. 	std::cout << (lhs << i) << '\n';
  89. 	std::cout << (lhs << 42) << '\n';
  90. 	std::cout << (lhs << 42 << 42) << '\n';
  91. 	//std::cout << (lhs << 42 << 47.11) << '\n';
  92. 	//std::cout << (lhs << i << 47.11 << "blah") << '\n';
  93.  
  94.     return 0;
  95. }
  96.  
Compilation error #stdin compilation error #stdout 0s 0KB
comments (?)
stdin
copy 
Standard input is empty
compilation info 
prog.cpp: In function 'int main()':
prog.cpp:90:29: error: no match for 'operator<<' in 'operator<<(const expression<nil>&, const T&) [with T = int](((const int&)((const int*)(&42)))) << 42'
stdout
copy 
Standard output is empty
https://ideone.com/bsewWU
language:
C++14 (gcc 8.3)
created:
11 years ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!