Library to store an "equation" involving references? - c++

Question

So I can pass by reference, and store that reference in a structure or class, and if I make changes elsewhere and check that reference again where I stored it the changes will be there because I'm just accessing the same memory.
Is there a library that will let me do something like this:
int foo = 9;
int bar = 5;
// obviously other arithmetic would exist too, and could be combined
Equation foo_minus_bar = Subtract(foo, bar);
// output: 4
cout << foo_minus_bar << endl;
foo = 11;
// output: 6
cout << foo_minus_bar << endl;
It would also be nice if I could access the inputs (preferably as a flat array or similar, but beggars can't be choosers, and maybe even something like this:
// literal character for character output: foo - bar
cout << foo_minus_bar.formula() << endl;
I could make one myself, but I'd rather not reinvent the wheel if it exists.

Answer 1

The question of OP reminds me to another answer where I modeled an AST for a small example compiler with functor-like classes: The Tiny Calculator Project.
In that project the AST expression nodes have ownership of their child (expression) nodes.
I'm not sure whether I read the intention of OP correctly but, of course, it can be designed as well with expression nodes which don't have ownership of child (expression) nodes.
Thus, I made another (even shorter) example. Additionally, I overloaded operator()() (instead of a virtual solve() member function). Though, in this case, I consider it as a matter of taste.
Sample code:
#include <iostream>
struct Expr {
virtual int operator()() const = 0;
};
struct ExprConst: Expr {
const int value;
ExprConst(int value): value(value) { }
virtual int operator()() const { return value; }
};
struct ExprRef: Expr {
const int &ref;
ExprRef(const int &ref): ref(ref) { }
virtual int operator()() const { return ref; }
};
struct ExprBin: Expr {
const Expr &arg1, &arg2;
ExprBin(const Expr &arg1, const Expr &arg2):
arg1(arg1), arg2(arg2)
{ }
};
struct ExprSub: ExprBin {
ExprSub(const Expr &arg1, const Expr &arg2):
ExprBin(arg1, arg2)
{ }
virtual int operator()() const { return arg1() - arg2(); }
};
int main()
{
int foo = 9;
int bar = 5;
ExprRef exprFoo(foo), exprBar(bar);
ExprSub exprSub(exprFoo, exprBar);
std::cout << "foo - bar: " << exprSub() << '\n';
std::cout << "foo = 7; bar = 10;\n";
foo = 7; bar = 10;
std::cout << "foo - bar: " << exprSub() << '\n';
// done
return 0;
}
Output:
foo - bar: 4
foo = 7; bar = 10;
foo - bar: -3
Live Demo on coliru