This snippet is compiled without errors in Visual Studio 2013 (Version 12.0.31101.00 Update 4)

    class A
    {
    public:
       A(){}
       A(A &amp;&amp;){}
    };
    
    int main(int, char*)
    {
       A a;
       new A(a);
       return 0;
    }

while it is compiled with this error in Visual Studio 2015 RC (Version 14.0.22823.1 D14REL):

    1&gt;------ Build started: Project: foo, Configuration: Debug Win32 ------
    1&gt;  foo.cpp
    1&gt;c:\dev\foo\foo.cpp(11): error C2280: &#39;A::A(const A &amp;)&#39;: attempting to reference a deleted function
    1&gt;  c:\dev\foo\foo.cpp(6): note: compiler has generated &#39;A::A&#39; here
    ========== Build: 0 succeeded, 1 failed, 0 up-to-date, 0 skipped ==========

I think that the compiler shipped with Visual Studio 2015 generates the Copy Constructor and marks it as `=delete` and so I get the error C2280 (which, by the way, I cannot find documented on msdn.microsoft.com).

Now, let&#39;s say I have a codebase which is compilable with Visual Studio 2013 (and it works because it relies on the code generated automatically by the compiler) but not compilable with Visual Studio 2015 due to C2280, how can I fix the problem?

I was thinking to declare class `A` in this way:

    class A
    {
    public:
       A(){}
       A(A &amp;&amp;){}
       A(const A&amp;)=default;
    };

am I missing something?


C++ Compiler Error C2280 &quot;attempting to reference a deleted function&quot; in Visual Studio 2013 and 2015

Suppose I have a POD type like this:

    struct A {
        char a;
        int b;
    };

On my system, `sizeof(A) == 8`, even though `sizeof(char) == 1` and `sizeof(b) == 4`.  This means that the data structure has 3 unused bytes.

Now suppose we do

    A x = ...;
    A y =x;

**Question:**

Is it guaranteed that all 8 bytes of `x` and `y` will be identical, even those 3 unused ones?

Equivalently, if I transfer the underlying bytes of some `A` objects to another program that does not understand their meaning or structure, and treats them as an array of 8 bytes, can that other program safely compare two `A`s for equality?

Note: [In an experiment with gcc 7][1], it appears that those bytes do get copied. I would like to know if this is guaranteed.


  [1]: http://coliru.stacked-crooked.com/a/364008a86ee4ec3d

Do the padding bytes of a POD type get copied?

I have a class :

    class SymbolIndexer {
    protected:
      SymbolIndexer ( ) { }
  
    public:
      static inline SymbolIndexer &amp; 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 &amp; ref_symbol_indexer_ = SymbolIndexer::GetUniqueInstance ( );



Disable copy constructor

I want to refresh my memory on the conditions under which a compiler typically auto generates a default constructor, copy constructor and assignment operator.

I recollect there were some rules, but I don&#39;t remember, and also can&#39;t find a reputable resource online. Can anyone help?

Conditions for automatic generation of default/copy/move ctor and copy/move assignment operator?

clone method vs copy constructor in java. which one is correct solution. where to use each case?

Clone() vs Copy constructor- which is recommended in java

Why must a copy constructor&#39;s parameter be passed by reference?

Why should the copy constructor accept its parameter by reference in C++?

 - What does *copying an object* mean?
 - What are the *copy constructor* and the *copy assignment operator*?
 - When do I need to declare them myself?
 - How can I prevent my objects from being copied?

What is The Rule of Three?

What is this idiom and when should it be used? Which problems does it solve? Does the idiom change when C++11 is used?

Although it&#39;s been mentioned in many places, we didn&#39;t have any singular &quot;what is it&quot; question and answer, so here it is. Here is a partial list of places where it was previously mentioned:

 * [What are your favorite C++ Coding Style idioms:  Copy-swap](https://stackoverflow.com/questions/276173/what-are-your-favorite-c-coding-style-idioms/2034447#2034447)
 * [Copy constructor and = operator overload in C++: is a common function possible?](https://stackoverflow.com/questions/1734628/copy-constructor-and-operator-overload-in-c-is-a-common-function-possible/1734640#1734640)
 * [What is copy elision and how it optimizes copy-and-swap idiom](https://stackoverflow.com/questions/2143787/what-is-copy-elision-and-how-it-optimizes-copy-and-swap-idiom)
 * [C++: dynamically allocating an array of objects?](https://stackoverflow.com/questions/255612/c-dynamically-allocating-an-array-of-objects/255744#255744)

What is the copy-and-swap idiom?

Since a copy constructor

    MyClass(const MyClass&amp;);

and an = operator overload

    MyClass&amp; operator = (const MyClass&amp;);

have pretty much the same code, the same parameter, and only differ on the return, is it possible to have a common function for them both to use?


Copy constructor and = operator overload in C++: is a common function possible?

I know that C++ compiler creates a copy constructor for a class. In which case do we have to write a user-defined copy constructor? Can you give some examples? 

When do we have to use copy constructors?

In C++, the concept of returning reference from the copy assignment operator is unclear to me. Why can&#39;t the copy assignment operator return a copy of the new object? In addition, if I have class `A`, and the following:

    A a1(param);
    A a2 = a1;
    A a3;
    
    a3 = a2; //&lt;--- this is the problematic line

The `operator=` is defined as follows:

    A A::operator=(const A&amp; a)
    {
    	if (this == &amp;a)
    	{
    		return *this;
    	}
    	param = a.param;
    	return *this;
    }

Why must the copy assignment operator return a reference/const reference?

See title.

I  have:

    class Foo {
       private:
         Foo();
       public:
         static Foo* create();
    }

What need I do from here to make Foo un-copyable?

Thanks!
         

How do I make this C++ object non-copyable?

Why doesn&#39;t Java support a copy constructor like in C++?

Why doesn&#39;t Java have a copy constructor?

I have a class that contains a dynamically allocated array, say

    class A
    {
        int* myArray;
        A()
        {
            myArray = 0;
        }
        A(int size)
        {
            myArray = new int[size];
        }
        ~A()
        {
            // Note that as per MikeB&#39;s helpful style critique, no need to check against 0.
            delete [] myArray;
        }
    }

But now I want to create a dynamically allocated array of these classes. Here&#39;s my current code:

    A* arrayOfAs = new A[5];
    for (int i = 0; i &lt; 5; ++i)
    {
        arrayOfAs[i] = A(3);
    }

But this blows up terribly. Because the new `A` object created (with the `A(3)` call) gets destructed when the `for` loop iteration finishes, and this means that the internal `myArray` of that `A` instance gets `delete []`-ed.

So I think my syntax must be terribly wrong? I guess there are a few fixes that seem like overkill, which I&#39;m hoping to avoid:

 * Creating a copy constructor for `A`.
 * Using `vector&lt;int&gt;` and `vector&lt;A&gt;` so I don&#39;t have to worry about all this.
 * Instead of having `arrayOfAs` be an array of `A` objects, have it be an array of `A*` pointers.

I would think this is just some beginners thing where there&#39;s a syntax that actually works when attempting to dynamically allocate an array of things that have internal dynamic allocation.

(Also, style critiques appreciated, since it&#39;s been a while since I did C++.)

**Update for future viewers**: All of the answers below are really helpful. Martin&#39;s is accepted because of the example code and the useful &quot;rule of 4,&quot; but I really suggest reading them all. Some are good, succinct statements of what&#39;s wrong, and some point out correctly how and why `vector`s are a good way to go.


Dynamically allocating an array of objects

If I override `operator=` will the copy constructor automatically use the new operator? Similarly, if I define a copy constructor, will `operator=` automatically &#39;inherit&#39; the behavior from the copy constructor?

The copy constructor and assignment operator

I have heard that C++ has something called &quot;conversion constructors&quot; or &quot;converting constructors&quot;.  What are these, and what are they for?  I saw it mentioned with regards to this code:

    class MyClass
    {
      public:
         int a, b;
         MyClass( int i ) {}
    }
    
     int main()
    {
        MyClass M = 1 ;
    }

All Copy Constructor Solutions on Gang of Coders

Total of 16 Copy Constructor Solutions

C++ Compiler Error C2280 "attempting to reference a deleted function" in Visual Studio 2013 and 2015