Initialization and assignment in C++

Initialization is one of the most fundamental concepts in C++ programming, yet it’s also one of the most nuanced. Understanding the different types of initialization and when to use each can significantly improve your code’s safety, performance, and readability. In this post, we’ll explore the various initialization techniques available in modern C++.

What is Initialization?

Initialization is the process of giving a variable an initial value at the time of its creation. This is different from assignment, which changes the value of an already-existing variable. Proper initialization helps prevent undefined behavior and makes your code more predictable.

---

Types of Initialization

1. Default Initialization

Use when:

• You need to declare a variable but will assign a value later
• Working with objects that have meaningful default states
• Performance is critical and you know you’ll assign before use

// Good uses of default initialization
std::string filename;  // Will be assigned from user input
std::vector<int> data; // Will be populated later
int result;            
result=0; // Will be calculated and assigned immediately
 
// Avoid for built-in types unless absolutely necessary
int x;  // Dangerous - contains garbage value

Avoid when:

• Working with built-in types (int, float, etc.) unless you’re certain you’ll assign before use
• You can initialize with a meaningful value immediately

2. Value Initialization

Use when:

• You want to ensure a variable starts with a “zero” or default value
• Working with built-in types and need a safe initial state
• Creating containers that will be populated later

// Perfect for ensuring clean initial state
int counter{};           // Explicit zero initialization
double sum{};          // Clear that this will accumulate
std::vector<int> data{};  // Empty container, ready to be filled
bool isValid{false};      // Clear initial state

Best for:

• Counters and accumulators
• Flags and boolean states
• Containers that will be populated
• Any variable where “zero” is a meaningful initial state

3. Direct Initialization

Use when:

• You have constructor arguments to pass
• Working with objects that don’t support copy initialization
• You want to be explicit about constructor calls
• Performance matters (avoids potential copy operations)

// When you have constructor arguments
int i(0);
std::vector<int> vec(10, 5);        // 10 elements, each = 5
std::unique_ptr<int> ptr(new int(42)); // Raw pointer constructor
std::string s(5, 'A');              // 5 'A' characters
 
// For non-copyable types
std::ofstream file("data.txt");     // File constructor
std::mutex mtx;                     // Default constructor

Best for:

• Container initialization with size and value
• File and stream objects
• Smart pointers
• Objects with explicit constructors

4. Copy Initialization

Use when:

• You want intuitive assignment-like syntax
• Working with simple types and literals
• Code readability is more important than micro-optimizations
• You’re not sure about the type (works with auto)

// Natural, readable syntax
int age = 25;
std::string name = "Alice";
auto values = std::vector<int>{1, 2, 3};
 
// When working with literals
double pi = 3.14159;
char grade = 'A';

Best for:

• Simple assignments from literals
• When readability is paramount
• Working with auto type deduction
• Legacy code compatibility

5. List Initialization (Uniform Initialization)

Use when:

• You want the safest and most consistent initialization
• Working with aggregates (arrays, structs)
• You want to prevent narrowing conversions
• You’re writing modern C++ (C++11 and later)

// Most versatile and safe
int count{42};
std::string message{"Hello, World!"};
std::vector<int> numbers{1, 2, 3, 4, 5};
 
// Aggregate initialization
struct Point { double x, y; };
Point origin{0.0, 0.0};
 
// Array initialization
int scores[]{95, 87, 92, 78, 88};

Best for:

• Modern C++ development (preferred default)
• Aggregate types
• When you want compiler protection against narrowing
• Consistent initialization across all types
• Preventing the “most vexing parse”

---

Decision Matrix

Scenario	Recommended Type	Why
Built-in types with known value	List initialization int x{42}	Safe, prevents narrowing
Built-in types, zero initial	Value initialization int x{}	Clear intent, safe
Container with size/value	Direct initialization vector<int> v(10, 5)	Most efficient
Simple literals	Copy initialization int x = 42	Readable, familiar
Aggregates (structs/arrays)	List initialization Point p{1, 2}	Only option, clear
Auto type deduction	Copy initialization auto x = 42	Most readable
Modern C++ (default choice)	List initialization int x{42}	Safest, most consistent

---

Modern C++ Best Practices

Prefer Uniform Initialization (Braces)

Modern C++ guidelines recommend using brace initialization as the default choice:

// Preferred modern style
int count{0};
double rate{3.14};
std::vector<std::string> names{"Alice", "Bob", "Charlie"};
 
// Instead of
int count = 0;
double rate = 3.14;
std::vector<std::string> names = {"Alice", "Bob", "Charlie"};

Initialize Variables at Declaration

Always initialize variables when you declare them:

// Good
int counter{0};
bool isReady{false};
std::string message{"Starting process..."};
 
// Avoid
int counter;        // Undefined value
bool isReady;       // Undefined value
std::string message; // This is actually okay for std::string, but inconsistent

Use Auto with Initialization

The auto keyword works well with proper initialization:

auto count = 42;           // int
auto rate = 3.14;          // double
auto name = std::string{"John"}; // std::string
auto values = std::vector<int>{1, 2, 3}; // std::vector<int>

In-Class Member Initializers (C++11)

You can initialize member variables directly in the class definition:

class Player {
private:
    int health{100};        // In-class initializer
    std::string name{"Unknown"};
    bool isActive{true};
 
public:
    Player() = default;     // Uses in-class initializers
    Player(const std::string& playerName) : name{playerName} {}
};

Constructor Initializer Lists

Use initializer lists in constructors for efficient initialization:

class Rectangle {
private:
    double width;
    double height;
 
public:
    // Preferred: initializer list
    Rectangle(double w, double h) : width{w}, height{h} {}
 
    // Less efficient: assignment in body
    Rectangle(double w, double h) {
        width = w;   // Assignment, not initialization
        height = h;  // Assignment, not initialization
    }
};

Aggregate Initialization

Aggregates (arrays, structs with no user-defined constructors) can be initialized with brace-enclosed lists:

struct Point {
    double x;
    double y;
};
 
// Aggregate initialization
Point p1{3.0, 4.0};
Point p2{.x = 1.0, .y = 2.0}; // Designated initializers (C++20)
 
int array[]{1, 2, 3, 4, 5};

---

Typical Initialization Errors

1. Uninitialized Variables (Undefined Behavior)

// ❌ DANGEROUS - Undefined behavior
int x;
std::cout << x;  // Garbage value, undefined behavior!
 
// ✅ CORRECT - Always initialize
int x{0};
int y = 42;
int z{};  // Zero-initialized
static int x;  // This is actually safe (zero-initialized)

2. The Most Vexing Parse

// ❌ WRONG - This declares a function, not a variable!
std::vector<int> vec();
 
// ✅ CORRECT - Use braces or parentheses with arguments
std::vector<int> vec{};     // Empty vector
std::vector<int> vec(0);    // Vector with 0 elements
auto vec = std::vector<int>{}; // Copy initialization

3. Narrowing Conversions

// ❌ DANGEROUS - Silent data loss
double pi = 3.14;
int truncated = pi;  // Loses decimal part silently
 
// ✅ CORRECT - Use braces to prevent narrowing
int truncated{pi};  // Compiler error - prevents data loss
int explicit_cast = static_cast<int>(pi);  // Explicit conversion

4. Initialization vs Assignment Confusion

class MyClass {
    std::string name;
    int value;
public:
    // ❌ INEFFICIENT - Assignment, not initialization
    MyClass(const std::string& n, int v) {
        name = n;    // Assignment after default construction
        value = v;   // Assignment after default construction
    }
 
    // ✅ EFFICIENT - Proper initialization
    MyClass(const std::string& n, int v) : name{n}, value{v} {}
};

5. Array Initialization Mistakes

// ❌ WRONG - Size mismatch
int arr[3] = {1, 2, 3, 4};  // Compiler error
 
// ❌ WRONG - Partial initialization without zeros
int arr[5] = {1, 2};  // Last 3 elements are 0, but not obvious
 
// ✅ CORRECT - Clear initialization
int arr[5] = {1, 2, 0, 0, 0};  // Explicit
int arr[5]{};  // All zeros
int arr[]{1, 2, 3};  // Size deduced

6. String Initialization Confusion

// ❌ CONFUSING - What does this create?
std::string s(5);  // String with 5 null characters
 
// ✅ CLEAR - Be explicit about intent
std::string s(5, 'A');     // "AAAAA"
std::string s{"Hello"};    // "Hello"
std::string s(5, '\0');    // 5 null characters (if that's what you want)

7. Const Variable Initialization

// ❌ WRONG - Const variables must be initialized
const int x;  // Compiler error
 
// ✅ CORRECT - Initialize const variables
const int x{42};
const int y = 42;
const auto z = calculateValue();

Key Takeaways

Understanding initialization in C++ is crucial for writing safe, efficient, and maintainable code. Here are the key takeaways:

1. Always initialize variables at declaration to avoid undefined behavior
2. Prefer list and value initialization for its consistency and safety features
3. Use initializer lists in constructors for efficiency
4. Leverage in-class member initializers for default values
5. Be aware of the differences between initialization and assignment
6. Use auto with proper initialization for type deduction

Remember that good initialization practices are not just about correctness—they’re about writing code that clearly expresses your intent and is easy for others (and future you) to understand and maintain. You can refer to the following section for examples of good practices when initialize variables in C.

---

Reference

Alex. (2025, March 6). 1.4 — Variable assignment and initialization. https://www.learncpp.com/cpp-tutorial/variable-assignment-and-initialization/