copy initialization
From cppreference.com
Initializes an object from another object
Contents |
[edit] Syntax
| T object = other ; | (1) | ||||||||
| f(other); | (2) | ||||||||
| return other; | (3) | ||||||||
| catch ( T other) ; | (4) | ||||||||
| T array [ N ] = { other }; | (5) | ||||||||
[edit] Explanation
Copy initialization is performed in the following situations:
1) when a named variable (automatic, static, or thread-local) is declared with the initializer consisting of an equals sign followed by an expression.
2) when passing an argument to a function by value
3) when returning from a function that returns by value
4) when catching an exception by value
5) as part of aggregate initialization, to initialize each element for which an initializer is provided
The effects of copy initialization are:
- If T is a class type and the type of other is cv-unqualified version of T or a class derived from T, the constructors of T are examined and the best match is selected by overload resolution. The constructor is then called to initialize the object.
- If T is a class type, and the type of other is different, or if T is non-class type, but the type of other is a class type, user-defined conversion sequences that can convert from the type of other to T are examined and the best one is selected through overload resolution. The result of the conversion, which is a prvalue temporary of the destination type, is then used to direct-initialize the object. Most compilers eliminate the last step and construct the temporary from the conversion function directly in the memory occupied by the target object.
- Otherwise (if neither T nor the type of other are class types), standard conversions are used, if necessary, to convert the value of other to the cv-unqualified version of T.
[edit] Notes
Copy-initialization is less permissive than direct-initialization: copy-initialization only considers non-explicit constructors and user-defined conversion functions.
If other is an rvalue expression, move constructor will be selected by overload resolution and called during copy-initialization.
In many cases, copy-initialization is optimized out, see copy elision
The equals sign, =, in copy-initialization of a named variable is not related to the assignment operator. Assignment operator overloads have no effect on copy-initialization.
[edit] Example
#include <string> #include <utility> #include <memory> int main() { std::string s = "test"; // OK: constructor is non-explicit std::string s2 = std::move(s); // this copy-initialization performs a move // std::unique_ptr<int> p = new int(1); // error: constructor is explicit std::unique_ptr<int> p(new int(1)); // OK: direct-initialization int n = 3.14; // floating-integral conversion const int b = n; // const doesn't matter int c = b; // ...either way }
