Copying and moving are value-semantic operations. To define them, you first have to decide what properties of a class give its objects distinct values. This point was at first largely sidestepped for the iostreams library, and then C++11 took a different direction incompatible with such a copy constructor. The state of a stream object comprises … Read more
B b2 = a; This is known as Copy Initialization. It does the following: Create an object of type B from a by using B (const A& a). Copy the created temporary object to b2 by using B (const B& b). Destroy the temporary object by using ~B(). The error you get is not at … Read more
You need to use the virtual copy pattern: provide a virtual function in the interface that does the copy and then implement it across the hierarchy: struct base { virtual ~base() {} // Remember to provide a virtual destructor virtual base* clone() const = 0; }; struct derived : base { virtual derived* clone() const … Read more
Case 1) m is interpreted as a function return my and taking no arguments. To see the expected output remove () i.e use my m; Case 2) This is something better known as the “Most vexing parse”. n is interpreted as a function returning my that takes an argument of type pointer to function returning … Read more
The first one is better Even better is C++0x ‘delete’ keyword: class Class { // useful stuff, then public: Class(const Class&) = delete; void operator=(const Class&) = delete; };
class Foo { private: Foo(); Foo( const Foo& ); // non construction-copyable Foo& operator=( const Foo& ); // non copyable public: static Foo* create(); } If you’re using boost, you can also inherit from noncopyable : http://www.boost.org/doc/libs/1_41_0/boost/noncopyable.hpp EDIT: C++11 version if you have a compiler supporting this feature: class Foo { private: Foo(); public: Foo( … Read more
Because the standard says so. [class.inhctor]/p3, emphasis mine: For each non-template constructor in the candidate set of inherited constructors other than a constructor having no parameters or a copy/move constructor having a single parameter, a constructor is implicitly declared with the same constructor characteristics unless there is a user-declared constructor with the same signature in … Read more
The explicit copy constructor means that the copy constructor will not be called implicitly, which is what happens in the expression: CustomString s = CustomString(“test”); This expression literally means: create a temporary CustomString using the constructor that takes a const char*. Implicitly call the copy constructor of CustomString to copy from that temporary into s. … Read more
A copy constructor is of the form X(X& ) or (X const&) and will be provided for you by the compiler if you didn’t declare one yourself (or a few other conditions which are not relevant here). You didn’t, so implicitly we have the following set of candidates: MyTemplateClass(const MyTemplateClass&); template <typename U> MyTemplateClass(const MyTemplateClass<U>&); … Read more
This is what the standard says in 12.8 (Copying class objects). Copy construction: Each subobject is copied in the manner appropriate to its type: if the subobject is of class type, the copy constructor for the class is used; if the subobject is an array, each element is copied, in the manner appropriate to the … Read more