How do I make a variable always equal to the result of some calculations?












26















In math, if z = x+y/2, then z will always change whenever we replace the value of x and y. Can we do that in programming without having to specifically updating z whenever we change the value of x and y?



I mean something like that won't work, right?



int x;
int y;
int z{x + y};
cin >> x;
cin >> y;
cout << z;


If you're confused why I would need that, I want the variable shown live, and get it updated automatically when a rhs-variable make changes.



Like when killing a creep and get gold, then the net-worth (cash+worth of own items) shown changes. Or the speed meter of a car changing depending on how slow or fast you're driving.










share|improve this question









New contributor




Nay Wunna Zaw is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
Check out our Code of Conduct.
















  • 2





    Right, that won't work. That's a spreadsheet thing.

    – Pete Becker
    yesterday






  • 2





    @RobertAndrzejuk Because it'd be very useful. For example, if you write a game and have something like networth(cash+the worth of all you own). You will have to call the function of networth everytime one of those update. That would be very annoying and error prone if you forgot to call the function somewhere.

    – Nay Wunna Zaw
    yesterday






  • 19





    @NayWunnaZaw In my experience this is why getters and setters are encouraged over direct variable access. If you always wanted networth to be updated, you could retrieve the value using getNetWorth() which would itself call updateNetWorth() before returning the value... or just calculate it before returning it.

    – Onyz
    yesterday






  • 34





    That's called a "function."

    – ApproachingDarknessFish
    yesterday






  • 2





    @Nat: This is something GMP's C++ interface does; operators produce progressively more complex expression trees until assigned to mpz_class, at which point the expression tree is evaluated to produce the final result. It allows expressions like a += b * c; to collapse to (ignoring accessor functions involved) mpz_addmul(a, b, c) (which is an optimized one-operation version of the above), rather than creating a temporary t and do mpz_mul(t, b, c) followed by mpz_add(a, a, t) followed by cleaning t. It's a production version of this.

    – ShadowRanger
    9 hours ago
















26















In math, if z = x+y/2, then z will always change whenever we replace the value of x and y. Can we do that in programming without having to specifically updating z whenever we change the value of x and y?



I mean something like that won't work, right?



int x;
int y;
int z{x + y};
cin >> x;
cin >> y;
cout << z;


If you're confused why I would need that, I want the variable shown live, and get it updated automatically when a rhs-variable make changes.



Like when killing a creep and get gold, then the net-worth (cash+worth of own items) shown changes. Or the speed meter of a car changing depending on how slow or fast you're driving.










share|improve this question









New contributor




Nay Wunna Zaw is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
Check out our Code of Conduct.
















  • 2





    Right, that won't work. That's a spreadsheet thing.

    – Pete Becker
    yesterday






  • 2





    @RobertAndrzejuk Because it'd be very useful. For example, if you write a game and have something like networth(cash+the worth of all you own). You will have to call the function of networth everytime one of those update. That would be very annoying and error prone if you forgot to call the function somewhere.

    – Nay Wunna Zaw
    yesterday






  • 19





    @NayWunnaZaw In my experience this is why getters and setters are encouraged over direct variable access. If you always wanted networth to be updated, you could retrieve the value using getNetWorth() which would itself call updateNetWorth() before returning the value... or just calculate it before returning it.

    – Onyz
    yesterday






  • 34





    That's called a "function."

    – ApproachingDarknessFish
    yesterday






  • 2





    @Nat: This is something GMP's C++ interface does; operators produce progressively more complex expression trees until assigned to mpz_class, at which point the expression tree is evaluated to produce the final result. It allows expressions like a += b * c; to collapse to (ignoring accessor functions involved) mpz_addmul(a, b, c) (which is an optimized one-operation version of the above), rather than creating a temporary t and do mpz_mul(t, b, c) followed by mpz_add(a, a, t) followed by cleaning t. It's a production version of this.

    – ShadowRanger
    9 hours ago














26












26








26


6






In math, if z = x+y/2, then z will always change whenever we replace the value of x and y. Can we do that in programming without having to specifically updating z whenever we change the value of x and y?



I mean something like that won't work, right?



int x;
int y;
int z{x + y};
cin >> x;
cin >> y;
cout << z;


If you're confused why I would need that, I want the variable shown live, and get it updated automatically when a rhs-variable make changes.



Like when killing a creep and get gold, then the net-worth (cash+worth of own items) shown changes. Or the speed meter of a car changing depending on how slow or fast you're driving.










share|improve this question









New contributor




Nay Wunna Zaw is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
Check out our Code of Conduct.












In math, if z = x+y/2, then z will always change whenever we replace the value of x and y. Can we do that in programming without having to specifically updating z whenever we change the value of x and y?



I mean something like that won't work, right?



int x;
int y;
int z{x + y};
cin >> x;
cin >> y;
cout << z;


If you're confused why I would need that, I want the variable shown live, and get it updated automatically when a rhs-variable make changes.



Like when killing a creep and get gold, then the net-worth (cash+worth of own items) shown changes. Or the speed meter of a car changing depending on how slow or fast you're driving.







c++ c++11






share|improve this question









New contributor




Nay Wunna Zaw is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
Check out our Code of Conduct.











share|improve this question









New contributor




Nay Wunna Zaw is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
Check out our Code of Conduct.









share|improve this question




share|improve this question








edited 1 hour ago









Peter Mortensen

13.8k1987113




13.8k1987113






New contributor




Nay Wunna Zaw is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
Check out our Code of Conduct.









asked yesterday









Nay Wunna ZawNay Wunna Zaw

138211




138211




New contributor




Nay Wunna Zaw is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
Check out our Code of Conduct.





New contributor





Nay Wunna Zaw is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
Check out our Code of Conduct.






Nay Wunna Zaw is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
Check out our Code of Conduct.








  • 2





    Right, that won't work. That's a spreadsheet thing.

    – Pete Becker
    yesterday






  • 2





    @RobertAndrzejuk Because it'd be very useful. For example, if you write a game and have something like networth(cash+the worth of all you own). You will have to call the function of networth everytime one of those update. That would be very annoying and error prone if you forgot to call the function somewhere.

    – Nay Wunna Zaw
    yesterday






  • 19





    @NayWunnaZaw In my experience this is why getters and setters are encouraged over direct variable access. If you always wanted networth to be updated, you could retrieve the value using getNetWorth() which would itself call updateNetWorth() before returning the value... or just calculate it before returning it.

    – Onyz
    yesterday






  • 34





    That's called a "function."

    – ApproachingDarknessFish
    yesterday






  • 2





    @Nat: This is something GMP's C++ interface does; operators produce progressively more complex expression trees until assigned to mpz_class, at which point the expression tree is evaluated to produce the final result. It allows expressions like a += b * c; to collapse to (ignoring accessor functions involved) mpz_addmul(a, b, c) (which is an optimized one-operation version of the above), rather than creating a temporary t and do mpz_mul(t, b, c) followed by mpz_add(a, a, t) followed by cleaning t. It's a production version of this.

    – ShadowRanger
    9 hours ago














  • 2





    Right, that won't work. That's a spreadsheet thing.

    – Pete Becker
    yesterday






  • 2





    @RobertAndrzejuk Because it'd be very useful. For example, if you write a game and have something like networth(cash+the worth of all you own). You will have to call the function of networth everytime one of those update. That would be very annoying and error prone if you forgot to call the function somewhere.

    – Nay Wunna Zaw
    yesterday






  • 19





    @NayWunnaZaw In my experience this is why getters and setters are encouraged over direct variable access. If you always wanted networth to be updated, you could retrieve the value using getNetWorth() which would itself call updateNetWorth() before returning the value... or just calculate it before returning it.

    – Onyz
    yesterday






  • 34





    That's called a "function."

    – ApproachingDarknessFish
    yesterday






  • 2





    @Nat: This is something GMP's C++ interface does; operators produce progressively more complex expression trees until assigned to mpz_class, at which point the expression tree is evaluated to produce the final result. It allows expressions like a += b * c; to collapse to (ignoring accessor functions involved) mpz_addmul(a, b, c) (which is an optimized one-operation version of the above), rather than creating a temporary t and do mpz_mul(t, b, c) followed by mpz_add(a, a, t) followed by cleaning t. It's a production version of this.

    – ShadowRanger
    9 hours ago








2




2





Right, that won't work. That's a spreadsheet thing.

– Pete Becker
yesterday





Right, that won't work. That's a spreadsheet thing.

– Pete Becker
yesterday




2




2





@RobertAndrzejuk Because it'd be very useful. For example, if you write a game and have something like networth(cash+the worth of all you own). You will have to call the function of networth everytime one of those update. That would be very annoying and error prone if you forgot to call the function somewhere.

– Nay Wunna Zaw
yesterday





@RobertAndrzejuk Because it'd be very useful. For example, if you write a game and have something like networth(cash+the worth of all you own). You will have to call the function of networth everytime one of those update. That would be very annoying and error prone if you forgot to call the function somewhere.

– Nay Wunna Zaw
yesterday




19




19





@NayWunnaZaw In my experience this is why getters and setters are encouraged over direct variable access. If you always wanted networth to be updated, you could retrieve the value using getNetWorth() which would itself call updateNetWorth() before returning the value... or just calculate it before returning it.

– Onyz
yesterday





@NayWunnaZaw In my experience this is why getters and setters are encouraged over direct variable access. If you always wanted networth to be updated, you could retrieve the value using getNetWorth() which would itself call updateNetWorth() before returning the value... or just calculate it before returning it.

– Onyz
yesterday




34




34





That's called a "function."

– ApproachingDarknessFish
yesterday





That's called a "function."

– ApproachingDarknessFish
yesterday




2




2





@Nat: This is something GMP's C++ interface does; operators produce progressively more complex expression trees until assigned to mpz_class, at which point the expression tree is evaluated to produce the final result. It allows expressions like a += b * c; to collapse to (ignoring accessor functions involved) mpz_addmul(a, b, c) (which is an optimized one-operation version of the above), rather than creating a temporary t and do mpz_mul(t, b, c) followed by mpz_add(a, a, t) followed by cleaning t. It's a production version of this.

– ShadowRanger
9 hours ago





@Nat: This is something GMP's C++ interface does; operators produce progressively more complex expression trees until assigned to mpz_class, at which point the expression tree is evaluated to produce the final result. It allows expressions like a += b * c; to collapse to (ignoring accessor functions involved) mpz_addmul(a, b, c) (which is an optimized one-operation version of the above), rather than creating a temporary t and do mpz_mul(t, b, c) followed by mpz_add(a, a, t) followed by cleaning t. It's a production version of this.

– ShadowRanger
9 hours ago












9 Answers
9






active

oldest

votes


















32














You can get close to this with by using a lambda in C++. Generally, when you set a variable like



int x;
int y;
int z{x + y};


z will only be the result of x + y at that time. You'd have to do z = x + y; every time you change x or y to keep it update.



If you use a lambda though, you can have it capture what objects it should refer to, and what calculation should be done, and then every time you access the lambda it will give you the result at that point in time. That looks like



int x;
int y;
auto z = [&](){ return x + y; };
cin >> x;
cin >> y;
cout << z();


and now z() will have the correct value instead of the uninitialized garbage that the original code had.



If the computation is very expensive you can even add some caching to the lambda to make sure you aren't running the computation when you don't need to. That would look like



auto z = [&](){ static auto cache_x = x; 
static auto cache_y = y;
static auto cache_result = x + y;
if (x != cache_x || y != cache_y)
{
cache_x = x;
cache_y = y;
cache_result = x + y;
}
return cache_result;
};





share|improve this answer





















  • 1





    Also, at that point you should not repeat the cache code for each kind of lambda. A class encapsulation is pretty much required there.

    – Max Langhof
    yesterday






  • 6





    And a class can be used to avoid the z() syntax as well: coliru.stacked-crooked.com/a/3c3dafe9856c28b8

    – Mooing Duck
    yesterday











  • @MooingDuck That's awesome! I didn't think it was possible. It deserves to be an answer on its own!

    – Fabio Turati
    yesterday











  • @FabioTurati See Aconcagua's answer

    – NathanOliver
    yesterday






  • 6





    Erm you probably don't want static for caching... lambdas can be stateful for a reason.

    – Mehrdad
    19 hours ago





















24














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;





share|improve this answer
























  • while this could work whenever we need z, this requires a whole class to be created only for one variable. so i'm preferring the lambda method to be chosen as answer.

    – Nay Wunna Zaw
    11 hours ago






  • 2





    @NayWunnaZaw: If it's a one-off usage, sure, use the lambda. But if your code has multiple places where dynamic types like this are needed, a slightly more complex class (templated, receiving a function, e.g. one of the operator wrappers like std::plus) would be only a little longer at time of definition, while supporting reuse without redefining a fairly subtle thing at each point of use. I think this is the better answer for when this is a pattern, not merely a one-off trick.

    – ShadowRanger
    9 hours ago











  • @ShadowRanger Yes, I understand that. But it'd be off topic if I accept the class type answer. What I asked is a variable which will get updated whenever x and y are changed. So I think lambda is an appropriate answer for my question.

    – Nay Wunna Zaw
    7 hours ago






  • 2





    @NayWunnaZaw: BTW, just to be clear: You realize lambdas are (unnamed) classes, right? They're syntactic sugar around functors (the captures are instance attributes, and the arguments are arguments to operator()) so in both cases a class exists (or doesn't exist due to inlining). This explicitly overrides operator int (so implicit conversion does the trick), where lambdas implicitly override operator() (so explicit call parens are needed), otherwise they're the same. It's fine if you prefer the lambda for code brevity, but in terms of what actually runs, both of them involve classes.

    – ShadowRanger
    7 hours ago





















19














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";
}
}





share|improve this answer































    10














    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.






    share|improve this answer


























    • The observation approach is interesting, too, if calculations to be done are expensive. Appropriately implemented, I consider it more elegant than the caching proposed by NathanOliver...

      – Aconcagua
      16 hours ago






    • 1





      @Aconcagua, amend that to: if calculations to be done are expensive and reads are more frequent than updates. Otherwise, we need to add a way to avoid computing values that don't get used.

      – Toby Speight
      13 hours ago



















    4














    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.






    share|improve this answer


























    • can you give me the pros and cons of using lambdas vs this? which would be better practice?

      – Nay Wunna Zaw
      12 hours ago











    • Yes, this is the (real) answer I would expect. Unfortunately, there is FGITW (I think it is a real problem).

      – Peter Mortensen
      32 mins ago



















    3















    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 z{x + y};

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





    share|improve this answer



















    • 1





      yes, i mean the only way to get z updated is to call that function everytime we change x and y values?

      – Nay Wunna Zaw
      yesterday











    • @NayWunnaZaw, yes, that is correct.

      – R Sahu
      yesterday






    • 1





      @NayWunnaZaw, you can avoid the repeated use of x and y by using a lambda function, as shown by Nathan but you still have to make the call.

      – R Sahu
      yesterday






    • 4





      @NayWunnaZaw To complete the issue: Even with my solution, there is a function call (to the cast operator!), just that it is implicit and not required explicitly...

      – Aconcagua
      yesterday



















    2














    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
    }





    share|improve this answer





















    • 2





      Don't use parentheses around return values – return is not a function, and in worst case, the parentheses can even create a dangling reference (with return type being decltype(auto)).

      – Aconcagua
      yesterday











    • @Aconcagua thx! you are right. I edited my answer.

      – Hiroki
      yesterday













    • Why downvoted ? At least I posted my answer faster than Ted with my tested code. Hmm... :)

      – Hiroki
      16 hours ago








    • 1





      Well, I didn't and wouldn't have considered the parentheses worth doing so either. If they were the reason – well, people tend to never come back to remove a DV even if the answer was fixed, so (I don't think there's a notification for either, so people might just not even recognise...)

      – Aconcagua
      16 hours ago











    • @Aconcagua thx for your comment. Although I was downvoted after few hours later of my edition, I was relieved to hear your words.

      – Hiroki
      5 hours ago



















    1














    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();





    share|improve this answer
























    • I don't quite understand how lambda work. But if you've played dota you'd know how gold in the game work. The way it is displayed all the time and adding 1 gold every split-second. I'm asking this question with that in mind. How do I implement that in c++?

      – Nay Wunna Zaw
      7 hours ago






    • 1





      @NayWunnaZaw I mean generally you're going to have a main class which calls the tick function on any class that needs live updating, passing in a time elapsed since last tick parameter. You'd probably have a player class instead of just the simple foo which would do loads of things. Like the player class's tick would need to update the damage of poison effects, calculate cooldown times, and also calculate gold. I recognize this is probably a gross over simplification. But I do think you're going to want to go with a class here.

      – Jonathan Mee
      7 hours ago











    • thanks for that, but I like lambda answer more for it's simplicity for a variable. and that fits my question. And class type solution should be used instead if we plan on using the equation more than once like shadowranger said up there.

      – Nay Wunna Zaw
      7 hours ago



















    0














    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.






    share|improve this answer
























    • Although this could use an EXTREME CAUTION warning, I think it is worth mentioning. Sometimes quick'n'dirty is called for. I have used tricks like this to save time in programming competitions, or in mindless repetitive matrix calculations that would be a lot more verbose and/or bug-prone using any other approach.

      – Artelius
      19 hours ago














    Your Answer






    StackExchange.ifUsing("editor", function () {
    StackExchange.using("externalEditor", function () {
    StackExchange.using("snippets", function () {
    StackExchange.snippets.init();
    });
    });
    }, "code-snippets");

    StackExchange.ready(function() {
    var channelOptions = {
    tags: "".split(" "),
    id: "1"
    };
    initTagRenderer("".split(" "), "".split(" "), channelOptions);

    StackExchange.using("externalEditor", function() {
    // Have to fire editor after snippets, if snippets enabled
    if (StackExchange.settings.snippets.snippetsEnabled) {
    StackExchange.using("snippets", function() {
    createEditor();
    });
    }
    else {
    createEditor();
    }
    });

    function createEditor() {
    StackExchange.prepareEditor({
    heartbeatType: 'answer',
    autoActivateHeartbeat: false,
    convertImagesToLinks: true,
    noModals: true,
    showLowRepImageUploadWarning: true,
    reputationToPostImages: 10,
    bindNavPrevention: true,
    postfix: "",
    imageUploader: {
    brandingHtml: "Powered by u003ca class="icon-imgur-white" href="https://imgur.com/"u003eu003c/au003e",
    contentPolicyHtml: "User contributions licensed under u003ca href="https://creativecommons.org/licenses/by-sa/3.0/"u003ecc by-sa 3.0 with attribution requiredu003c/au003e u003ca href="https://stackoverflow.com/legal/content-policy"u003e(content policy)u003c/au003e",
    allowUrls: true
    },
    onDemand: true,
    discardSelector: ".discard-answer"
    ,immediatelyShowMarkdownHelp:true
    });


    }
    });






    Nay Wunna Zaw is a new contributor. Be nice, and check out our Code of Conduct.










    draft saved

    draft discarded


















    StackExchange.ready(
    function () {
    StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fstackoverflow.com%2fquestions%2f55402807%2fhow-do-i-make-a-variable-always-equal-to-the-result-of-some-calculations%23new-answer', 'question_page');
    }
    );

    Post as a guest















    Required, but never shown

























    9 Answers
    9






    active

    oldest

    votes








    9 Answers
    9






    active

    oldest

    votes









    active

    oldest

    votes






    active

    oldest

    votes









    32














    You can get close to this with by using a lambda in C++. Generally, when you set a variable like



    int x;
    int y;
    int z{x + y};


    z will only be the result of x + y at that time. You'd have to do z = x + y; every time you change x or y to keep it update.



    If you use a lambda though, you can have it capture what objects it should refer to, and what calculation should be done, and then every time you access the lambda it will give you the result at that point in time. That looks like



    int x;
    int y;
    auto z = [&](){ return x + y; };
    cin >> x;
    cin >> y;
    cout << z();


    and now z() will have the correct value instead of the uninitialized garbage that the original code had.



    If the computation is very expensive you can even add some caching to the lambda to make sure you aren't running the computation when you don't need to. That would look like



    auto z = [&](){ static auto cache_x = x; 
    static auto cache_y = y;
    static auto cache_result = x + y;
    if (x != cache_x || y != cache_y)
    {
    cache_x = x;
    cache_y = y;
    cache_result = x + y;
    }
    return cache_result;
    };





    share|improve this answer





















    • 1





      Also, at that point you should not repeat the cache code for each kind of lambda. A class encapsulation is pretty much required there.

      – Max Langhof
      yesterday






    • 6





      And a class can be used to avoid the z() syntax as well: coliru.stacked-crooked.com/a/3c3dafe9856c28b8

      – Mooing Duck
      yesterday











    • @MooingDuck That's awesome! I didn't think it was possible. It deserves to be an answer on its own!

      – Fabio Turati
      yesterday











    • @FabioTurati See Aconcagua's answer

      – NathanOliver
      yesterday






    • 6





      Erm you probably don't want static for caching... lambdas can be stateful for a reason.

      – Mehrdad
      19 hours ago


















    32














    You can get close to this with by using a lambda in C++. Generally, when you set a variable like



    int x;
    int y;
    int z{x + y};


    z will only be the result of x + y at that time. You'd have to do z = x + y; every time you change x or y to keep it update.



    If you use a lambda though, you can have it capture what objects it should refer to, and what calculation should be done, and then every time you access the lambda it will give you the result at that point in time. That looks like



    int x;
    int y;
    auto z = [&](){ return x + y; };
    cin >> x;
    cin >> y;
    cout << z();


    and now z() will have the correct value instead of the uninitialized garbage that the original code had.



    If the computation is very expensive you can even add some caching to the lambda to make sure you aren't running the computation when you don't need to. That would look like



    auto z = [&](){ static auto cache_x = x; 
    static auto cache_y = y;
    static auto cache_result = x + y;
    if (x != cache_x || y != cache_y)
    {
    cache_x = x;
    cache_y = y;
    cache_result = x + y;
    }
    return cache_result;
    };





    share|improve this answer





















    • 1





      Also, at that point you should not repeat the cache code for each kind of lambda. A class encapsulation is pretty much required there.

      – Max Langhof
      yesterday






    • 6





      And a class can be used to avoid the z() syntax as well: coliru.stacked-crooked.com/a/3c3dafe9856c28b8

      – Mooing Duck
      yesterday











    • @MooingDuck That's awesome! I didn't think it was possible. It deserves to be an answer on its own!

      – Fabio Turati
      yesterday











    • @FabioTurati See Aconcagua's answer

      – NathanOliver
      yesterday






    • 6





      Erm you probably don't want static for caching... lambdas can be stateful for a reason.

      – Mehrdad
      19 hours ago
















    32












    32








    32







    You can get close to this with by using a lambda in C++. Generally, when you set a variable like



    int x;
    int y;
    int z{x + y};


    z will only be the result of x + y at that time. You'd have to do z = x + y; every time you change x or y to keep it update.



    If you use a lambda though, you can have it capture what objects it should refer to, and what calculation should be done, and then every time you access the lambda it will give you the result at that point in time. That looks like



    int x;
    int y;
    auto z = [&](){ return x + y; };
    cin >> x;
    cin >> y;
    cout << z();


    and now z() will have the correct value instead of the uninitialized garbage that the original code had.



    If the computation is very expensive you can even add some caching to the lambda to make sure you aren't running the computation when you don't need to. That would look like



    auto z = [&](){ static auto cache_x = x; 
    static auto cache_y = y;
    static auto cache_result = x + y;
    if (x != cache_x || y != cache_y)
    {
    cache_x = x;
    cache_y = y;
    cache_result = x + y;
    }
    return cache_result;
    };





    share|improve this answer















    You can get close to this with by using a lambda in C++. Generally, when you set a variable like



    int x;
    int y;
    int z{x + y};


    z will only be the result of x + y at that time. You'd have to do z = x + y; every time you change x or y to keep it update.



    If you use a lambda though, you can have it capture what objects it should refer to, and what calculation should be done, and then every time you access the lambda it will give you the result at that point in time. That looks like



    int x;
    int y;
    auto z = [&](){ return x + y; };
    cin >> x;
    cin >> y;
    cout << z();


    and now z() will have the correct value instead of the uninitialized garbage that the original code had.



    If the computation is very expensive you can even add some caching to the lambda to make sure you aren't running the computation when you don't need to. That would look like



    auto z = [&](){ static auto cache_x = x; 
    static auto cache_y = y;
    static auto cache_result = x + y;
    if (x != cache_x || y != cache_y)
    {
    cache_x = x;
    cache_y = y;
    cache_result = x + y;
    }
    return cache_result;
    };






    share|improve this answer














    share|improve this answer



    share|improve this answer








    edited 9 hours ago









    J.G.

    1259




    1259










    answered yesterday









    NathanOliverNathanOliver

    97.3k16138214




    97.3k16138214








    • 1





      Also, at that point you should not repeat the cache code for each kind of lambda. A class encapsulation is pretty much required there.

      – Max Langhof
      yesterday






    • 6





      And a class can be used to avoid the z() syntax as well: coliru.stacked-crooked.com/a/3c3dafe9856c28b8

      – Mooing Duck
      yesterday











    • @MooingDuck That's awesome! I didn't think it was possible. It deserves to be an answer on its own!

      – Fabio Turati
      yesterday











    • @FabioTurati See Aconcagua's answer

      – NathanOliver
      yesterday






    • 6





      Erm you probably don't want static for caching... lambdas can be stateful for a reason.

      – Mehrdad
      19 hours ago
















    • 1





      Also, at that point you should not repeat the cache code for each kind of lambda. A class encapsulation is pretty much required there.

      – Max Langhof
      yesterday






    • 6





      And a class can be used to avoid the z() syntax as well: coliru.stacked-crooked.com/a/3c3dafe9856c28b8

      – Mooing Duck
      yesterday











    • @MooingDuck That's awesome! I didn't think it was possible. It deserves to be an answer on its own!

      – Fabio Turati
      yesterday











    • @FabioTurati See Aconcagua's answer

      – NathanOliver
      yesterday






    • 6





      Erm you probably don't want static for caching... lambdas can be stateful for a reason.

      – Mehrdad
      19 hours ago










    1




    1





    Also, at that point you should not repeat the cache code for each kind of lambda. A class encapsulation is pretty much required there.

    – Max Langhof
    yesterday





    Also, at that point you should not repeat the cache code for each kind of lambda. A class encapsulation is pretty much required there.

    – Max Langhof
    yesterday




    6




    6





    And a class can be used to avoid the z() syntax as well: coliru.stacked-crooked.com/a/3c3dafe9856c28b8

    – Mooing Duck
    yesterday





    And a class can be used to avoid the z() syntax as well: coliru.stacked-crooked.com/a/3c3dafe9856c28b8

    – Mooing Duck
    yesterday













    @MooingDuck That's awesome! I didn't think it was possible. It deserves to be an answer on its own!

    – Fabio Turati
    yesterday





    @MooingDuck That's awesome! I didn't think it was possible. It deserves to be an answer on its own!

    – Fabio Turati
    yesterday













    @FabioTurati See Aconcagua's answer

    – NathanOliver
    yesterday





    @FabioTurati See Aconcagua's answer

    – NathanOliver
    yesterday




    6




    6





    Erm you probably don't want static for caching... lambdas can be stateful for a reason.

    – Mehrdad
    19 hours ago







    Erm you probably don't want static for caching... lambdas can be stateful for a reason.

    – Mehrdad
    19 hours ago















    24














    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;





    share|improve this answer
























    • while this could work whenever we need z, this requires a whole class to be created only for one variable. so i'm preferring the lambda method to be chosen as answer.

      – Nay Wunna Zaw
      11 hours ago






    • 2





      @NayWunnaZaw: If it's a one-off usage, sure, use the lambda. But if your code has multiple places where dynamic types like this are needed, a slightly more complex class (templated, receiving a function, e.g. one of the operator wrappers like std::plus) would be only a little longer at time of definition, while supporting reuse without redefining a fairly subtle thing at each point of use. I think this is the better answer for when this is a pattern, not merely a one-off trick.

      – ShadowRanger
      9 hours ago











    • @ShadowRanger Yes, I understand that. But it'd be off topic if I accept the class type answer. What I asked is a variable which will get updated whenever x and y are changed. So I think lambda is an appropriate answer for my question.

      – Nay Wunna Zaw
      7 hours ago






    • 2





      @NayWunnaZaw: BTW, just to be clear: You realize lambdas are (unnamed) classes, right? They're syntactic sugar around functors (the captures are instance attributes, and the arguments are arguments to operator()) so in both cases a class exists (or doesn't exist due to inlining). This explicitly overrides operator int (so implicit conversion does the trick), where lambdas implicitly override operator() (so explicit call parens are needed), otherwise they're the same. It's fine if you prefer the lambda for code brevity, but in terms of what actually runs, both of them involve classes.

      – ShadowRanger
      7 hours ago


















    24














    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;





    share|improve this answer
























    • while this could work whenever we need z, this requires a whole class to be created only for one variable. so i'm preferring the lambda method to be chosen as answer.

      – Nay Wunna Zaw
      11 hours ago






    • 2





      @NayWunnaZaw: If it's a one-off usage, sure, use the lambda. But if your code has multiple places where dynamic types like this are needed, a slightly more complex class (templated, receiving a function, e.g. one of the operator wrappers like std::plus) would be only a little longer at time of definition, while supporting reuse without redefining a fairly subtle thing at each point of use. I think this is the better answer for when this is a pattern, not merely a one-off trick.

      – ShadowRanger
      9 hours ago











    • @ShadowRanger Yes, I understand that. But it'd be off topic if I accept the class type answer. What I asked is a variable which will get updated whenever x and y are changed. So I think lambda is an appropriate answer for my question.

      – Nay Wunna Zaw
      7 hours ago






    • 2





      @NayWunnaZaw: BTW, just to be clear: You realize lambdas are (unnamed) classes, right? They're syntactic sugar around functors (the captures are instance attributes, and the arguments are arguments to operator()) so in both cases a class exists (or doesn't exist due to inlining). This explicitly overrides operator int (so implicit conversion does the trick), where lambdas implicitly override operator() (so explicit call parens are needed), otherwise they're the same. It's fine if you prefer the lambda for code brevity, but in terms of what actually runs, both of them involve classes.

      – ShadowRanger
      7 hours ago
















    24












    24








    24







    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;





    share|improve this answer













    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;






    share|improve this answer












    share|improve this answer



    share|improve this answer










    answered yesterday









    AconcaguaAconcagua

    13.1k32145




    13.1k32145













    • while this could work whenever we need z, this requires a whole class to be created only for one variable. so i'm preferring the lambda method to be chosen as answer.

      – Nay Wunna Zaw
      11 hours ago






    • 2





      @NayWunnaZaw: If it's a one-off usage, sure, use the lambda. But if your code has multiple places where dynamic types like this are needed, a slightly more complex class (templated, receiving a function, e.g. one of the operator wrappers like std::plus) would be only a little longer at time of definition, while supporting reuse without redefining a fairly subtle thing at each point of use. I think this is the better answer for when this is a pattern, not merely a one-off trick.

      – ShadowRanger
      9 hours ago











    • @ShadowRanger Yes, I understand that. But it'd be off topic if I accept the class type answer. What I asked is a variable which will get updated whenever x and y are changed. So I think lambda is an appropriate answer for my question.

      – Nay Wunna Zaw
      7 hours ago






    • 2





      @NayWunnaZaw: BTW, just to be clear: You realize lambdas are (unnamed) classes, right? They're syntactic sugar around functors (the captures are instance attributes, and the arguments are arguments to operator()) so in both cases a class exists (or doesn't exist due to inlining). This explicitly overrides operator int (so implicit conversion does the trick), where lambdas implicitly override operator() (so explicit call parens are needed), otherwise they're the same. It's fine if you prefer the lambda for code brevity, but in terms of what actually runs, both of them involve classes.

      – ShadowRanger
      7 hours ago





















    • while this could work whenever we need z, this requires a whole class to be created only for one variable. so i'm preferring the lambda method to be chosen as answer.

      – Nay Wunna Zaw
      11 hours ago






    • 2





      @NayWunnaZaw: If it's a one-off usage, sure, use the lambda. But if your code has multiple places where dynamic types like this are needed, a slightly more complex class (templated, receiving a function, e.g. one of the operator wrappers like std::plus) would be only a little longer at time of definition, while supporting reuse without redefining a fairly subtle thing at each point of use. I think this is the better answer for when this is a pattern, not merely a one-off trick.

      – ShadowRanger
      9 hours ago











    • @ShadowRanger Yes, I understand that. But it'd be off topic if I accept the class type answer. What I asked is a variable which will get updated whenever x and y are changed. So I think lambda is an appropriate answer for my question.

      – Nay Wunna Zaw
      7 hours ago






    • 2





      @NayWunnaZaw: BTW, just to be clear: You realize lambdas are (unnamed) classes, right? They're syntactic sugar around functors (the captures are instance attributes, and the arguments are arguments to operator()) so in both cases a class exists (or doesn't exist due to inlining). This explicitly overrides operator int (so implicit conversion does the trick), where lambdas implicitly override operator() (so explicit call parens are needed), otherwise they're the same. It's fine if you prefer the lambda for code brevity, but in terms of what actually runs, both of them involve classes.

      – ShadowRanger
      7 hours ago



















    while this could work whenever we need z, this requires a whole class to be created only for one variable. so i'm preferring the lambda method to be chosen as answer.

    – Nay Wunna Zaw
    11 hours ago





    while this could work whenever we need z, this requires a whole class to be created only for one variable. so i'm preferring the lambda method to be chosen as answer.

    – Nay Wunna Zaw
    11 hours ago




    2




    2





    @NayWunnaZaw: If it's a one-off usage, sure, use the lambda. But if your code has multiple places where dynamic types like this are needed, a slightly more complex class (templated, receiving a function, e.g. one of the operator wrappers like std::plus) would be only a little longer at time of definition, while supporting reuse without redefining a fairly subtle thing at each point of use. I think this is the better answer for when this is a pattern, not merely a one-off trick.

    – ShadowRanger
    9 hours ago





    @NayWunnaZaw: If it's a one-off usage, sure, use the lambda. But if your code has multiple places where dynamic types like this are needed, a slightly more complex class (templated, receiving a function, e.g. one of the operator wrappers like std::plus) would be only a little longer at time of definition, while supporting reuse without redefining a fairly subtle thing at each point of use. I think this is the better answer for when this is a pattern, not merely a one-off trick.

    – ShadowRanger
    9 hours ago













    @ShadowRanger Yes, I understand that. But it'd be off topic if I accept the class type answer. What I asked is a variable which will get updated whenever x and y are changed. So I think lambda is an appropriate answer for my question.

    – Nay Wunna Zaw
    7 hours ago





    @ShadowRanger Yes, I understand that. But it'd be off topic if I accept the class type answer. What I asked is a variable which will get updated whenever x and y are changed. So I think lambda is an appropriate answer for my question.

    – Nay Wunna Zaw
    7 hours ago




    2




    2





    @NayWunnaZaw: BTW, just to be clear: You realize lambdas are (unnamed) classes, right? They're syntactic sugar around functors (the captures are instance attributes, and the arguments are arguments to operator()) so in both cases a class exists (or doesn't exist due to inlining). This explicitly overrides operator int (so implicit conversion does the trick), where lambdas implicitly override operator() (so explicit call parens are needed), otherwise they're the same. It's fine if you prefer the lambda for code brevity, but in terms of what actually runs, both of them involve classes.

    – ShadowRanger
    7 hours ago







    @NayWunnaZaw: BTW, just to be clear: You realize lambdas are (unnamed) classes, right? They're syntactic sugar around functors (the captures are instance attributes, and the arguments are arguments to operator()) so in both cases a class exists (or doesn't exist due to inlining). This explicitly overrides operator int (so implicit conversion does the trick), where lambdas implicitly override operator() (so explicit call parens are needed), otherwise they're the same. It's fine if you prefer the lambda for code brevity, but in terms of what actually runs, both of them involve classes.

    – ShadowRanger
    7 hours ago













    19














    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";
    }
    }





    share|improve this answer




























      19














      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";
      }
      }





      share|improve this answer


























        19












        19








        19







        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";
        }
        }





        share|improve this answer













        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";
        }
        }






        share|improve this answer












        share|improve this answer



        share|improve this answer










        answered yesterday









        Ted LyngmoTed Lyngmo

        3,5902522




        3,5902522























            10














            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.






            share|improve this answer


























            • The observation approach is interesting, too, if calculations to be done are expensive. Appropriately implemented, I consider it more elegant than the caching proposed by NathanOliver...

              – Aconcagua
              16 hours ago






            • 1





              @Aconcagua, amend that to: if calculations to be done are expensive and reads are more frequent than updates. Otherwise, we need to add a way to avoid computing values that don't get used.

              – Toby Speight
              13 hours ago
















            10














            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.






            share|improve this answer


























            • The observation approach is interesting, too, if calculations to be done are expensive. Appropriately implemented, I consider it more elegant than the caching proposed by NathanOliver...

              – Aconcagua
              16 hours ago






            • 1





              @Aconcagua, amend that to: if calculations to be done are expensive and reads are more frequent than updates. Otherwise, we need to add a way to avoid computing values that don't get used.

              – Toby Speight
              13 hours ago














            10












            10








            10







            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.






            share|improve this answer















            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.







            share|improve this answer














            share|improve this answer



            share|improve this answer








            edited 13 hours ago

























            answered yesterday









            Toby SpeightToby Speight

            17.3k134368




            17.3k134368













            • The observation approach is interesting, too, if calculations to be done are expensive. Appropriately implemented, I consider it more elegant than the caching proposed by NathanOliver...

              – Aconcagua
              16 hours ago






            • 1





              @Aconcagua, amend that to: if calculations to be done are expensive and reads are more frequent than updates. Otherwise, we need to add a way to avoid computing values that don't get used.

              – Toby Speight
              13 hours ago



















            • The observation approach is interesting, too, if calculations to be done are expensive. Appropriately implemented, I consider it more elegant than the caching proposed by NathanOliver...

              – Aconcagua
              16 hours ago






            • 1





              @Aconcagua, amend that to: if calculations to be done are expensive and reads are more frequent than updates. Otherwise, we need to add a way to avoid computing values that don't get used.

              – Toby Speight
              13 hours ago

















            The observation approach is interesting, too, if calculations to be done are expensive. Appropriately implemented, I consider it more elegant than the caching proposed by NathanOliver...

            – Aconcagua
            16 hours ago





            The observation approach is interesting, too, if calculations to be done are expensive. Appropriately implemented, I consider it more elegant than the caching proposed by NathanOliver...

            – Aconcagua
            16 hours ago




            1




            1





            @Aconcagua, amend that to: if calculations to be done are expensive and reads are more frequent than updates. Otherwise, we need to add a way to avoid computing values that don't get used.

            – Toby Speight
            13 hours ago





            @Aconcagua, amend that to: if calculations to be done are expensive and reads are more frequent than updates. Otherwise, we need to add a way to avoid computing values that don't get used.

            – Toby Speight
            13 hours ago











            4














            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.






            share|improve this answer


























            • can you give me the pros and cons of using lambdas vs this? which would be better practice?

              – Nay Wunna Zaw
              12 hours ago











            • Yes, this is the (real) answer I would expect. Unfortunately, there is FGITW (I think it is a real problem).

              – Peter Mortensen
              32 mins ago
















            4














            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.






            share|improve this answer


























            • can you give me the pros and cons of using lambdas vs this? which would be better practice?

              – Nay Wunna Zaw
              12 hours ago











            • Yes, this is the (real) answer I would expect. Unfortunately, there is FGITW (I think it is a real problem).

              – Peter Mortensen
              32 mins ago














            4












            4








            4







            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.






            share|improve this answer















            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.







            share|improve this answer














            share|improve this answer



            share|improve this answer








            edited 9 hours ago









            ShadowRanger

            63.3k66099




            63.3k66099










            answered 19 hours ago









            ArteliusArtelius

            41.4k87895




            41.4k87895













            • can you give me the pros and cons of using lambdas vs this? which would be better practice?

              – Nay Wunna Zaw
              12 hours ago











            • Yes, this is the (real) answer I would expect. Unfortunately, there is FGITW (I think it is a real problem).

              – Peter Mortensen
              32 mins ago



















            • can you give me the pros and cons of using lambdas vs this? which would be better practice?

              – Nay Wunna Zaw
              12 hours ago











            • Yes, this is the (real) answer I would expect. Unfortunately, there is FGITW (I think it is a real problem).

              – Peter Mortensen
              32 mins ago

















            can you give me the pros and cons of using lambdas vs this? which would be better practice?

            – Nay Wunna Zaw
            12 hours ago





            can you give me the pros and cons of using lambdas vs this? which would be better practice?

            – Nay Wunna Zaw
            12 hours ago













            Yes, this is the (real) answer I would expect. Unfortunately, there is FGITW (I think it is a real problem).

            – Peter Mortensen
            32 mins ago





            Yes, this is the (real) answer I would expect. Unfortunately, there is FGITW (I think it is a real problem).

            – Peter Mortensen
            32 mins ago











            3















            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 z{x + y};

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





            share|improve this answer



















            • 1





              yes, i mean the only way to get z updated is to call that function everytime we change x and y values?

              – Nay Wunna Zaw
              yesterday











            • @NayWunnaZaw, yes, that is correct.

              – R Sahu
              yesterday






            • 1





              @NayWunnaZaw, you can avoid the repeated use of x and y by using a lambda function, as shown by Nathan but you still have to make the call.

              – R Sahu
              yesterday






            • 4





              @NayWunnaZaw To complete the issue: Even with my solution, there is a function call (to the cast operator!), just that it is implicit and not required explicitly...

              – Aconcagua
              yesterday
















            3















            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 z{x + y};

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





            share|improve this answer



















            • 1





              yes, i mean the only way to get z updated is to call that function everytime we change x and y values?

              – Nay Wunna Zaw
              yesterday











            • @NayWunnaZaw, yes, that is correct.

              – R Sahu
              yesterday






            • 1





              @NayWunnaZaw, you can avoid the repeated use of x and y by using a lambda function, as shown by Nathan but you still have to make the call.

              – R Sahu
              yesterday






            • 4





              @NayWunnaZaw To complete the issue: Even with my solution, there is a function call (to the cast operator!), just that it is implicit and not required explicitly...

              – Aconcagua
              yesterday














            3












            3








            3








            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 z{x + y};

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





            share|improve this answer














            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 z{x + y};

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






            share|improve this answer












            share|improve this answer



            share|improve this answer










            answered yesterday









            R SahuR Sahu

            170k1294193




            170k1294193








            • 1





              yes, i mean the only way to get z updated is to call that function everytime we change x and y values?

              – Nay Wunna Zaw
              yesterday











            • @NayWunnaZaw, yes, that is correct.

              – R Sahu
              yesterday






            • 1





              @NayWunnaZaw, you can avoid the repeated use of x and y by using a lambda function, as shown by Nathan but you still have to make the call.

              – R Sahu
              yesterday






            • 4





              @NayWunnaZaw To complete the issue: Even with my solution, there is a function call (to the cast operator!), just that it is implicit and not required explicitly...

              – Aconcagua
              yesterday














            • 1





              yes, i mean the only way to get z updated is to call that function everytime we change x and y values?

              – Nay Wunna Zaw
              yesterday











            • @NayWunnaZaw, yes, that is correct.

              – R Sahu
              yesterday






            • 1





              @NayWunnaZaw, you can avoid the repeated use of x and y by using a lambda function, as shown by Nathan but you still have to make the call.

              – R Sahu
              yesterday






            • 4





              @NayWunnaZaw To complete the issue: Even with my solution, there is a function call (to the cast operator!), just that it is implicit and not required explicitly...

              – Aconcagua
              yesterday








            1




            1





            yes, i mean the only way to get z updated is to call that function everytime we change x and y values?

            – Nay Wunna Zaw
            yesterday





            yes, i mean the only way to get z updated is to call that function everytime we change x and y values?

            – Nay Wunna Zaw
            yesterday













            @NayWunnaZaw, yes, that is correct.

            – R Sahu
            yesterday





            @NayWunnaZaw, yes, that is correct.

            – R Sahu
            yesterday




            1




            1





            @NayWunnaZaw, you can avoid the repeated use of x and y by using a lambda function, as shown by Nathan but you still have to make the call.

            – R Sahu
            yesterday





            @NayWunnaZaw, you can avoid the repeated use of x and y by using a lambda function, as shown by Nathan but you still have to make the call.

            – R Sahu
            yesterday




            4




            4





            @NayWunnaZaw To complete the issue: Even with my solution, there is a function call (to the cast operator!), just that it is implicit and not required explicitly...

            – Aconcagua
            yesterday





            @NayWunnaZaw To complete the issue: Even with my solution, there is a function call (to the cast operator!), just that it is implicit and not required explicitly...

            – Aconcagua
            yesterday











            2














            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
            }





            share|improve this answer





















            • 2





              Don't use parentheses around return values – return is not a function, and in worst case, the parentheses can even create a dangling reference (with return type being decltype(auto)).

              – Aconcagua
              yesterday











            • @Aconcagua thx! you are right. I edited my answer.

              – Hiroki
              yesterday













            • Why downvoted ? At least I posted my answer faster than Ted with my tested code. Hmm... :)

              – Hiroki
              16 hours ago








            • 1





              Well, I didn't and wouldn't have considered the parentheses worth doing so either. If they were the reason – well, people tend to never come back to remove a DV even if the answer was fixed, so (I don't think there's a notification for either, so people might just not even recognise...)

              – Aconcagua
              16 hours ago











            • @Aconcagua thx for your comment. Although I was downvoted after few hours later of my edition, I was relieved to hear your words.

              – Hiroki
              5 hours ago
















            2














            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
            }





            share|improve this answer





















            • 2





              Don't use parentheses around return values – return is not a function, and in worst case, the parentheses can even create a dangling reference (with return type being decltype(auto)).

              – Aconcagua
              yesterday











            • @Aconcagua thx! you are right. I edited my answer.

              – Hiroki
              yesterday













            • Why downvoted ? At least I posted my answer faster than Ted with my tested code. Hmm... :)

              – Hiroki
              16 hours ago








            • 1





              Well, I didn't and wouldn't have considered the parentheses worth doing so either. If they were the reason – well, people tend to never come back to remove a DV even if the answer was fixed, so (I don't think there's a notification for either, so people might just not even recognise...)

              – Aconcagua
              16 hours ago











            • @Aconcagua thx for your comment. Although I was downvoted after few hours later of my edition, I was relieved to hear your words.

              – Hiroki
              5 hours ago














            2












            2








            2







            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
            }





            share|improve this answer















            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
            }






            share|improve this answer














            share|improve this answer



            share|improve this answer








            edited 16 hours ago

























            answered yesterday









            HirokiHiroki

            2,1353320




            2,1353320








            • 2





              Don't use parentheses around return values – return is not a function, and in worst case, the parentheses can even create a dangling reference (with return type being decltype(auto)).

              – Aconcagua
              yesterday











            • @Aconcagua thx! you are right. I edited my answer.

              – Hiroki
              yesterday













            • Why downvoted ? At least I posted my answer faster than Ted with my tested code. Hmm... :)

              – Hiroki
              16 hours ago








            • 1





              Well, I didn't and wouldn't have considered the parentheses worth doing so either. If they were the reason – well, people tend to never come back to remove a DV even if the answer was fixed, so (I don't think there's a notification for either, so people might just not even recognise...)

              – Aconcagua
              16 hours ago











            • @Aconcagua thx for your comment. Although I was downvoted after few hours later of my edition, I was relieved to hear your words.

              – Hiroki
              5 hours ago














            • 2





              Don't use parentheses around return values – return is not a function, and in worst case, the parentheses can even create a dangling reference (with return type being decltype(auto)).

              – Aconcagua
              yesterday











            • @Aconcagua thx! you are right. I edited my answer.

              – Hiroki
              yesterday













            • Why downvoted ? At least I posted my answer faster than Ted with my tested code. Hmm... :)

              – Hiroki
              16 hours ago








            • 1





              Well, I didn't and wouldn't have considered the parentheses worth doing so either. If they were the reason – well, people tend to never come back to remove a DV even if the answer was fixed, so (I don't think there's a notification for either, so people might just not even recognise...)

              – Aconcagua
              16 hours ago











            • @Aconcagua thx for your comment. Although I was downvoted after few hours later of my edition, I was relieved to hear your words.

              – Hiroki
              5 hours ago








            2




            2





            Don't use parentheses around return values – return is not a function, and in worst case, the parentheses can even create a dangling reference (with return type being decltype(auto)).

            – Aconcagua
            yesterday





            Don't use parentheses around return values – return is not a function, and in worst case, the parentheses can even create a dangling reference (with return type being decltype(auto)).

            – Aconcagua
            yesterday













            @Aconcagua thx! you are right. I edited my answer.

            – Hiroki
            yesterday







            @Aconcagua thx! you are right. I edited my answer.

            – Hiroki
            yesterday















            Why downvoted ? At least I posted my answer faster than Ted with my tested code. Hmm... :)

            – Hiroki
            16 hours ago







            Why downvoted ? At least I posted my answer faster than Ted with my tested code. Hmm... :)

            – Hiroki
            16 hours ago






            1




            1





            Well, I didn't and wouldn't have considered the parentheses worth doing so either. If they were the reason – well, people tend to never come back to remove a DV even if the answer was fixed, so (I don't think there's a notification for either, so people might just not even recognise...)

            – Aconcagua
            16 hours ago





            Well, I didn't and wouldn't have considered the parentheses worth doing so either. If they were the reason – well, people tend to never come back to remove a DV even if the answer was fixed, so (I don't think there's a notification for either, so people might just not even recognise...)

            – Aconcagua
            16 hours ago













            @Aconcagua thx for your comment. Although I was downvoted after few hours later of my edition, I was relieved to hear your words.

            – Hiroki
            5 hours ago





            @Aconcagua thx for your comment. Although I was downvoted after few hours later of my edition, I was relieved to hear your words.

            – Hiroki
            5 hours ago











            1














            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();





            share|improve this answer
























            • I don't quite understand how lambda work. But if you've played dota you'd know how gold in the game work. The way it is displayed all the time and adding 1 gold every split-second. I'm asking this question with that in mind. How do I implement that in c++?

              – Nay Wunna Zaw
              7 hours ago






            • 1





              @NayWunnaZaw I mean generally you're going to have a main class which calls the tick function on any class that needs live updating, passing in a time elapsed since last tick parameter. You'd probably have a player class instead of just the simple foo which would do loads of things. Like the player class's tick would need to update the damage of poison effects, calculate cooldown times, and also calculate gold. I recognize this is probably a gross over simplification. But I do think you're going to want to go with a class here.

              – Jonathan Mee
              7 hours ago











            • thanks for that, but I like lambda answer more for it's simplicity for a variable. and that fits my question. And class type solution should be used instead if we plan on using the equation more than once like shadowranger said up there.

              – Nay Wunna Zaw
              7 hours ago
















            1














            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();





            share|improve this answer
























            • I don't quite understand how lambda work. But if you've played dota you'd know how gold in the game work. The way it is displayed all the time and adding 1 gold every split-second. I'm asking this question with that in mind. How do I implement that in c++?

              – Nay Wunna Zaw
              7 hours ago






            • 1





              @NayWunnaZaw I mean generally you're going to have a main class which calls the tick function on any class that needs live updating, passing in a time elapsed since last tick parameter. You'd probably have a player class instead of just the simple foo which would do loads of things. Like the player class's tick would need to update the damage of poison effects, calculate cooldown times, and also calculate gold. I recognize this is probably a gross over simplification. But I do think you're going to want to go with a class here.

              – Jonathan Mee
              7 hours ago











            • thanks for that, but I like lambda answer more for it's simplicity for a variable. and that fits my question. And class type solution should be used instead if we plan on using the equation more than once like shadowranger said up there.

              – Nay Wunna Zaw
              7 hours ago














            1












            1








            1







            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();





            share|improve this answer













            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();






            share|improve this answer












            share|improve this answer



            share|improve this answer










            answered 8 hours ago









            Jonathan MeeJonathan Mee

            22k1066176




            22k1066176













            • I don't quite understand how lambda work. But if you've played dota you'd know how gold in the game work. The way it is displayed all the time and adding 1 gold every split-second. I'm asking this question with that in mind. How do I implement that in c++?

              – Nay Wunna Zaw
              7 hours ago






            • 1





              @NayWunnaZaw I mean generally you're going to have a main class which calls the tick function on any class that needs live updating, passing in a time elapsed since last tick parameter. You'd probably have a player class instead of just the simple foo which would do loads of things. Like the player class's tick would need to update the damage of poison effects, calculate cooldown times, and also calculate gold. I recognize this is probably a gross over simplification. But I do think you're going to want to go with a class here.

              – Jonathan Mee
              7 hours ago











            • thanks for that, but I like lambda answer more for it's simplicity for a variable. and that fits my question. And class type solution should be used instead if we plan on using the equation more than once like shadowranger said up there.

              – Nay Wunna Zaw
              7 hours ago



















            • I don't quite understand how lambda work. But if you've played dota you'd know how gold in the game work. The way it is displayed all the time and adding 1 gold every split-second. I'm asking this question with that in mind. How do I implement that in c++?

              – Nay Wunna Zaw
              7 hours ago






            • 1





              @NayWunnaZaw I mean generally you're going to have a main class which calls the tick function on any class that needs live updating, passing in a time elapsed since last tick parameter. You'd probably have a player class instead of just the simple foo which would do loads of things. Like the player class's tick would need to update the damage of poison effects, calculate cooldown times, and also calculate gold. I recognize this is probably a gross over simplification. But I do think you're going to want to go with a class here.

              – Jonathan Mee
              7 hours ago











            • thanks for that, but I like lambda answer more for it's simplicity for a variable. and that fits my question. And class type solution should be used instead if we plan on using the equation more than once like shadowranger said up there.

              – Nay Wunna Zaw
              7 hours ago

















            I don't quite understand how lambda work. But if you've played dota you'd know how gold in the game work. The way it is displayed all the time and adding 1 gold every split-second. I'm asking this question with that in mind. How do I implement that in c++?

            – Nay Wunna Zaw
            7 hours ago





            I don't quite understand how lambda work. But if you've played dota you'd know how gold in the game work. The way it is displayed all the time and adding 1 gold every split-second. I'm asking this question with that in mind. How do I implement that in c++?

            – Nay Wunna Zaw
            7 hours ago




            1




            1





            @NayWunnaZaw I mean generally you're going to have a main class which calls the tick function on any class that needs live updating, passing in a time elapsed since last tick parameter. You'd probably have a player class instead of just the simple foo which would do loads of things. Like the player class's tick would need to update the damage of poison effects, calculate cooldown times, and also calculate gold. I recognize this is probably a gross over simplification. But I do think you're going to want to go with a class here.

            – Jonathan Mee
            7 hours ago





            @NayWunnaZaw I mean generally you're going to have a main class which calls the tick function on any class that needs live updating, passing in a time elapsed since last tick parameter. You'd probably have a player class instead of just the simple foo which would do loads of things. Like the player class's tick would need to update the damage of poison effects, calculate cooldown times, and also calculate gold. I recognize this is probably a gross over simplification. But I do think you're going to want to go with a class here.

            – Jonathan Mee
            7 hours ago













            thanks for that, but I like lambda answer more for it's simplicity for a variable. and that fits my question. And class type solution should be used instead if we plan on using the equation more than once like shadowranger said up there.

            – Nay Wunna Zaw
            7 hours ago





            thanks for that, but I like lambda answer more for it's simplicity for a variable. and that fits my question. And class type solution should be used instead if we plan on using the equation more than once like shadowranger said up there.

            – Nay Wunna Zaw
            7 hours ago











            0














            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.






            share|improve this answer
























            • Although this could use an EXTREME CAUTION warning, I think it is worth mentioning. Sometimes quick'n'dirty is called for. I have used tricks like this to save time in programming competitions, or in mindless repetitive matrix calculations that would be a lot more verbose and/or bug-prone using any other approach.

              – Artelius
              19 hours ago


















            0














            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.






            share|improve this answer
























            • Although this could use an EXTREME CAUTION warning, I think it is worth mentioning. Sometimes quick'n'dirty is called for. I have used tricks like this to save time in programming competitions, or in mindless repetitive matrix calculations that would be a lot more verbose and/or bug-prone using any other approach.

              – Artelius
              19 hours ago
















            0












            0








            0







            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.






            share|improve this answer













            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.







            share|improve this answer












            share|improve this answer



            share|improve this answer










            answered 23 hours ago









            o11co11c

            10.9k43154




            10.9k43154













            • Although this could use an EXTREME CAUTION warning, I think it is worth mentioning. Sometimes quick'n'dirty is called for. I have used tricks like this to save time in programming competitions, or in mindless repetitive matrix calculations that would be a lot more verbose and/or bug-prone using any other approach.

              – Artelius
              19 hours ago





















            • Although this could use an EXTREME CAUTION warning, I think it is worth mentioning. Sometimes quick'n'dirty is called for. I have used tricks like this to save time in programming competitions, or in mindless repetitive matrix calculations that would be a lot more verbose and/or bug-prone using any other approach.

              – Artelius
              19 hours ago



















            Although this could use an EXTREME CAUTION warning, I think it is worth mentioning. Sometimes quick'n'dirty is called for. I have used tricks like this to save time in programming competitions, or in mindless repetitive matrix calculations that would be a lot more verbose and/or bug-prone using any other approach.

            – Artelius
            19 hours ago







            Although this could use an EXTREME CAUTION warning, I think it is worth mentioning. Sometimes quick'n'dirty is called for. I have used tricks like this to save time in programming competitions, or in mindless repetitive matrix calculations that would be a lot more verbose and/or bug-prone using any other approach.

            – Artelius
            19 hours ago












            Nay Wunna Zaw is a new contributor. Be nice, and check out our Code of Conduct.










            draft saved

            draft discarded


















            Nay Wunna Zaw is a new contributor. Be nice, and check out our Code of Conduct.













            Nay Wunna Zaw is a new contributor. Be nice, and check out our Code of Conduct.












            Nay Wunna Zaw is a new contributor. Be nice, and check out our Code of Conduct.
















            Thanks for contributing an answer to Stack Overflow!


            • Please be sure to answer the question. Provide details and share your research!

            But avoid



            • Asking for help, clarification, or responding to other answers.

            • Making statements based on opinion; back them up with references or personal experience.


            To learn more, see our tips on writing great answers.




            draft saved


            draft discarded














            StackExchange.ready(
            function () {
            StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fstackoverflow.com%2fquestions%2f55402807%2fhow-do-i-make-a-variable-always-equal-to-the-result-of-some-calculations%23new-answer', 'question_page');
            }
            );

            Post as a guest















            Required, but never shown





















































            Required, but never shown














            Required, but never shown












            Required, but never shown







            Required, but never shown

































            Required, but never shown














            Required, but never shown












            Required, but never shown







            Required, but never shown







            Popular posts from this blog

            Knooppunt Holsloot

            Altaar (religie)

            Gregoriusmis