How do I make a variable always equal to the result of some calculations? The Next CEO of Stack OverflowLazy evaluation in C++Convention for leaving body of an if/else blankHow do you clear a stringstream variable?What's the best way to do fixed-point math?Is the sizeof(some pointer) always equal to four?How to make a SIMPLE C++ Makefile?Is there some ninja trick to make a variable constant after its declaration?How to make my custom type to work with “range-based for loops”?Does static constexpr variable make sense?How to make a conditional typedef in C++QTableView slow scrolling when many cells are visible at onceC++11 Print run-time variable name equal to some constexpr variable
"misplaced omit" error when >centering columns
Where does this common spurious transmission come from? Is there a quality difference?
Can MTA send mail via a relay without being told so?
Calculator final project in Python
Is it ever safe to open a suspicious HTML file (e.g. email attachment)?
What was the first Unix version to run on a microcomputer?
Method for adding error messages to a dictionary given a key
Would this house-rule that treats advantage as a +1 to the roll instead (and disadvantage as -1) and allows them to stack be balanced?
Are police here, aren't itthey?
How to check if all elements of 1 list are in the *same quantity* and in any order, in the list2?
Won the lottery - how do I keep the money?
The past simple of "gaslight" – "gaslighted" or "gaslit"?
Domestic-to-international connection at Orlando (MCO)
Is it okay to majorly distort historical facts while writing a fiction story?
Which one is the true statement?
Does Germany produce more waste than the US?
Why don't programming languages automatically manage the synchronous/asynchronous problem?
What flight has the highest ratio of time difference to flight time?
Should I tutor a student who I know has cheated on their homework?
Why the difference in type-inference over the as-pattern in two similar function definitions?
Bartok - Syncopation (1): Meaning of notes in between Grand Staff
Legal workarounds for testamentary trust perceived as unfair
Grabbing quick drinks
Where do students learn to solve polynomial equations these days?
How do I make a variable always equal to the result of some calculations?
The Next CEO of Stack OverflowLazy evaluation in C++Convention for leaving body of an if/else blankHow do you clear a stringstream variable?What's the best way to do fixed-point math?Is the sizeof(some pointer) always equal to four?How to make a SIMPLE C++ Makefile?Is there some ninja trick to make a variable constant after its declaration?How to make my custom type to work with “range-based for loops”?Does static constexpr variable make sense?How to make a conditional typedef in C++QTableView slow scrolling when many cells are visible at onceC++11 Print run-time variable name equal to some constexpr variable
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 zx + 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
New contributor
|
show 6 more comments
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 zx + 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
New contributor
3
Right, that won't work. That's a spreadsheet thing.
– Pete Becker
2 days ago
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
2 days ago
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
2 days ago
39
That's called a "function."
– ApproachingDarknessFish
2 days ago
3
Surely this is a bit of an XY-problem?
– Carmeister
yesterday
|
show 6 more comments
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 zx + 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
New contributor
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 zx + 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
c++ c++11
New contributor
New contributor
edited yesterday
Peter Mortensen
13.8k1987113
13.8k1987113
New contributor
asked 2 days ago
Nay Wunna ZawNay Wunna Zaw
136211
136211
New contributor
New contributor
3
Right, that won't work. That's a spreadsheet thing.
– Pete Becker
2 days ago
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
2 days ago
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
2 days ago
39
That's called a "function."
– ApproachingDarknessFish
2 days ago
3
Surely this is a bit of an XY-problem?
– Carmeister
yesterday
|
show 6 more comments
3
Right, that won't work. That's a spreadsheet thing.
– Pete Becker
2 days ago
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
2 days ago
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
2 days ago
39
That's called a "function."
– ApproachingDarknessFish
2 days ago
3
Surely this is a bit of an XY-problem?
– Carmeister
yesterday
3
3
Right, that won't work. That's a spreadsheet thing.
– Pete Becker
2 days ago
Right, that won't work. That's a spreadsheet thing.
– Pete Becker
2 days ago
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
2 days ago
@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
2 days ago
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
2 days ago
@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
2 days ago
39
39
That's called a "function."
– ApproachingDarknessFish
2 days ago
That's called a "function."
– ApproachingDarknessFish
2 days ago
3
3
Surely this is a bit of an XY-problem?
– Carmeister
yesterday
Surely this is a bit of an XY-problem?
– Carmeister
yesterday
|
show 6 more comments
9 Answers
9
active
oldest
votes
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 zx + 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 = [&]() y != cache_y)
cache_x = x;
cache_y = y;
cache_result = x + y;
return cache_result;
;
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
2 days ago
6
And a class can be used to avoid thez()
syntax as well: coliru.stacked-crooked.com/a/3c3dafe9856c28b8
– Mooing Duck
2 days ago
@MooingDuck That's awesome! I didn't think it was possible. It deserves to be an answer on its own!
– Fabio Turati
2 days ago
@FabioTurati See Aconcagua's answer
– NathanOliver
2 days ago
6
Erm you probably don't wantstatic
for caching... lambdas can be stateful for a reason.
– Mehrdad
yesterday
|
show 2 more comments
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;
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
yesterday
2
@NayWunnaZaw: If it's a one-off usage, sure, use thelambda
. 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 likestd::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
yesterday
@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
yesterday
3
@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 tooperator()
) so in both cases a class exists (or doesn't exist due to inlining). This explicitly overridesoperator int
(so implicit conversion does the trick), where lambdas implicitly overrideoperator()
(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
yesterday
This is my personal favourite kind of answer!
– Ted Lyngmo
20 hours ago
add a comment |
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";
add a comment |
There are two chief techniques:
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 ifz
is some proxy object with implicit conversion to the required type (as in Aconcagua's answer).Explicit notification of changes. This requires
x
andy
to be observable types; when either changes value, thenz
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.
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
yesterday
2
@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
yesterday
add a comment |
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.
can you give me the pros and cons of using lambdas vs this? which would be better practice?
– Nay Wunna Zaw
yesterday
1
Yes, this is the (real) answer I would expect. Unfortunately, there is FGITW (I think it is a real problem).
– Peter Mortensen
yesterday
add a comment |
- You create a function for that.
- You call the function with the appropriate arguments when you need the value.
int z(int x, int y)
return (x + y);
int x;
int y;
// This does ot work
// int zx + y;
cin >> x;
cin >> y;
cout << z(x, y);
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
2 days ago
@NayWunnaZaw, yes, that is correct.
– R Sahu
2 days ago
1
@NayWunnaZaw, you can avoid the repeated use ofx
andy
by using a lambda function, as shown by Nathan but you still have to make the call.
– R Sahu
2 days ago
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
2 days ago
add a comment |
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
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 beingdecltype(auto)
).
– Aconcagua
2 days ago
@Aconcagua thx! you are right. I edited my answer.
– Hiroki
2 days ago
Why downvoted ? At least I posted my answer faster than Ted with my tested code. Hmm... :)
– Hiroki
yesterday
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
yesterday
@Aconcagua thx for your comment. Although I was downvoted after few hours later of my edition, I was relieved to hear your words.
– Hiroki
yesterday
add a comment |
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();
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
yesterday
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 simplefoo
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
yesterday
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
yesterday
add a comment |
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.
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
yesterday
add a comment |
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.
Sign up or log in
StackExchange.ready(function ()
StackExchange.helpers.onClickDraftSave('#login-link');
);
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
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
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 zx + 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 = [&]() y != cache_y)
cache_x = x;
cache_y = y;
cache_result = x + y;
return cache_result;
;
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
2 days ago
6
And a class can be used to avoid thez()
syntax as well: coliru.stacked-crooked.com/a/3c3dafe9856c28b8
– Mooing Duck
2 days ago
@MooingDuck That's awesome! I didn't think it was possible. It deserves to be an answer on its own!
– Fabio Turati
2 days ago
@FabioTurati See Aconcagua's answer
– NathanOliver
2 days ago
6
Erm you probably don't wantstatic
for caching... lambdas can be stateful for a reason.
– Mehrdad
yesterday
|
show 2 more comments
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 zx + 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 = [&]() y != cache_y)
cache_x = x;
cache_y = y;
cache_result = x + y;
return cache_result;
;
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
2 days ago
6
And a class can be used to avoid thez()
syntax as well: coliru.stacked-crooked.com/a/3c3dafe9856c28b8
– Mooing Duck
2 days ago
@MooingDuck That's awesome! I didn't think it was possible. It deserves to be an answer on its own!
– Fabio Turati
2 days ago
@FabioTurati See Aconcagua's answer
– NathanOliver
2 days ago
6
Erm you probably don't wantstatic
for caching... lambdas can be stateful for a reason.
– Mehrdad
yesterday
|
show 2 more comments
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 zx + 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 = [&]() y != cache_y)
cache_x = x;
cache_y = y;
cache_result = x + y;
return cache_result;
;
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 zx + 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 = [&]() y != cache_y)
cache_x = x;
cache_y = y;
cache_result = x + y;
return cache_result;
;
edited yesterday
J.G.
1259
1259
answered 2 days ago
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
2 days ago
6
And a class can be used to avoid thez()
syntax as well: coliru.stacked-crooked.com/a/3c3dafe9856c28b8
– Mooing Duck
2 days ago
@MooingDuck That's awesome! I didn't think it was possible. It deserves to be an answer on its own!
– Fabio Turati
2 days ago
@FabioTurati See Aconcagua's answer
– NathanOliver
2 days ago
6
Erm you probably don't wantstatic
for caching... lambdas can be stateful for a reason.
– Mehrdad
yesterday
|
show 2 more comments
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
2 days ago
6
And a class can be used to avoid thez()
syntax as well: coliru.stacked-crooked.com/a/3c3dafe9856c28b8
– Mooing Duck
2 days ago
@MooingDuck That's awesome! I didn't think it was possible. It deserves to be an answer on its own!
– Fabio Turati
2 days ago
@FabioTurati See Aconcagua's answer
– NathanOliver
2 days ago
6
Erm you probably don't wantstatic
for caching... lambdas can be stateful for a reason.
– Mehrdad
yesterday
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
2 days ago
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
2 days ago
6
6
And a class can be used to avoid the
z()
syntax as well: coliru.stacked-crooked.com/a/3c3dafe9856c28b8– Mooing Duck
2 days ago
And a class can be used to avoid the
z()
syntax as well: coliru.stacked-crooked.com/a/3c3dafe9856c28b8– Mooing Duck
2 days ago
@MooingDuck That's awesome! I didn't think it was possible. It deserves to be an answer on its own!
– Fabio Turati
2 days ago
@MooingDuck That's awesome! I didn't think it was possible. It deserves to be an answer on its own!
– Fabio Turati
2 days ago
@FabioTurati See Aconcagua's answer
– NathanOliver
2 days ago
@FabioTurati See Aconcagua's answer
– NathanOliver
2 days ago
6
6
Erm you probably don't want
static
for caching... lambdas can be stateful for a reason.– Mehrdad
yesterday
Erm you probably don't want
static
for caching... lambdas can be stateful for a reason.– Mehrdad
yesterday
|
show 2 more comments
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;
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
yesterday
2
@NayWunnaZaw: If it's a one-off usage, sure, use thelambda
. 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 likestd::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
yesterday
@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
yesterday
3
@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 tooperator()
) so in both cases a class exists (or doesn't exist due to inlining). This explicitly overridesoperator int
(so implicit conversion does the trick), where lambdas implicitly overrideoperator()
(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
yesterday
This is my personal favourite kind of answer!
– Ted Lyngmo
20 hours ago
add a comment |
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;
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
yesterday
2
@NayWunnaZaw: If it's a one-off usage, sure, use thelambda
. 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 likestd::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
yesterday
@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
yesterday
3
@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 tooperator()
) so in both cases a class exists (or doesn't exist due to inlining). This explicitly overridesoperator int
(so implicit conversion does the trick), where lambdas implicitly overrideoperator()
(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
yesterday
This is my personal favourite kind of answer!
– Ted Lyngmo
20 hours ago
add a comment |
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;
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;
answered 2 days ago
AconcaguaAconcagua
13.1k32245
13.1k32245
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
yesterday
2
@NayWunnaZaw: If it's a one-off usage, sure, use thelambda
. 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 likestd::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
yesterday
@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
yesterday
3
@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 tooperator()
) so in both cases a class exists (or doesn't exist due to inlining). This explicitly overridesoperator int
(so implicit conversion does the trick), where lambdas implicitly overrideoperator()
(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
yesterday
This is my personal favourite kind of answer!
– Ted Lyngmo
20 hours ago
add a comment |
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
yesterday
2
@NayWunnaZaw: If it's a one-off usage, sure, use thelambda
. 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 likestd::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
yesterday
@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
yesterday
3
@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 tooperator()
) so in both cases a class exists (or doesn't exist due to inlining). This explicitly overridesoperator int
(so implicit conversion does the trick), where lambdas implicitly overrideoperator()
(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
yesterday
This is my personal favourite kind of answer!
– Ted Lyngmo
20 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
yesterday
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
yesterday
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
yesterday
@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
yesterday
@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
yesterday
@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
yesterday
3
3
@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
yesterday
@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
yesterday
This is my personal favourite kind of answer!
– Ted Lyngmo
20 hours ago
This is my personal favourite kind of answer!
– Ted Lyngmo
20 hours ago
add a comment |
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";
add a comment |
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";
add a comment |
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";
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";
answered 2 days ago
Ted LyngmoTed Lyngmo
3,5982522
3,5982522
add a comment |
add a comment |
There are two chief techniques:
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 ifz
is some proxy object with implicit conversion to the required type (as in Aconcagua's answer).Explicit notification of changes. This requires
x
andy
to be observable types; when either changes value, thenz
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.
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
yesterday
2
@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
yesterday
add a comment |
There are two chief techniques:
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 ifz
is some proxy object with implicit conversion to the required type (as in Aconcagua's answer).Explicit notification of changes. This requires
x
andy
to be observable types; when either changes value, thenz
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.
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
yesterday
2
@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
yesterday
add a comment |
There are two chief techniques:
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 ifz
is some proxy object with implicit conversion to the required type (as in Aconcagua's answer).Explicit notification of changes. This requires
x
andy
to be observable types; when either changes value, thenz
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.
There are two chief techniques:
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 ifz
is some proxy object with implicit conversion to the required type (as in Aconcagua's answer).Explicit notification of changes. This requires
x
andy
to be observable types; when either changes value, thenz
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.
edited yesterday
answered 2 days ago
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
yesterday
2
@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
yesterday
add a comment |
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
yesterday
2
@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
yesterday
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
yesterday
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
yesterday
2
2
@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
yesterday
@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
yesterday
add a comment |
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.
can you give me the pros and cons of using lambdas vs this? which would be better practice?
– Nay Wunna Zaw
yesterday
1
Yes, this is the (real) answer I would expect. Unfortunately, there is FGITW (I think it is a real problem).
– Peter Mortensen
yesterday
add a comment |
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.
can you give me the pros and cons of using lambdas vs this? which would be better practice?
– Nay Wunna Zaw
yesterday
1
Yes, this is the (real) answer I would expect. Unfortunately, there is FGITW (I think it is a real problem).
– Peter Mortensen
yesterday
add a comment |
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.
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.
edited yesterday
ShadowRanger
63.3k660100
63.3k660100
answered yesterday
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
yesterday
1
Yes, this is the (real) answer I would expect. Unfortunately, there is FGITW (I think it is a real problem).
– Peter Mortensen
yesterday
add a comment |
can you give me the pros and cons of using lambdas vs this? which would be better practice?
– Nay Wunna Zaw
yesterday
1
Yes, this is the (real) answer I would expect. Unfortunately, there is FGITW (I think it is a real problem).
– Peter Mortensen
yesterday
can you give me the pros and cons of using lambdas vs this? which would be better practice?
– Nay Wunna Zaw
yesterday
can you give me the pros and cons of using lambdas vs this? which would be better practice?
– Nay Wunna Zaw
yesterday
1
1
Yes, this is the (real) answer I would expect. Unfortunately, there is FGITW (I think it is a real problem).
– Peter Mortensen
yesterday
Yes, this is the (real) answer I would expect. Unfortunately, there is FGITW (I think it is a real problem).
– Peter Mortensen
yesterday
add a comment |
- You create a function for that.
- You call the function with the appropriate arguments when you need the value.
int z(int x, int y)
return (x + y);
int x;
int y;
// This does ot work
// int zx + y;
cin >> x;
cin >> y;
cout << z(x, y);
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
2 days ago
@NayWunnaZaw, yes, that is correct.
– R Sahu
2 days ago
1
@NayWunnaZaw, you can avoid the repeated use ofx
andy
by using a lambda function, as shown by Nathan but you still have to make the call.
– R Sahu
2 days ago
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
2 days ago
add a comment |
- You create a function for that.
- You call the function with the appropriate arguments when you need the value.
int z(int x, int y)
return (x + y);
int x;
int y;
// This does ot work
// int zx + y;
cin >> x;
cin >> y;
cout << z(x, y);
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
2 days ago
@NayWunnaZaw, yes, that is correct.
– R Sahu
2 days ago
1
@NayWunnaZaw, you can avoid the repeated use ofx
andy
by using a lambda function, as shown by Nathan but you still have to make the call.
– R Sahu
2 days ago
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
2 days ago
add a comment |
- You create a function for that.
- You call the function with the appropriate arguments when you need the value.
int z(int x, int y)
return (x + y);
int x;
int y;
// This does ot work
// int zx + y;
cin >> x;
cin >> y;
cout << z(x, y);
- You create a function for that.
- You call the function with the appropriate arguments when you need the value.
int z(int x, int y)
return (x + y);
int x;
int y;
// This does ot work
// int zx + y;
cin >> x;
cin >> y;
cout << z(x, y);
answered 2 days ago
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
2 days ago
@NayWunnaZaw, yes, that is correct.
– R Sahu
2 days ago
1
@NayWunnaZaw, you can avoid the repeated use ofx
andy
by using a lambda function, as shown by Nathan but you still have to make the call.
– R Sahu
2 days ago
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
2 days ago
add a comment |
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
2 days ago
@NayWunnaZaw, yes, that is correct.
– R Sahu
2 days ago
1
@NayWunnaZaw, you can avoid the repeated use ofx
andy
by using a lambda function, as shown by Nathan but you still have to make the call.
– R Sahu
2 days ago
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
2 days ago
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
2 days ago
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
2 days ago
@NayWunnaZaw, yes, that is correct.
– R Sahu
2 days ago
@NayWunnaZaw, yes, that is correct.
– R Sahu
2 days ago
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
2 days ago
@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
2 days ago
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
2 days ago
@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
2 days ago
add a comment |
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
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 beingdecltype(auto)
).
– Aconcagua
2 days ago
@Aconcagua thx! you are right. I edited my answer.
– Hiroki
2 days ago
Why downvoted ? At least I posted my answer faster than Ted with my tested code. Hmm... :)
– Hiroki
yesterday
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
yesterday
@Aconcagua thx for your comment. Although I was downvoted after few hours later of my edition, I was relieved to hear your words.
– Hiroki
yesterday
add a comment |
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
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 beingdecltype(auto)
).
– Aconcagua
2 days ago
@Aconcagua thx! you are right. I edited my answer.
– Hiroki
2 days ago
Why downvoted ? At least I posted my answer faster than Ted with my tested code. Hmm... :)
– Hiroki
yesterday
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
yesterday
@Aconcagua thx for your comment. Although I was downvoted after few hours later of my edition, I was relieved to hear your words.
– Hiroki
yesterday
add a comment |
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
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
edited yesterday
answered 2 days ago
HirokiHiroki
2,1503420
2,1503420
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 beingdecltype(auto)
).
– Aconcagua
2 days ago
@Aconcagua thx! you are right. I edited my answer.
– Hiroki
2 days ago
Why downvoted ? At least I posted my answer faster than Ted with my tested code. Hmm... :)
– Hiroki
yesterday
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
yesterday
@Aconcagua thx for your comment. Although I was downvoted after few hours later of my edition, I was relieved to hear your words.
– Hiroki
yesterday
add a comment |
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 beingdecltype(auto)
).
– Aconcagua
2 days ago
@Aconcagua thx! you are right. I edited my answer.
– Hiroki
2 days ago
Why downvoted ? At least I posted my answer faster than Ted with my tested code. Hmm... :)
– Hiroki
yesterday
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
yesterday
@Aconcagua thx for your comment. Although I was downvoted after few hours later of my edition, I was relieved to hear your words.
– Hiroki
yesterday
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
2 days ago
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
2 days ago
@Aconcagua thx! you are right. I edited my answer.
– Hiroki
2 days ago
@Aconcagua thx! you are right. I edited my answer.
– Hiroki
2 days ago
Why downvoted ? At least I posted my answer faster than Ted with my tested code. Hmm... :)
– Hiroki
yesterday
Why downvoted ? At least I posted my answer faster than Ted with my tested code. Hmm... :)
– Hiroki
yesterday
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
yesterday
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
yesterday
@Aconcagua thx for your comment. Although I was downvoted after few hours later of my edition, I was relieved to hear your words.
– Hiroki
yesterday
@Aconcagua thx for your comment. Although I was downvoted after few hours later of my edition, I was relieved to hear your words.
– Hiroki
yesterday
add a comment |
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();
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
yesterday
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 simplefoo
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
yesterday
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
yesterday
add a comment |
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();
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
yesterday
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 simplefoo
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
yesterday
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
yesterday
add a comment |
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();
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();
answered yesterday
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
yesterday
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 simplefoo
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
yesterday
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
yesterday
add a comment |
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
yesterday
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 simplefoo
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
yesterday
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
yesterday
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
yesterday
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
yesterday
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
yesterday
@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
yesterday
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
yesterday
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
yesterday
add a comment |
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.
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
yesterday
add a comment |
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.
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
yesterday
add a comment |
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.
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.
answered 2 days ago
o11co11c
10.9k43155
10.9k43155
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
yesterday
add a comment |
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
yesterday
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
yesterday
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
yesterday
add a comment |
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.
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.
Sign up or log in
StackExchange.ready(function ()
StackExchange.helpers.onClickDraftSave('#login-link');
);
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
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
Sign up or log in
StackExchange.ready(function ()
StackExchange.helpers.onClickDraftSave('#login-link');
);
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
Sign up or log in
StackExchange.ready(function ()
StackExchange.helpers.onClickDraftSave('#login-link');
);
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
Sign up or log in
StackExchange.ready(function ()
StackExchange.helpers.onClickDraftSave('#login-link');
);
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
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
3
Right, that won't work. That's a spreadsheet thing.
– Pete Becker
2 days ago
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
2 days ago
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
2 days ago
39
That's called a "function."
– ApproachingDarknessFish
2 days ago
3
Surely this is a bit of an XY-problem?
– Carmeister
yesterday