How to Resize a Vector Without Initializing New Elements in C++?

Last Updated : 27 Nov, 2024

In C++, when a vector is resized upward (increased size) using vector resize() method, the new elements are initialized to the default value for the vector's type (e.g., 0 for int). However, in some cases, initializing these new elements might be unnecessary in performance-critical applications.

Vector elements are initialized when it is allocated some memory. This is handled by the vector allocator's construct method. This allocator can be replaced by our own custom allocator to manage the behaviour of memory allocation and prevent the default initialization of elements. Let's take a look at example:

C++

#include <bits/stdc++.h>
using namespace std;

// Custom allocator that does not initialize elements
template <typename T>
class Alloc {
public:
    using value_type = T;
  
  	// Allocate sufficient memory
    T* allocate(size_t n) {
        return static_cast<T*>(::operator new(n * sizeof(T)));
    }
    
    void deallocate(T* p, size_t n) noexcept {
        ::operator delete(p, sizeof(T) * n);
    }

    // Override construct to skip initialization
    template <typename U, typename... Args>
    void construct(U* p, Args&&...) noexcept {
      
        // No initialization occurs
    }
    template <typename U>
    void destroy(U* p) noexcept {
        p->~U();
    }
};

// Classes to log construction
class A {
    public:
    int a;
    A(int x = 0): a(x) {
        cout << "\tConstructor Called\n";
    }
};


int main() {
    vector<A> v1;
    vector<A, Alloc<A>> v2;
    
    // Resizing vector with default Allocator
  	cout << "In Vector 1:\n";
    v1.resize(2);
    
    // Resize vector with custom Allocator
  	cout << "In Vector 2:\n";
    v2.resize(2);
    
    return 0;
}

Output

In Vector 1:
	Constructor Called
	Constructor Called
In Vector 2:

Explanation: As we can see, in v1, object is initialized to their default value using their constructor. But in v2 for which we have used custom comparator, there is no such initialization for the new elements.

The above method works for any data type including primitive types such as int, float, etc. But if you only need to deal with user-defined data type, initialization can be controlled from the data type itself instead of vector allocator.

Using a Custom No-Op Constructor

In this method, initialization can be controlled at the data type level by adding a no-op constructor. A new resize function is created that uses vector reserve() to allocate the memory without initialization and then increase the vector size using vector emplace_back(). This eliminates the need to modify the vector's allocator.

C++

#include <bits/stdc++.h>
using namespace std;

// Struct to be used as tag
struct NoInit {};
const NoInit noInit;

struct A {
    float x, y, z;

    // Default constructor initializes members
    A() : x(0), y(0), z(0) {
      	cout << "Constructor Called\n";
    }

    // No-op constructor leaves members uninitialized
    A(NoInit) {}
};

void newResize(vector<A>& v, size_t n) {
  
    // Reserve memory for new size
    v.reserve(n);

    // Add uninitialized elements using no-op constructor
    while (v.size() < n) {
        v.emplace_back(noInit);
    }

    // Adjust size if the vector is larger than n
    v.resize(n);
}

int main() {
    vector<A> v;

    // Resize to 5 elements without initializing
    newResize(v, 5);

    return 0;
}

Output

{empty}

Explanation: As we can see, the constructor of A was not called after the resize operation to initialize the new elements to default value. This technique uses the concept of the function overloading to call the version of constructor that does nothing using NoInit struct as the argument. This technique is called Tag Dispatch.

How to Remove Elements from a Vector while Iterating in C++?

gaurav472

Improve

Article Tags :

Practice Tags :

How to Resize a Vector Without Initializing New Elements in C++?

Using a Custom No-Op Constructor

Similar Reads

Thank You!

What kind of Experience do you want to share?