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
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
The implicitly-defined copy/move constructor for a non-union class X performs a memberwise copy/move of its bases and members. 12.8/15 [class.copy] in N4141 The bit pattern in the padding bytes is thus allowed to differ.
I’ve upvoted ildjarn’s answer because I found it both accurate and humorous. 🙂 I’m providing an alternate answer because I’m assuming because of the title of the question that the OP might want to know why the standard says so. background C++ has implicitly generated copy members because if it didn’t, it would’ve been still-born … Read more
The definition for a converting constructor is different between C++03 and C++11. In both cases it must be a non-explicit constructor (otherwise it wouldn’t be involved in implicit conversions), but for C++03 it must also be callable with a single argument. That is: struct foo { foo(int x); // 1 foo(char* s, int x = … Read more
From [class.copy]/7, emphasis mine: If the class definition does not explicitly declare a copy constructor, a non-explicit one is declared implicitly. If the class definition declares a move constructor or move assignment operator, the implicitly declared copy constructor is defined as deleted; otherwise, it is defined as defaulted (8.4). The latter case is deprecated if … Read more
No, they are different operators. The copy constructor is for creating a new object. It copies an existing object to a newly constructed object.The copy constructor is used to initialize a new instance from an old instance. It is not necessarily called when passing variables by value into functions or as return values out of … Read more
For building containers you obviously want to use one of the standard containers (such as a std::vector). But this is a perfect example of the things you need to consider when your object contains RAW pointers. If your object has a RAW pointer then you need to remember the rule of 3 (now the rule … 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
Strictly speaking, the result of a copy assignment operator doesn’t need to return a reference, though to mimic the default behavior the C++ compiler uses, it should return a non-const reference to the object that is assigned to (an implicitly generated copy assignment operator will return a non-const reference – C++03: 12.8/10). I’ve seen a … Read more