How to Initialize a Vector in C++

As a full-stack developer, working with data structures like vectors is essential for managing data efficiently in C++ applications. Vectors are dynamic arrays that allow storage and access of data elements in a contiguous block of memory. They are extremely useful when the quantity of data being handled is unknown or likely to change. In this comprehensive guide, we will explore the anatomy of a C++ vector, why they are useful, and various ways to initialize a vector with example code snippets.

Anatomy of a C++ Vector

A vector in C++ has the following key properties:

• Dynamic size – The size grows and shrinks automatically as elements are added or removed
• Contiguous storage – Data elements are stored in contiguous blocks of memory for faster access
• Fast access – Supports fast random access to elements using index values
• Flexibility – They can contain data types like int, string, objects etc.
• Methods – Useful built-in methods for common operations like add, remove, insert, size etc.

Syntactically, a vector is declared as:

vector <datatype> vectorName; 

Some key methods are:

• push_back(element) – Adds new element to end
• size() – Gives current size
• capacity() – Total allocated storage capacity
• resize(n) – Resizes to n elements
• clear() – Deletes all elements

Now that we understand the basics of vectors, let‘s move on to initialization techniques.

Why Initialize Vectors?

Initializing a vector allocates the required memory so data elements can be stored. An uninitialized vector cannot store data.

Proper initialization also enables:

• Adding elements from the start safely
• Avoiding unexpected errors
• Specifying initial size or capacity as per need
• Setting default values for data elements

Some common initialization needs are:

• Store a fixed set of data upfront
• Prepare empty vector of required size to add data later
• Set all elements to a default value

The key is choosing the right initialization method for your use-case.

1. With fill Constructor

This uses an overloaded vector constructor that initializes by filling all elements with the specified value.

vector<int> vec(10, 5); //10 elements with value 5

This allocates 10 int elements, sets each to 5.

Let‘s initialize a vector to store 10 student marks out of 100.

vector<double> marks(10, 0); //10 students with 0 marks initially 

We set 0 to track students without marks set.

When to use?

Great when you need to prefill a vector with a meaningful default value for all elements.

2. With Array Values

We can initialize a vector with an array of values. The array size determines vector size.

int arr[] = {10, 20, 30}; 

vector<int> vec(arr, arr+3); // 10, 20, 30 inside vec

The arr+3 points to end, indicating total elements count.
Let‘s store website page load timings:

double timings[] = {12.5, 10.7, 50.5, 15.3};

vector<double> pageTimings(timings, timings+4);

Now pageTimings vector will store load timings for analysis.

When to use?

When you have a prepopulated array, and want to initialize vector from it.

3. With fill() function

The fill() function can set all vector elements to a specified value in one go.

vector<int> visits(100); 

fill(visits.begin(), visits.end(), 0);   

This makes a size 100 vector, setting all values as 0.

Let‘s count visitors over 7 days of a week:

vector<int> weeklyVisits(7);

fill(weeklyVisits.begin(), weeklyVisits.end(), 0); 

Now we can increment individual days to track visits.

When to use?

When the vector size is fixed, fill() allows setting all to a default uniform value easily.

4. With resize() method

We can initialize an empty vector and resize it as needed.

vector<string> bands;

bands.resize(5); //allocates 5 strings 

Optionally we can also set a fill value:

bands.resize(8, "NA"); //8 strings set as "NA" 

This allows dynamic resizing later as well. Let‘s use it to get user phone contacts:

vector<string> userContacts;  

cout << "How many contacts? ";
int n;
cin >> n;

userContacts.resize(n);

We get contacts count as input, resize accordingly before collecting contacts.

When to use?

When initial vector size is unclear, resize allows initializing once actual count is known.

5. With push_back() method

We can start empty, use push_back to add elements one by one.

vector<int> nums; 

nums.push_back(10); 
nums.push_back(30);
nums.push_back(20);

Nums will contain 10, 30 and 20.

Let‘s collect student‘s marks:

vector<double> studentMarks;   

double mark;
for(int i=0; i<5; i++) {
  cin >> mark;
  studentMarks.push_back(mark); 
} 

We add each mark as user enters it.

When to use?

When elements count is not known upfront. Flexible to add dynamically.

6. Empty with no args

We can initialize an empty vector by without args like:

vector<char> chars; //empty  

Simpler initialize option when actual population happens later by other means.

Let‘s start collecting survey responses:

vector<string> surveyResponses; //no size known yet

//collect responses later  

When to use?

When you just want to declare a vector reference early on, before determining size.

7. Initializer List Syntax

Modern C++ offers initializer list syntax to initialize as:

vector<int> nums {10, 20, 30, 5}; 

This feels concise compared to other approaches.

Let‘s store website page urls to scrape:

vector<string> scrapePages {"page1.html", "/page2.html", 
                            "http://www.site.com/page3.html"};

When to use?

Useful when initializing known set of elements upfront.

So in summary –

• Consider expected element count upfront
• Initialize enough capacity and size
• Use appropriate constructors or methods
• Set meaningful defaults if possible
• Leave expandability for future growth

Choosing the right approach as per intended vector usage can improve quality and performance.