How Do C 11's `std::vector::resize()` and Boost.Container's `resize()` Handle Uninitialized Elements?

Vector Behavior in C 11 and Boost.Container: Handling Uninitialized Elements

In C applications, vectors are commonly used as temporary buffers. To ensure adequate capacity, these vectors often undergo resizing operations. In C 03, the std::vector::resize() function expands the vector by appending copies of a specified value. While this approach initializes unused elements, it can be inefficient when only vector size matters.

C 11 introduced two overloads of resize():

• resize(size_type n): Performs value initialization for unused elements.
• resize(size_type n, const value_type & val): Initializes unused elements with a copy of the provided value.

Boost.Container further extends this functionality with an additional overload:

• resize(size_type n, default_init_t): Performs default initialization for unused elements.

To verify the behavior of these functions, a test was conducted using C 11 std::vector and boost::container::vector:

1. Filled vectors with values [0, 1, 2, 3, 4, 5, 6, 7, 8, 9].
2. Removed some elements to create vectors with the desired size [0, 1, 2, 3, 4].
3. Resized vectors to 10 elements using different resize() overloads.
4. Printed the updated vectors.

Expected Behavior

For the C 03 std::vector, the unused elements should be initialized with zeros. The boost::container variants were expected to emulate C 03 behavior when compiled in C 03 mode and exhibit different behavior when compiled in C 11 mode.

Actual Results

Surprisingly, the test results revealed that both std::vector and boost::container::vector exhibited the same behavior. In all cases, the unused elements were initialized with zeros, regardless of the resize() overload used.

Explanation

This unexpected behavior suggests that the resize() interface change introduced in C 11 has no practical effect in the given scenario. The C 03 std::vector::resize() function default-initializes unused elements by default. In C 11, the resize() overloads provide additional options for explicit initialization, but they do not alter the default behavior of default-initializing unused elements. The same behavior is reflected in the Boost.Container implementation.

Implications

If you need to avoid initializing unused elements with zeros, you can use a custom allocator that intercepts std::allocator's construct() method and replaces value-initialization with default-initialization. However, proceed with caution, as applying this to all initializations can lead to unintended consequences.

The above is the detailed content of How Do C 11's `std::vector::resize()` and Boost.Container's `resize()` Handle Uninitialized Elements?. For more information, please follow other related articles on the PHP Chinese website!