Ttykuu

You mean something like this:

class Z

 int& x;
 int& y;
public:
 Z(int& x, int& y) : x(x), y(y) 
 operator int() return x + y; 
;

The class delays calculation of the result until casted as int. As cast operator is not explicit, Z can be used whenever an int is required. As there's an overload of operator<< for int, you can use it with e. g. std::cout directly:

int x, y;
Z z(x, y);
std::cin >> x >> y;
if(std::cin) // otherwise, IO error! (e. g. bad user input)
 std::cout << z << std::endl;

The closest you probably can get is to create a functor:

#include <iostream>

int main() 
 int x;
 int y;

 auto z = [&x, &y] return x + y; ; // a lambda capturing x and y

 while(true) 
 std::cin >> x;
 std::cin >> y;
 std::cout << z() << "n";
 

There are two chief techniques:

1. Deferred calculation - instead of z being a simple variable, make it a function which calculates the value on demand (see other answers for examples). This can be source-code transparent if z is some proxy object with implicit conversion to the required type (as in Aconcagua's answer).




2. Explicit notification of changes. This requires x and y to be observable types; when either changes value, then z updates itself (and notifies its observers if applicable).

The first version is usually preferred, but the second may be more appropriate if you need z to be an observable type.

This sounds like the XY problem (pun intended).

From the sound of it, you are not really writing code according to good object oriented practices. I would advise you not to use the "tricks" other people have suggested, but to actually learn how to make better use of OO structure.

Before I go into that, note that assignment is distinct from an equality relation. The = in C++ is assignment, which is not the same as the = in maths. There are some (but not many) programming languages that do support equality relations, but C++ is not one of them. The thing is, adding support for equality relations introduces a heap of new challenges, so it's not as simple as "why isn't it in C++ yet".

Anyway, in this case, you should probably be encapsulating your related variables in a class. Then you can use methods to obtain the "up-to-date" information. For example:

class Player 
 std::vector<int> inventory;
 int cash;
public:
 int inventory_total();
 int net_worth();


//adds up total value of inventory
int Player::inventory_total() 
 int total = 0;
 for(std::vector<int>::iterator it = inventory.begin(); it != inventory.end(); ++it) 
 total += *it;
 
 return total;


//calculates net worth
int Player::net_worth() 
 //we are using inventory_total() as if it were a variable that automatically
 //holds the sum of the inventory values
 return inventory_total() + cash;



...


//we are using net_worth() as if it were a variable that automatically
//holds the sum of the cash and total holdings
std::cout << player1.net_worth();

I admit that adding this behaviour to a class is quite a bit more complicated than saying z = x + y, but it really is only a few extra lines of code.

That would be very annoying and error prone if you forgot to call the function somewhere.

In this case the object doesn't have a net_worth member variable, so you can't accidentally use it instead of calling the function.

1. You create a function for that.


2. You call the function with the appropriate arguments when you need the value.

int z(int x, int y)

 return (x + y);



int x;
int y;

// This does ot work
// int zx + y;

cin >> x;
cin >> y;
cout << z(x, y);

You can define the following lambda z which always returns the current value of x+y because x and y are captured by reference:

DEMO

int main()

 int x;
 int y;

 const auto z = [&x, &y]() return x+y; ;

 std::cin >> x; // 1
 std::cin >> y; // 2
 std::cout << z() << std::endl; // 3

 std::cin >> x; // 3
 std::cin >> y; // 4
 std::cout << z() << std::endl; // 7

So a big problem that I see with the lambda solutions provided is that z is calculated each time that it is inspected even if neither x nor y has changed. To get around this you really need to link these variables.
I would suggest doing that via class:

class foo 
 int x;
 int y;
 int z;
 void calculate() z = (x + y) / 2; 
 friend istream& operator >>(istream& lhs, foo& rhs);
public:
 void set_x(const int param) 
 x = param;
 calculate();
 
 int get_x() const return x; 
 void set_y(const int param) 
 y = param;
 calculate();
 
 int get_y() const return y; 
 int get_z() const return z; 
;

istream& operator >>(istream& lhs, foo& rhs) 
 lhs >> rhs.x >> rhs.y;
 rhs.calculate();
 return lhs;

This will recalculate z each time x or y is set. This is a good solution if you access z frequently, and x and y are set infrequently. If x and y are set frequently or calculate is expensive you might consider:

class foo 
 int x;
 int y;
 int z;
 bool dirty;
 void calculate() z = (x + y) / 2; 
 friend istream& operator >>(istream& lhs, foo& rhs);
public:
 void set_x(const int param) 
 x = param;
 dirty = true;
 
 int get_x() const return x; 
 void set_y(const int param) 
 y = param;
 dirty = true;
 
 int get_y() const return y; 
 int get_z() const 
 if(dirty) 
 calculate();
 
 return z;
 
;

istream& operator >>(istream& lhs, foo& rhs) 
 lhs >> rhs.x >> rhs.y;
 rhs.dirty = true;
 return lhs;

Note that I've included an extraction operator, so whichever you choose your code can turn into something as simple as:

foo xyz;

cin >> xyz;
cout << xyz.get_z();

You can get what you're asking for by using macros:

 int x, y;
#define z (x + y)
 /* use x, y, z */
#undef z

The #undef is for a little sanity. For more sanity, don't use macros at all, and go with one of the other answers, and deal with the extra verbosity.

Although a class with a custom operator int would work in a lot of cases ... hmm.