copy-assignment

These are my prototypes, MyClass& operator=(MyClass rhs); // copy assignment MyClass& operator=(MyClass &&rhs); // move assignment But when I call MyClass a, b; a = std::move(b); , there is an error. 556 IntelliSense: more than one operator "=" matches these operands: function "MyClass::operator=(MyClass rhs)" function "MyClass::operator=(MyClass &&rhs)" operand types are: MyClass = MyClass And the compiler returns: Error 56 error C2593: 'operator =' is ambiguous Overload resolution is ambiguous because when you pass an rvalue, both MyClass and MyClass && can be directly initialised by it. If

I have a 2D array A of shape (4,3) , and a 1D array a of shape (4,) . I want to swap the first two rows of A , as well as the first two elements in a . I did the following: A[0,:],A[1,:] = A[1,:],A[0,:] a[0],a[1] = a[1],a[0] Apparently, it works for a , but fails for A . Now, the second row becomes the first row, but the first row remains unchanged. If I do the following: first_row_copy = A[0,:].copy() A[0,:] = A[1,:] A[1,:] = first_row_copy Then, it seems to work. Why the first method doesn't work? (but works for a ) Also, what's the difference between A_copy = A[0,:].copy() and A_copy = A[0,

Coming from a c++ background I'm curious about object assignment in Ruby. What considerations (if any) should be made for the following object assignments: class MyClass attr_accessor :a, :b def initialize(a, b) @a = a @b = b end def some_method puts "#{self.a} #{self.b}" end end m = MyClass.new("first", "last") n = MyClass.new("pizza", "hello") q = n q.some_method If you're familiar with C++, then you might want to consider every variable in Ruby, instance or otherwise, as a reference to another object. Since everything in Ruby is an object, even nil , which is of type NilClass, this holds

Here we can read that no copy construct and copy assignment operator evaluable. But here we can read that qRegisterMetaType and Q_DECLARE_METATYPE have to have public default constructor, public copy constructor and public destructor. The question is: who is telling a lie? Or I did not understand it correctly? Ezee Everything is true: 1. QObject can't be copied and all its descendants can't be copied also. 2. Q_DECLARE_METATYPE accepts objects with public constructor, copy constructor and destructor. There is no contradiction, because you can't register QObject descendants with Q_DECLARE

What is the difference between this: TestClass t; And this: TestClass t = TestClass(); I expected that the second might call the constructor twice and then operator=, but instead it calls the constructor exactly once, just like the first. TestClass t; calls the default constructor. TestClass t = TestClass(); is a copy initialization . It will call the default constructor for TestClass() and then the copy constructor (theoretically, copying is subject to copy elision ). No assignment takes place here . There's also the notion of direct initialization : TestClass t(TestClass()); If you want to