assignment-operator

Possible Duplicate: Assignment operators in R: '=' and '<-' I'm using R 2.8.1 and it is possible to use both = and <- as variable assignment operators. What's the difference between them? Which one should I use? From here : The operators <- and = assign into the environment in which they are evaluated. The operator <- can be used anywhere, whereas the operator = is only allowed at the top level (e.g., in the complete expression typed at the command prompt) or as one of the subexpressions in a braced list of expressions. Reading from "Introducing Monte Carlo Methods with R", by Robert and

I have extended std::string to fulfil my needs of having to write custom function build into string class called CustomString I have defined constructors: class CustomString : public std::string { public: explicit CustomString(void); explicit CustomString(const std::string& str); explicit CustomString(const CustomString& customString); //assignment operator CustomString& operator=(const CustomString& customString); ... }; In the third constructor (copy constructor) and assignment operator, whose definition is: CustomString::CustomString(const CustomString& customString): std::string(static

Why is that undefined behaviour? struct s { const int id; // <-- const member s(int id): id(id) {} s& operator =(const s& m) { return *new(this) s(m); // <-- undefined behavior? } }; (Quote from the standard would be nice). This question arose from this answer . There is nothing that makes the shown code snippet inherently UB. However, it is almost certain UB will follow immediately under any normal usage. From [basic.life]/8 (emphasis mine) If, after the lifetime of an object has ended and before the storage which the object occupied is reused or released, a new object is created at the

As I've understand, when overloading operator=, the return value should should be a non-const reference. A& A::operator=( const A& ) { // check for self-assignment, do assignment return *this; } It is non-const to allow non-const member functions to be called in cases like: ( a = b ).f(); But why should it return a reference? In what instance will it give a problem if the return value is not declared a reference, let's say return by value? It's assumed that copy constructor is implemented correctly. Not returning a reference is a waste of resources and a yields a weird design. Why do you want

Why does the regular assignment statement (say, x = 5 ) return the value assigned ( 5 in this case), while the assignment combined with a variable declaration ( var x = 5 ) returns undefined ? I got the return values by executing these statements in the Chrome browser's Javascript console: > var x = 5; undefined > y = 5; 5 That's the way the language was designed. It is consistent with most languages. Having a variable declaration return anything other than undefined is meaningless, because you can't ever use the var keyword in an expression context. Having assignment be an expression not a

Why do people define a private copy constructor? When is making the copy constructor and the assignment operator private a good design? If there are no members in the class which are pointers or handles to a unique object (like file name), then wat other cases are there where private copy constructor is a good idea? Same question apply for assignment operator. Given that majority of C++ revolves around copying of objects and passing by reference, are there any good designs which involve private copy constructor? Some objects represent particular entities that can't or shouldn't be copied. For