Overoad operator<<

[ruchirp]

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

I want to make for_each(v.begi n(), 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 >

#include <string>
#include <iostream>
using namespace std;
 
//Expr class to evaluate expression
template <class A, class B>
class Expr {
 
public:
    A l_v;
    B r_v;
    string Op;
    //ostream l_s;
 
    Expr() { }
 
    Expr(A l, B r, string o) {
        l_v = l;
        r_v = r;
        Op = o;
    }
 
    int operator()(int &);
};
 
template <class A, class B>
class ExprForOut {
 
public:
    A l_s;
    B r_s;
 
    ExprForOut() { }
 
    ExprForOut(A l, B r) {
        l_s = l;
        r_s = r;
    }
 
    int operator()(int &);
};
 
//class a2 as a placeholder/expression call for _1 
class a2 {
 
public:
    a2() {
    }
 
    int operator()(int& x) {
        return x;
    }
 
    template <class B> Expr<a2, B> operator=(B b) {
        Expr<a2, B> expression(*this, b, "=");
        return expression;
    }
 
};
 
int clarifyExpr(int x, int y) {
    return x;
}
 
int clarifyExpr(a2 a, int x) {
    return x;
}
 
template <class A, class B> int clarifyExpr(Expr<A,B> expression, int x) {
    return eval(expression, x);
}
 
//Evaluation of the given expression
template <class A, class B> 
int eval(Expr<A,B> expression, int &x) {
    int var;
    int l_v;
    int r_v;
 
    if(expression.Op != "<<") {
        l_v = clarifyExpr(expression.l_v, x);
        r_v = clarifyExpr(expression.r_v, x);
    } 
 
    cout<< l_v << " : " << r_v << endl;
 
    if(expression.Op == "+") {
        var = l_v + r_v;
    } else if(expression.Op == "-") {
        var = l_v - r_v;
    } else if(expression.Op == "/") {
        var = l_v / r_v;
    } else if(expression.Op == "*") {
        var = l_v * r_v;
    } else if(expression.Op == "=") {
        x = r_v;
    } 
 
    return var;
}
 
 
template <class A, class B>
int evalOut(ExprForOut<A,B> expression, int &x) {
    ostream& left = cout;
 
    left << x;
}
 
template <class A, class B>
int evalOut(ostream& O, int &x) {
    ostream& left = O;
 
    left << x;
    return 0;
}
 
template <class A, class B> int Expr<A, B> :: operator()(int &x) {
    return eval(*this, x);
}
 
template <class A, class B> int ExprForOut<A,B> :: operator()(int &x) {
    return evalOut(*this, x);
}
 
template <class A, class B> Expr <A,B> operator+(A a, B b) {
    Expr <A, B> expression(a, b, "+");
    return expression;
}
 
template <class A, class B> Expr <A, B> operator-(A a, B b) {
    Expr <A, B> expression(a, b, "-");
    return expression;
}
 
template <class A, class B> Expr <A, B> operator*(A a, B b) {
    Expr <A, B> expression(a, b, "*");
    return expression;
}
 
template <class A, class B> Expr <A, B> operator/(A a, B b) {
    Expr <A, B> expression(a, b, "/");
    return expression;
}
 
template <class A, class B> ExprForOut<A, B> operator<<(A a, B b) {
    cout << "Reaching here in a, b" << endl;
    ExprForOut<A,B> expression(a,b);
    return expression;
}
 
 
//explicit placeholder definition for _1
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!

[ruchirp]

just solved. don't worry about replying! it was a problem of me storing the output stream and not the reference to it!