copy-constructor

See title. I have: class Foo { private: Foo(); public: static Foo* create(); } What need I do from here to make Foo un-copyable? Thanks! Klaim 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(); Foo( const Foo& ) = delete; // non construction-copyable Foo& operator=( const Foo& )

In C++03 it is impossible to return an object of a class having a private non-defined copy constructor by value: struct A { A(int x) { ... } private: A(A const&); }; A f() { return A(10); // error! return 10; // error too! } I was wondering, was this restriction lifted in C++11, making it possible to write functions having a class type return type for classes without constructors used for copy or move? I remember it could be useful to allow callers of a function use the newly returned object, but that they are not able to copy the value and store it somewhere. Here is how it can work A f() {

I have a class : class SymbolIndexer { protected: SymbolIndexer ( ) { } public: static inline SymbolIndexer & GetUniqueInstance ( ) { static SymbolIndexer uniqueinstance_ ; return uniqueinstance_ ; } }; How should I modify it to disable code like: SymbolIndexer symbol_indexer_ = SymbolIndexer::GetUniqueInstance ( ); and only allow code like : SymbolIndexer & ref_symbol_indexer_ = SymbolIndexer::GetUniqueInstance ( ); R. Martinho Fernandes You can make the copy constructor private and provide no implementation: private: SymbolIndexer(const SymbolIndexer&); Or in C++11, explicitly forbid it:

Why doesn't Java support a copy constructor like in C++? 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 C++ will implicitly call the copy constructor with a statement like this: Blah b2 = b1; Cloning/copying in that instance simply makes no sense in Java because all b1 and b2 are references and not value objects like they are in C++. In C+

I've got the following code: class C { public: C(int) {} C(const C&) {} C() {} }; class D : public C { public: using C::C; }; int main() { C c; D d_from_c(c); // does not compile, copy ctor is not inherited D d_from_int(1); // compiles, C(int) is inherited } Derived class should inherit all ctors of base except the default ctor (it is explained here ). But why copy ctor is not inherited as well? Arguments from the related question are not acceptable here. The code is compiled with g++ 4.8.1. Because the standard says so. [class.inhctor]/p3, emphasis mine: For each non-template constructor in

class MyClass { public: ~MyClass() {} MyClass():x(0), y(0){} //default constructor MyClass(int X, int Y):x(X), y(Y){} //user-defined constructor MyClass(const MyClass& tempObj):x(tempObj.x), y(tempObj.y){} //copy constructor private: int x; int y; }; int main() { MyClass MyObj(MyClass(1, 2)); //user-defined constructor was called. MyClass MyObj2(MyObj); //copy constructor was called. } In the first case, when MyClass(1, 2) calls the user-defined constructor and returns an object, I was expecting MyObj to call the copy constructor. Why it doesn't need to call the copy constructor for the second