How to Initialize std::vector with Hardcoded Values in C++

By the end of this page, you will understand the simplest ways to initialize a std::vector with fixed values in C++, when to use each approach, and how modern C++ makes vector initialization much cleaner than repeated push_back calls.

std::vector is a dynamic array in C++. Unlike a built-in array, it can grow and shrink at runtime. Because of that flexibility, C++ provides several ways to create and fill a vector.

When you already know the values you want to store, the most readable approach in modern C++ is usually list initialization using braces:

std::vector<int> ints = {10, 20, 30};

or simply:

std::vector<int> ints{10, 20, 30};

This works because std::vector supports initializer lists. An initializer list lets you pass a fixed set of values directly when constructing the vector.

This matters in real programming because:

• it makes code shorter and easier to read
• it reduces repetitive push_back calls
• it clearly shows the vector's initial contents
• it avoids accidental mistakes from forgetting an element or adding them in multiple places

Before C++11, developers often had to use less elegant approaches, such as creating an array first and copying its contents into the vector. In modern C++, brace initialization is the standard beginner-friendly solution.

Think of a std::vector like a resizable shopping basket.

• A built-in array is like a fixed egg carton: its size is decided immediately.
• A std::vector is like a basket that can hold more items later.

If you already know the starting items, brace initialization is like filling the basket all at once:

std::vector<int> ints{10, 20, 30};

Using repeated push_back is like putting items in one by one after picking up the basket. That works, but it is more verbose when the items are already known.

The most common ways to initialize a std::vector are below.

1. Initialize with hardcoded values using braces

#include <vector>

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

This is the cleanest modern C++ approach.

You may also see:

std::vector<int> nums = {10, 20, 30};

Both forms are valid.

2. Initialize with repeated copies of one value

std::vector<int> nums(3, 100);

This creates:

{100, 100, 100}

Be careful: this is different from brace initialization.

3. Construct from an array

 a[] = {, , };
;

Consider this example:

#include <vector>

int main() {
    std::vector<int> ints{10, 20, 30};
    return 0;
}

Here is what happens step by step:

1. The program reaches std::vector<int> ints{10, 20, 30};
2. A vector named ints is created.
3. The type inside the vector is int.
4. The brace list {10, 20, 30} is passed to the vector constructor.
5. The vector stores three elements in order:
   • ints[0] becomes 10
   • ints[1] becomes 20
   • ints[2] becomes 30
6. The vector size becomes 3.

You can verify that with this traceable example:

Hardcoded vector initialization is common when a program starts with a known set of values.

Common examples

• Menu choices

  std::vector<std::string> options{"start", "settings", "quit"};
  

• Allowed status codes

  std::vector<int> validCodes{200, 201, 204};
  

• Default configuration values

  std::vector<double> thresholds{0.25, 0.5, 0.75};
  

• Test data in unit tests

  std::vector<int> input{1, 2, 3, 4, 5};
  

• Coordinate or sample data in small programs

  std::vector<int> points{10, , , };
  

In real projects, developers often use vector initialization in a few common patterns.

1. Default data setup

A vector may be created with default values near the point of declaration:

std::vector<std::string> roles{"admin", "editor", "viewer"};

This keeps the code readable and avoids scattered push_back calls.

2. Test fixtures and sample input

In tests, short inline vectors are very common:

std::vector<int> expected{2, 4, 6};

This makes expected values easy to compare.

3. Guarded setup before processing

Developers may initialize a vector and then validate it:

std::vector<int> ports{80, 443, 8080};
if (ports.empty()) {
    return;
}

4. Copying from existing ranges

When values come from arrays or other containers, range constructors are often used:

int raw[] = {, , };
;

Here are common mistakes beginners make when initializing std::vector.

1. Confusing parentheses with braces

These two do different things:

std::vector<int> a(3, 10);
std::vector<int> b{3, 10};

a becomes:

{10, 10, 10}

b becomes:

{3, 10}

How to avoid it

• Use braces when listing explicit elements.
• Use parentheses when calling a constructor with size and value.

2. Forgetting to include the header

Broken code:

std::vector<int> nums{1, 2, 3};

This will fail if you forget:

Here is a comparison of common ways to create a std::vector.

#include <vector>

Initialize with hardcoded values

std::vector<int> v{10, 20, 30};
std::vector<int> v = {10, 20, 30};

Initialize with repeated value

std::vector<int> v(3, 5); // {5, 5, 5}

Copy from an array

int a[] = {10, 20, 30};
std::vector<int> v(std::begin(a), std::end(a));

Add items later

std::vector<int> v;
v.push_back(10);
v.push_back(20);

Can I initialize a std::vector like an array in C++?

Yes. In modern C++, you can use brace initialization:

std::vector<int> v{10, 20, 30};

Is std::vector<int> v = {1, 2, 3}; valid?

Yes. This is valid C++ and is a common way to initialize a vector with fixed values.

What is the difference between vector<int>(3, 10) and vector<int>{3, 10}?

vector<int>(3, 10) creates three elements, each equal to 10. vector<int>{3, 10} creates two elements: 3 and 10.

Should I use push_back or brace initialization?

Use brace initialization when the values are already known. Use push_back when values are produced later by logic, loops, input, or function results.

Does this require C++11?

Yes, initializer-list vector syntax is part of modern C++ and is available from C++11 onward.

Can I initialize a vector from an existing array?

• std::array - A fixed-size container that also supports clean brace initialization.
• C++ initializer lists - The language feature that makes brace-based vector initialization possible.
• push_back - Useful when elements are added one at a time during execution.
• Range constructors - Used to build vectors from arrays or other containers.
• Built-in arrays - Helpful for understanding how vector initialization compares to traditional arrays.
• std::list - Another container type, useful for comparing container choices.
• C++11 features - Important because initializer-list support became standard in C++11.