C++ flashcards, generated for you.

Declaration tells the compiler about a variable's type and name (e.g., `extern int x;`). Definition allocates storage and optionally initializes it (e.g., `int x = 5;`). A definition is also a declaration, but not vice versa.

`nullptr` is a null pointer constant with type `std::nullptr_t`. It's type-safe and prevents accidental implicit conversions to integers. `NULL` is often just `0`, which can cause overload ambiguity.

Both initialize `str` to "hello". The first uses copy-initialization; the second uses brace-initialization (uniform initialization). Brace-initialization prevents narrowing conversions and is generally preferred in modern C++.

References are non-null aliases to existing objects (cannot be reassigned or reseated), require initialization at declaration, and use dot notation. Pointers are variables storing addresses, can be null, can be reassigned, and use arrow (`->`) or dereference (`*`) notation.

`const int*` (or `int const*`): pointer to a const int—the pointed-to value cannot change. `int* const`: const pointer to an int—the pointer address cannot change, but the value can.

Resource Acquisition Is Initialization: resources (memory, files, locks) are tied to object lifetime—acquired in constructor, released in destructor. This ensures automatic cleanup even if exceptions occur, preventing leaks and resource exhaustion.

Pass-by-value: copies the object (overhead, modifications don't affect original). Pass-by-reference: aliases the object (fast, modifications affect original, caller must pass lvalue). Pass-by-const-reference: fast, read-only, accepts both lvalues and rvalues—preferred for large objects.

`resize(n)` changes the logical size and adds/removes elements (calling constructors/destructors as needed). `reserve(n)` only preallocates capacity without changing size. Use `reserve()` to avoid reallocations during repeated `push_back()`.

Move semantics transfers ownership of resources (like heap memory) from a temporary object to another, avoiding deep copies. A move constructor is invoked when binding to an rvalue (temporary), detected via `&&`. Use `std::move()` to cast lvalues to rvalues.

The parser interprets `MyClass obj(SomeType());` as a function declaration, not object construction. Avoid it using brace-initialization: `MyClass obj{SomeType()};` or explicit parentheses: `MyClass obj((SomeType()));`