assignment-operator

1.char str[] = "hello"; //legal 2.char str1[]; str1 = "hello"; // illegal I understand that "hello" returns the address of the string literal from the string literal pool which cannot be directly assigned to an array variable. And in the first case the characters from the "hello" literal are copied one by one into the array with a '\0' added at the end. Is this because the assignment operator "=" is overloaded here to support this? I would also like to know other interesting cases wherein initialization is different from assignment. You cannot think of it as overloading (which doesn't exist in

At what point does JavaScript determine the left-hand side of an assignment — is it before or after the right-hand side is evaluated? For example, what does this code do? var arr = [{thing:1},{thing:2},{thing:3},{last:true}]; arr[arr.length - 1].newField = arr.pop(); The left-hand side of an assignment operator is evaluated first. The specification for this as of ES2015 can be found in the "Runtime Semantics: Evaluation" portion of the "Assignment Operators" section and can be very roughly summarized as: Evaluate the LHS to determine the reference Evaluate the RHS to determine the value Assign

I tried the following code as a naive attempt to implement swapping of R and B bytes in an ABGR word #include <stdio.h> #include <stdint.h> uint32_t ABGR_to_ARGB(uint32_t abgr) { return ((abgr ^= (abgr >> 16) & 0xFF) ^= (abgr & 0xFF) << 16) ^= (abgr >> 16) & 0xFF; } int main() { uint32_t tmp = 0x11223344; printf("%x %x\n", tmp, ABGR_to_ARGB(tmp)); } To my surprise this code "worked" in GCC in C++17 mode - the bytes were swapped http://coliru.stacked-crooked.com/a/43d0fc47f5539746 But it is not supposed to swap bytes! C++17 clearly states that the RHS of assignment is supposed to be [fully]

It seems to me there should be four variants of boost::optional optional<Foo> => holds a mutable Foo and can be reassigned after initialization optional<Foo const> const => holds a const Foo and can't be reassigned after initialization optional<Foo> const => (should?) hold a mutable Foo but can't be reassigned after initialization optional<Foo const> => (should?) hold a const Foo and can be reassigned after initialization The first 2 cases work as expected. But the optional<Foo> const dereferences to a const Foo, and the optional<Foo const> doesn't allow reassignment after initialization (as

Here is a test file from gcc, live demo struct do_nothing { template <class T> void operator()(T*) {} }; int main() { int i = 0; std::unique_ptr<int, do_nothing> p1(&i); std::unique_ptr<int> p2; static_assert(!std::is_assignable<decltype(p2), decltype(p1)>::value, ""); // note ! here. } std::is_assignable If the expression std::declval<T>() = std::declval<U>() is well-formed in unevaluated context, provides the member constant value equal true. Otherwise, value is false. Access checks are performed as if from a context unrelated to either type. std::declval : template<class T> typename std:

Let's have this code: Test1 t1; Test2 t2; t1 = t2; I believe there are three (or more?) ways how to implement t1 = t2 to overload assign operator in Test1 to overload type cast operator in Test2 to create Test1(const Test2&) conversion constructor According to my GCC testing, this is the priority of what is used: assign operator conversion constructor and type cast operator (ambiguous) const conversion constructor and const type cast operator (ambiguous) Please help me understand why this priority. I use this code for testing (uncomment some lines to try out) struct Test2; struct Test1 { Test1