Logically, it should make no sense to modify an object of which you just want to make a copy, though sometimes it may have some sense, like a situation where you’d like to store the number of time this object has been copied. But this could work with a mutable member variable that stores this … 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
One use case is the singleton pattern where there can only be exactly one instance of a class. In this case, you need make your constructors and assignment operator= private so that there is no way of creating more than one object. The only way to create an object is via your GetInstance() function as … 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
Java does. They’re just not called implicitly like they are in C++ and I suspect that’s your real question. Firstly, a copy constructor is nothing more than: public class Blah { private int foo; public Blah() { } // public no-args constructor public Blah(Blah b) { foo = b.foo; } // copy constructor } Now … Read more
You can make the copy constructor private and provide no implementation: private: SymbolIndexer(const SymbolIndexer&); Or in C++11, explicitly forbid it: SymbolIndexer(const SymbolIndexer&) = delete;
Here is how it can work A f() { return { 10 }; } This works even though A has no working copy or move constructor and no other constructor that could copy or move an A! To make use of this feature of C++11, the constructor (taking int in this case) has to be … 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
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