c++ allows mutability right then why isnt this working
#include <iostream>
int main() {
double filesize = 100;
double sales = 10.10;
filesize, sales == sales, filesize ;
std::cout << (filesize); << (sales);
return 0;
}
#Variable swap code
ocean crag
young glenBOT
ocean tree
Will there are multiple things wrong with... All of that
First, == is equality, not assignment.
Second the comma operator doesn't make tuples, it just evaluates both side and "returns" the second.
Third, even if you had a pair, you can't do a decomposing assignment to already existing variables
All in all, this isn't python
If you want to swap, either do it manually using a temporary variable, or use the std::swap method
ocean crag
okay thank you
young glenBOT
robust nacelle
okay thank you
So, did you manage to implement a swap (without using std::swap)?
If yes, as a small challenge you could try to swap the two elements without using a 3rd temporary variable (and without using std::swap of course)
bronze sinew
So, did you manage to implement a swap (without using `std::swap`)?
If yes, as ...
std::exchange 
robust nacelle
`std::exchange` <:kekw:673277564034482178>
ocean crag
#include <iostream>
int main() {
double filesize = 100;
double sales = 10.10;
double emptybucket = filesize;
filesize = sales;
sales = emptybucket;
std::cout << (filesize);
return 0;
}
||
a = a + b;
b = a - b;
a = a - b;
||
bronze sinew
wow
ocean crag
does swapping differ from language to language? Are we supposed to remember different logics for different languages?
robust nacelle
does swapping differ from language to language? Are we supposed to remember diff...
nope (although there are some small syntactical improvements in other languages)
bronze sinew
does swapping differ from language to language? Are we supposed to remember diff...
it all works the same
ocean crag
okay
bronze sinew
||
```cpp
a = a + b;
b = a - b;
a = a - b;
```
||
ah, algebra~y trick
amaze amaze amaze
cold frigate
you could actually do something horrible with tuples and tuples of references like:
std::tie(b,a) = std::tuple(a,b);
but that does needless copies and is just, bleh
robust nacelle
ah, algebra~y trick
Yeah, with floating point numbers it's a bit iffy because of rounding errors, but that's fine given the beginner context
!cppref std::tie
young glenBOT
robust nacelle
(always forget what this does)
bronze sinew
std::tie works the same like
auto [a, b] = ...;
right?
cold frigate
yesn't
bronze sinew
awesome
cold frigate
auto [a,b] would copy
cold frigate
while tie(a,b) makes a tuple of references
bronze sinew
also, std::tie would assign to the variable right
cold frigate
the = is the part assigning
cold frigate
tie is kind of doing the opposite
tying together two things into one tuple
while auto& [a,b] "takes apart (not really)" to parts of a tuple/struct/...
robust nacelle
`auto [a,b]` would copy
Can you do
auto &[a, b] = ...;
```or smth like:
```cpp
auto [&a, &b] = ...;
```or smth alike? Pretty sure you can't, but since you're here already, figured why not aski see
cold frigate
Can you do
```cpp
auto &[a, b] = ...;
```or smth like:
```cpp
auto [&a, &b] = ....
the first one, yes
robust nacelle
oh wow, really? Damn
cold frigate
it doesn't actually split apart the object in C++, it keeps the whole thing around,
but binds the names a, b to the two members
so you can only decide whether the whole thing is a reference or copy
not the individual parts
bronze sinew
i see
robust nacelle
makes sense, pretty much what you would expect
bronze sinew
sad
cold frigate
you'd have to do
auto [a, x] = ...;
auto [b, c] = x;
😛
bronze sinew
not cursed enough
ocean crag
i did not undertand a single thing
pearl pebble
i did not undertand a single thing
just do this:
temp = a;
a = b;
b = temp;
and don't concern your self with other things [ for now ].
ocean crag
just do this:
```c
temp = a;
a = b;
b = temp;
```
and don't concern your self ...
how does this things logic work?
a=5
b=2
a=7
b=3
a= 3?
robust nacelle
why cant i put a=b; at the last
Try it out and see