 <p>All of the answers you've gotten so far are overly complicated and/or slightly misleading.</p> <p>In the first construction/initialization:</p> <pre><code>T a(10); </code></pre> <p>The very obvious thing happens. The second construction/initialization is more interesting:</p> <pre><code>T aa = 10; </code></pre> <p>This is equivalent to:</p> <pre><code>T aa(T(10)); </code></pre> <p>Meaning that you create a temporary object of type T, and then construct <code>aa</code> as a copy of this temporary. This means that the copy constructor is called.</p> <p>C++ has a default copy constructor that it creates for a class when you have none explicitly declared. So even though the first version of <code>class T</code> has no copy constructor declared, there still is one. The one the compiler declares has this signature <code>T(const T &amp;)</code>.</p> <p>Now in your second case where you declare something that looks like a copy constructor, you make the argument a <code>T &amp;</code>, not a <code>const T &amp;</code>. This means that the compiler, when trying to compile the second expression, tries to use your copy constructor, and it can't. It's complaining that the copy constructor you declared requires a non-const argument, and the argument it's being given is const. So it fails.</p> <p>The other rule is that after the compiler has converted your initialization to <code>T aa(T(10));</code> it is then allowed to transform it to <code>T aa(10);</code>. This is called 'copy elision'. The compiler is allowed, in certain circumstances, to skip calls to the copy constructor. But it may only do this after it verifies that the expression is correctly formed and doesn't generate any compiler errors when the copy constructor call is still there. So this is an optimization step that may affect exactly which parts of a program run, but cannot affect which programs are valid and which ones are in error (at least from the standpoint of whether or not they compile).</p>