Why is reading a default-initialized local dangerous?

Automatic storage scalars can hold indeterminate values—reading them is undefined behavior. Assign first or use `T{}`.

Default vs value initialization?

`new T` vs `new T()` differ; class types call default ctors but subobjects may still need care. See the standard’s rules per context.

Member with no default and not in ctor init list?

Default init rules apply; risk of partially uninitialized objects.

Static storage first gets zero initialization, then possibly dynamic init—different from stack locals.

C++ Default Initialization | Uninitialized Locals and Undefined Behavior

2026년 3월 12일 · 14분 읽기 · 수정 2026년 3월 30일 Beginner Tutorial

이 글의 핵심

Default initialization means no initializer: local ints can hold garbage. Globals are different. Use value initialization or member defaults to stay safe.

What is default initialization?

Declaring a variable without an initializer applies default initialization. For local scalars, the value can be indeterminate—reading it is undefined behavior. Prefer value initialization (T{}) or explicit assignment.

int x;        // default-initialized local: garbage
int y = 10;   // explicit

Scalars (automatic storage)

void func() {
    int x;       // indeterminate
    double d;    // indeterminate
    int* ptr;    // indeterminate
    
    x = 10;
    d = 3.14;
    ptr = nullptr;
}

Undefined behavior examples

Using x before assignment in conditions, arithmetic, or I/O is UB.

Pitfalls

Missing sum initialization

// ❌
int sum;
for (int i = 0; i < 10; i++) {
    sum += i;  // UB
}

// ✅
int sum = 0;

Uninitialized pointers

int* ptr = nullptr;

Class members

class Good {
    int value = 0;
public:
    Good() = default;
};

Conditional assignment

Initialize before the branch or set a default first.

`memset` anti-pattern

Do not memset non-trivial C++ objects to zero—use value initialization, ctors, or member defaults.

FAQ

Q1: What is default initialization?
A: No initializer—dangerous for local scalars.

Q2: Globals?
A: Static storage is zero-initialized first, then dynamic init.

Q3: Fix?
A: Always initialize—=, {}, or member defaults.

Related: Value initialization, Zero initialization, Undefined behavior.

C++ Value initialization
C++ Zero initialization
C++ Undefined behavior

Keywords

C++, default initialization, undefined behavior, uninitialized variable.