C++ flashcards, generated for you.

`int x;` creates an uninitialized variable with garbage value. `int x = 0;` explicitly initializes it to 0. Use `int x{};` (uniform initialization) to safely default-initialize.

`const int* p`: pointer to a constant int (data is const, pointer can move). `int* const p`: constant pointer to int (pointer is const, data can change).

By value: copy made (slow for large objects). By reference `&`: alias to original (allows modification). By const reference `const&`: alias to original (read-only, efficient).

Function returns undefined/garbage value (for non-void types). Compiler may warn but won't error. Always explicitly return or use `void`.

`v(5)` creates vector of 5 default-initialized ints (size 5). `v{5}` creates vector with single element 5 (size 1). Uniform initialization `{}` can be confusing—prefer `v.resize(5)` for clarity.

Code with undefined behavior has no guaranteed outcome—may crash, appear to work, or behave unpredictably. Common causes: null pointer dereference, out-of-bounds access, use-after-free. Compiler makes no promises.

`delete p` deallocates single object. `delete[] p` deallocates array. Using wrong form causes heap corruption. Use `std::unique_ptr` or `std::vector` to avoid manual management.

`operator[]` does not bounds-check (undefined behavior if out of range). Use `.at()` instead, which throws `std::out_of_range` exception. Always use `.at()` for safety-critical code.

Resource Acquisition Is Initialization: resources (memory, files, locks) are acquired in constructor and released in destructor. Ensures cleanup even if exceptions occur. Use smart pointers and container classes.

`std::move()` casts an lvalue to an rvalue, enabling move semantics (steal resources instead of copy). Use when passing temporary objects or explicitly transferring ownership: `vec.push_back(std::move(obj));`