assignment-operator

I've run into an issue I don't understand and I was hoping someone here might provide some insight. The simplified code is as follows (original code was a custom queue/queue-iterator implementation): class B { public: B() {}; class C { public: int get(); C(B&b) : b(b){}; private: B& b; }; public: C get_c() { return C(*this); } }; int main() { B b; B::C c = b.get_c(); c = b.get_c(); return EXIT_SUCCESS; } This, when compiled, gives me the following error: foo.cpp: In member function 'B::C& B::C::operator=(const B::C&)': foo.cpp:46: error: non-static reference member 'B& B::C::b', can't use

I am trying to use a if condition to assign a value to a variable in an xquery. I am not sure how to do this. This is what I tried: declare namespace libx='http://libx.org/xml/libx2'; declare namespace atom='http://www.w3.org/2005/Atom'; declare variable $entry_type as xs:string external; let $libx_node := if ($entry_type = 'package' or 'libapp') then {element {fn:concat("libx:", $entry_type)} {()} } else if ($entry_type = 'module') then '<libx:module> <libx:body>{$module_body}</libx:body> </libx:module>' This code throws an [XPST0003] Incomplete 'if' expression error. Can someone help me fix

Recently, I have followed a discussion about assignments to expressions in C++ as shown in the following example: string s1, s2, s3; (s1 + s2) = s3; With C++11 it is possible to restrict the assignment operator to lvalue references (on the left side). When declaring the assignment operators as follow, the compiler Clang rejects the code with an error message due to incompatible types. auto operator=(const string& rhs) & -> string&; auto operator=(string&& rhs) & -> string&; I haven't seen this anywhere. Is there a good reason for not using lvalue reference qualifiers for assignment operators

Following is a simplified version of an actual problem. Rather than call Base::operator=(int) , the code appears to generate a temporary Derived object and copy that instead. Why doesn't the base assignment operator get used, since the function signature seems to match perfectly? This simplified example doesn't display any ill effects, but the original code has a side-effect in the destructor that causes all kinds of havoc. #include <iostream> using namespace std; class Base { public: Base() { cout << "Base()\n"; } Base(int) { cout << "Base(int)\n"; } ~Base() { cout << "~Base()\n"; } Base&

Can you help me is there definition in C++ standard that describes which one will be called constructor or assignment operator in this case: #include <iostream> using namespace std; class CTest { public: CTest() : m_nTest(0) { cout << "Default constructor" << endl; } CTest(int a) : m_nTest(a) { cout << "Int constructor" << endl; } CTest(const CTest& obj) { m_nTest = obj.m_nTest; cout << "Copy constructor" << endl; } CTest& operator=(int rhs) { m_nTest = rhs; cout << "Assignment" << endl; return *this; } protected: int m_nTest; }; int _tmain(int argc, _TCHAR* argv[]) { CTest b = 5; return 0; }