By using this site, you agree to our updated Privacy Policy and our Terms of Use. Manage your Cookies Settings.
457,976 Members | 1,139 Online
Bytes IT Community
+ Ask a Question
Need help? Post your question and get tips & solutions from a community of 457,976 IT Pros & Developers. It's quick & easy.

Overoad operator<<

P: 2
Hi, I've been trying to overload << for a function similar to boost lambda library.

I want to make for_each(v.begin(), b.end(), cout << _1 << endl); to work, however, i'm getting a lot of problems in making this happen..

The following is my current code >

Expand|Select|Wrap|Line Numbers
  1. #include <string>
  2. #include <iostream>
  3. using namespace std;
  4.  
  5. //Expr class to evaluate expression
  6. template <class A, class B>
  7. class Expr {
  8.  
  9. public:
  10.     A l_v;
  11.     B r_v;
  12.     string Op;
  13.     //ostream l_s;
  14.  
  15.     Expr() { }
  16.  
  17.     Expr(A l, B r, string o) {
  18.         l_v = l;
  19.         r_v = r;
  20.         Op = o;
  21.     }
  22.  
  23.     int operator()(int &);
  24. };
  25.  
  26. template <class A, class B>
  27. class ExprForOut {
  28.  
  29. public:
  30.     A l_s;
  31.     B r_s;
  32.  
  33.     ExprForOut() { }
  34.  
  35.     ExprForOut(A l, B r) {
  36.         l_s = l;
  37.         r_s = r;
  38.     }
  39.  
  40.     int operator()(int &);
  41. };
  42.  
  43. //class a2 as a placeholder/expression call for _1 
  44. class a2 {
  45.  
  46. public:
  47.     a2() {
  48.     }
  49.  
  50.     int operator()(int& x) {
  51.         return x;
  52.     }
  53.  
  54.     template <class B> Expr<a2, B> operator=(B b) {
  55.         Expr<a2, B> expression(*this, b, "=");
  56.         return expression;
  57.     }
  58.  
  59. };
  60.  
  61. int clarifyExpr(int x, int y) {
  62.     return x;
  63. }
  64.  
  65. int clarifyExpr(a2 a, int x) {
  66.     return x;
  67. }
  68.  
  69. template <class A, class B> int clarifyExpr(Expr<A,B> expression, int x) {
  70.     return eval(expression, x);
  71. }
  72.  
  73. //Evaluation of the given expression
  74. template <class A, class B> 
  75. int eval(Expr<A,B> expression, int &x) {
  76.     int var;
  77.     int l_v;
  78.     int r_v;
  79.  
  80.     if(expression.Op != "<<") {
  81.         l_v = clarifyExpr(expression.l_v, x);
  82.         r_v = clarifyExpr(expression.r_v, x);
  83.     } 
  84.  
  85.     cout<< l_v << " : " << r_v << endl;
  86.  
  87.     if(expression.Op == "+") {
  88.         var = l_v + r_v;
  89.     } else if(expression.Op == "-") {
  90.         var = l_v - r_v;
  91.     } else if(expression.Op == "/") {
  92.         var = l_v / r_v;
  93.     } else if(expression.Op == "*") {
  94.         var = l_v * r_v;
  95.     } else if(expression.Op == "=") {
  96.         x = r_v;
  97.     } 
  98.  
  99.     return var;
  100. }
  101.  
  102.  
  103. template <class A, class B>
  104. int evalOut(ExprForOut<A,B> expression, int &x) {
  105.     ostream& left = cout;
  106.  
  107.     left << x;
  108. }
  109.  
  110. template <class A, class B>
  111. int evalOut(ostream& O, int &x) {
  112.     ostream& left = O;
  113.  
  114.     left << x;
  115.     return 0;
  116. }
  117.  
  118. template <class A, class B> int Expr<A, B> :: operator()(int &x) {
  119.     return eval(*this, x);
  120. }
  121.  
  122. template <class A, class B> int ExprForOut<A,B> :: operator()(int &x) {
  123.     return evalOut(*this, x);
  124. }
  125.  
  126. template <class A, class B> Expr <A,B> operator+(A a, B b) {
  127.     Expr <A, B> expression(a, b, "+");
  128.     return expression;
  129. }
  130.  
  131. template <class A, class B> Expr <A, B> operator-(A a, B b) {
  132.     Expr <A, B> expression(a, b, "-");
  133.     return expression;
  134. }
  135.  
  136. template <class A, class B> Expr <A, B> operator*(A a, B b) {
  137.     Expr <A, B> expression(a, b, "*");
  138.     return expression;
  139. }
  140.  
  141. template <class A, class B> Expr <A, B> operator/(A a, B b) {
  142.     Expr <A, B> expression(a, b, "/");
  143.     return expression;
  144. }
  145.  
  146. template <class A, class B> ExprForOut<A, B> operator<<(A a, B b) {
  147.     cout << "Reaching here in a, b" << endl;
  148.     ExprForOut<A,B> expression(a,b);
  149.     return expression;
  150. }
  151.  
  152.  
  153. //explicit placeholder definition for _1
  154. a2 _1;

^^ The evalOut is meant to overload the function, however, whenever i put in cout, it isn't identified as ostream& type. Any suggestions? Or am I really unclear?

Thanks!
May 17 '07 #1
Share this Question
Share on Google+
1 Reply


P: 2
just solved. don't worry about replying! it was a problem of me storing the output stream and not the reference to it!
May 17 '07 #2

Post your reply

Sign in to post your reply or Sign up for a free account.