C++ copy assignment为何不适用于未初始化对象？

Great question—this cuts to a core distinction between object construction and assignment in C++, which is key to understanding how containers like vector manage memory under the hood. Let’s break this down clearly:

1. Copy Assignment Requires an Existing, Valid Object #

The copy assignment operator (operator=) has a non-negotiable precondition: the left-hand side must be a fully constructed, valid object. Its entire job is to overwrite the state of an already existing object with the state of another.

For example:

MyClass a;
MyClass b;
a = b; // Valid: a is already a constructed object

Here, a exists first—operator= will clean up any resources a holds (like freeing dynamic memory) before copying data from b into it.

2. Uninitialized Memory Has No Object to Assign To #

When vector resizes, it allocates raw, uninitialized memory. This isn’t just empty space—it’s memory that hasn’t been converted into a valid object yet. There’s no existing instance in that space to run operator= on.

If you tried to force assignment here (e.g., *new_ptr = *old_ptr; where new_ptr points to uninitialized memory), you’d be invoking operator= on a "ghost" object—one that never had its constructor called. This is undefined behavior: the operator might try to access non-existent member variables or free memory that was never allocated, leading to crashes or corrupted data.

3. Placement New Is the Correct Tool for Uninitialized Memory #

To turn raw memory into a valid object, you need placement new. This constructs an object directly in pre-allocated memory, skipping the normal memory allocation step:

// new_buf points to uninitialized memory large enough for MyClass
new (new_buf) MyClass(*old_ptr); // Uses copy constructor to create a valid object in new_buf

This is exactly what vector does during resizing: it uses placement new to construct copies (or moves) of old elements in the new space, then destroys the old objects and deallocates the original memory.

4. Why Avoid assign? #

Stroustrup mentions skipping assign because vector::assign is designed to replace a vector’s existing elements. Using it for uninitialized memory would require first default-constructing objects in the new space (wasteful and inefficient) just to overwrite them—plus, this doesn’t work for types that can’t be default-constructed.

In short: assignment modifies existing objects; construction creates objects from scratch. Uninitialized memory needs construction, not assignment.

内容的提问来源于stack exchange，提问作者Han XIAO