C++ Advanced Fundamentals

ref: https://github.com/0voice/cpp-learning-2025

I. STL (Standard Template Library)

The STL (Standard Template Library) is a core C++ library that encapsulates common data structures (containers) and algorithms, following the “generic programming” paradigm. It is a high-frequency topic in technical interviews. Its core components are: Containers, Iterators, and Algorithms.

1. Common Containers

Containers are “containers” for storing data. Based on their underlying implementation, they are divided into Sequence Containers (ordered storage) and Associative Containers (storage by key-value pairs/unique values). Core container comparison:

Container Type	Specific Container	Underlying Implementation	Core Characteristics	Typical Use Cases
Sequence Containers	vector	Dynamic Array	Random access O(1), Tail insertion/deletion O(1), Middle insertion/deletion O(n), Contiguous storage	Frequent access, tail-end insertions/deletions (most common)
	list	Doubly Linked List	Random access O(n), Insertion/deletion at any position O(1), Non-contiguous storage, No capacity concept	Frequent insertions/deletions in the middle
	deque	Segmented Dynamic Array	Random access O(1), Head/tail insertion/deletion O(1), Middle insertion/deletion O(n), Supports expansion without moving all elements	Frequent insertions/deletions at both ends, occasional random access
Associative Containers (Ordered)	map	Red-Black Tree	Keys ordered (ascending by default), Keys unique, Insert/Delete/Find O(log n), Key-value pair storage	Need ordered key-value pairs, deduplication, frequent lookup
	set	Red-Black Tree	Elements ordered (ascending by default), Elements unique, Insert/Delete/Find O(log n), Stores values only	Need ordered sets, deduplication
	multimap	Red-Black Tree	Keys ordered, Keys can duplicate, Insert/Delete/Find O(log n)	Ordered key-value pairs, allowing duplicate keys
	multiset	Red-Black Tree	Elements ordered, Elements can duplicate, Insert/Delete/Find O(log n)	Ordered collections, allowing duplicate elements
Associative Containers (Unordered)	unordered_map	Hash Table	Keys unordered, Keys unique, Insert/Delete/Find avg O(1), worst O(n), Key-value pair storage	High-frequency lookup, order not required (recommended)
	unordered_set	Hash Table	Elements unordered, Elements unique, Insert/Delete/Find avg O(1), worst O(n), Stores values only	High-frequency deduplication, order not required (recommended)
	unordered_multimap	Hash Table	Keys unordered, Keys can duplicate, avg O(1)	Unordered key-value pairs, allowing duplicate keys
	unordered_multiset	Hash Table	Elements unordered, Elements can duplicate, avg O(1)	Unordered collections, allowing duplicate elements

Core Container Usage Examples

(1) vector (Dynamic Array, Most Common)

#include <vector>
#include <algorithm> // For sort, etc.
#include <iostream>
using namespace std;

int main() {
  // Initialization
  vector<int> vec1; // Empty vector
  vector<int> vec2(5, 0); // 5 elements, all 0 → [0,0,0,0,0]
  vector<int> vec3 = {1, 2, 3, 4, 5}; // List initialization (C++11+)

  // Access/Modification
  vec3.push_back(6); // Insert at tail → [1,2,3,4,5,6]
  vec3.pop_back(); // Delete from tail → [1,2,3,4,5]
  vec3[2] = 10; // Random access modification → [1,2,10,4,5]
  cout << vec3.at(3); // Safe access (throws exception if out-of-bounds) → 4

  // Iteration Methods
  // 1. Index-based loop
  for (size_t i = 0; i < vec3.size(); ++i) {
    cout << vec3[i] << " ";
  }

  // 2. Iterator loop
  for (vector<int>::iterator it = vec3.begin(); it != vec3.end(); ++it) {
    cout << *it << " "; // Dereference iterator
  }

  // 3. Range-based for loop (C++11+)
  for (int num : vec3) {
    cout << num << " ";
  }

  // Common Operations
  sort(vec3.begin(), vec3.end()); // Sorting (requires #include <algorithm>)
  bool isEmpty = vec3.empty(); // Check if empty
  vec3.clear(); // Clear all elements (capacity remains)
  vec3.reserve(10); // Pre-allocate capacity (avoid frequent reallocations)
  return 0;
}

(2) unordered_map (Hash Table Key-Value Pairs, High-Frequency Use)

#include <unordered_map>
#include <string>
#include <iostream>
using namespace std;

int main() {
  unordered_map<string, int> scoreMap;

  // Insert key-value pairs
  scoreMap["Math"] = 90;
  scoreMap.insert({"English", 85}); // Insert using initializer list
  scoreMap.emplace("Chinese", 95); // In-place construction (more efficient)

  // Lookup (Core Operation)
  auto it = scoreMap.find("Math");
  if (it != scoreMap.end()) {
    cout << "Math score: " << it->second << endl; // Access value → 90
  }

  // Iteration
  for (const auto& pair : scoreMap) {
    cout << pair.first << ": " << pair.second << endl; // first=key, second=value
  }

  // Modification/Deletion
  scoreMap["English"] = 88; // Modify value
  scoreMap.erase("Chinese"); // Delete by key

  cout << scoreMap.size(); // Number of elements → 2
  return 0;
}

Key Points for unordered_map:

• Average case time complexity for insertion, deletion, and lookup is O(1), but can degrade to O(n) with poor hash functions or high collisions.
• Iterators are invalidated only when rehashing occurs (due to load factor threshold being exceeded), not on individual insertions/deletions (except for the element being erased).
• Use reserve() to pre-allocate buckets if the approximate number of elements is known, improving performance.

2. Iterators

Iterators are “the bridge between containers and algorithms.” They are essentially objects that encapsulate pointers, providing a uniform way to traverse containers (abstracting away underlying differences).

(1) Iterator Categories

Iterator Category	Capabilities	Supported Containers
Input Iterator	Read-only, forward traversal (only ++)	All containers
Output Iterator	Write-only, forward traversal (only ++)	All containers
Forward Iterator	Read/write, forward traversal (++)	forward_list, unordered_*
Bidirectional Iterator	Read/write, bidirectional traversal (++/--)	list, map, set
Random Access Iterator	Read/write, random access ([], +, -)	vector, deque, arrays

(2) Iterator Usage Conventions

• A container’s begin() returns an iterator to the first element, end() returns an iterator to one past the last element (the “past-the-end” iterator, must not be dereferenced).
• Constant iterators (const_iterator): Can only read elements, not modify (for const containers or read-only scenarios).
• C++11+ added cbegin()/cend() (return constant iterators), rbegin()/rend() (reverse iterators, traverse from end to beginning).

(3) Iterator Invalidation (High-Frequency Interview Topic)

Iterator invalidation occurs when the memory location an iterator points to becomes invalid (e.g., element deleted, container reallocated). Continuing to use an invalid iterator leads to crashes or logic errors. Core invalidation scenarios:

Container	Invalidation Scenarios
vector	1. Insertion causing reallocation (all iterators invalidated); 2. Insertion/deletion in the middle (iterators after the point become invalid); 3. After clear(), all iterators become invalid.
list	1. Only iterators to the erased element become invalid, others remain valid; 2. Insertion does not affect any iterators.
unordered_*	1. Insertion causing rehashing (load factor exceeds threshold) invalidates all iterators; 2. Deletion invalidates only the iterator to the erased element.
map/set	1. Erasing an element invalidates its iterator; other iterators remain valid; 2. Insertion does not affect any iterators.

Mitigation Strategies:

• After potential invalidation, reacquire valid iterators (e.g., don’t reuse old iterators after a vector insertion).
• When erasing elements, use the return value to update the iterator (e.g., list.erase(it) returns an iterator to the next valid element):

  // Correct way to erase elements in a list (avoiding iterator invalidation)
  list<int> lst = {1,2,3,4,5};
  for (auto it = lst.begin(); it != lst.end(); ) {
    if (*it % 2 == 0) {
      it = lst.erase(it); // erase returns the next valid iterator, don't increment
    } else {
      ++it;
    }
  }

3. Common Algorithms

STL algorithms encapsulate common operations (sorting, searching, counting, etc.), defined in the <algorithm> header. Most operate on containers via iterators and support custom logic (via lambdas or function objects).

Core Algorithm Examples

Function	Purpose	Example Code
sort()	Sort range	sort(vec.begin(), vec.end()); (ascending default); sort(vec.begin(), vec.end(), greater<int>()); (descending)
find()	Find value	auto it = find(vec.begin(), vec.end(), 3); (returns iterator to found element, else end())
count()	Count occurrences	int cnt = count(vec.begin(), vec.end(), 2);
for_each()	Apply function to each element	for_each(vec.begin(), vec.end(), [](int num){ cout << num << " "; });
find_if()	Find element satisfying condition	auto it = find_if(vec.begin(), vec.end(), [](int num){ return num > 5; });
unique()	Remove consecutive duplicates	vec.erase(unique(vec.begin(), vec.end()), vec.end()); (typically requires range to be sorted first)
reverse()	Reverse range	reverse(vec.begin(), vec.end());
accumulate()	Accumulate values	int sum = accumulate(vec.begin(), vec.end(), 0); (requires <numeric>)

Example: Combined Algorithm and Lambda Usage

#include <vector>
#include <algorithm>
#include <numeric>
#include <iostream>
using namespace std;

int main() {
  vector<int> vec = {3,1,4,1,5,9,2,6};

  // 1. Sort (descending)
  sort(vec.begin(), vec.end(), [](int a, int b){ return a > b; });
  // Result: [9,6,5,4,3,2,1,1]

  // 2. Remove duplicates (sort first, then unique)
  vec.erase(unique(vec.begin(), vec.end()), vec.end());
  // Result: [9,6,5,4,3,2,1]

  // 3. Output using for_each + lambda
  for_each(vec.begin(), vec.end(), [](int num){
    cout << num << " "; // Outputs: 9 6 5 4 3 2 1
  });

  // 4. Count elements > 3
  int cnt = count_if(vec.begin(), vec.end(), [](int num){ return num > 3; });
  cout << "\nCount > 3: " << cnt; // Output: 4

  // 5. Sum all elements
  int sum = accumulate(vec.begin(), vec.end(), 0);
  cout << "\nSum: " << sum; // Output: 30

  return 0;
}

4. Lambdas with STL

Lambdas (anonymous functions) are a core C++11+ feature, allowing in-place function definition without separate function declarations. They work perfectly with STL algorithms for custom logic.

Lambda Syntax Recap

[capture-list](parameters) -> return-type { body }
// Simplified: Return type can often be omitted (deduced), empty parameter list can be `()` or omitted entirely.

Core Capture List Usages

Capture	Meaning
[]	Capture nothing
[=]	Capture all by value (read-only copies inside lambda)
[&]	Capture all by reference (modifiable references inside lambda)
[x]	Capture x by value only
[&y]	Capture y by reference only
[=, &z]	Capture all by value except z, which is captured by reference
[&, x]	Capture all by reference except x, captured by value
[this]	Capture the current object this pointer (access members)

Note: Avoid default capture [=] or [&] in long-lived lambdas (e.g., stored in objects) to prevent dangling references or unintended copies. Prefer explicit capture lists.

Practical Example: Lambda with STL Sorting/Searching

#include <vector>
#include <algorithm>
#include <string>
#include <iostream>
using namespace std;

struct Student {
  string name;
  int age;
  int score;
};

int main() {
  vector<Student> students = {
    {"Tom", 18, 90},
    {"Jerry", 17, 85},
    {"Alice", 19, 95}
  };

  // 1. Sort by score descending (lambda as comparator)
  sort(students.begin(), students.end(), [](const Student& a, const Student& b){
    return a.score > b.score;
  });

  // 2. Find first student with age>=18 and score>=90
  auto it = find_if(students.begin(), students.end(), [](const Student& s){
    return s.age >= 18 && s.score >= 90;
  });
  if (it != students.end()) {
    cout << "Found: " << it->name << endl; // Outputs Alice
  }

  // 3. Modify scores using reference capture
  int addScore = 5;
  for_each(students.begin(), students.end(), [&addScore](Student& s){
    s.score += addScore; // Add 5 points to each student
  });

  return 0;
}

II. File I/O

File I/O enables “data persistence” (storing data to disk files or reading data from files). C++ offers two styles: C-style file I/O (<cstdio>) and C+±style file I/O (<fstream>). The C++ style is recommended (object-oriented, type-safe).

1. Core Headers and Classes

Header	Core Class	Purpose
<fstream>	ifstream	Input file stream (read from file)
	ofstream	Output file stream (write to file)
	fstream	Input/output file stream (both read and write)

2. File Opening Modes

Mode Flag	Meaning
ios::in	Read mode (default for ifstream)
ios::out	Write mode (default for ofstream). Creates file if doesn’t exist; truncates if exists.
ios::app	Append mode (append to end of file, do not truncate)
ios::binary	Binary mode (default is text mode) for binary files (images, videos, etc.)
ios::trunc	Truncate mode (truncate file if exists; default with ios::out)
ios::ate	Open and seek immediately to end of file (at end)
ios::nocreate	Open fails if file doesn’t exist (non-standard, use with caution)
ios::noreplace	Open fails if file exists (non-standard)

Combination Examples:

• ios::in | ios::out: Read/write mode (file must exist for reading).
• ios::out | ios::app: Append write mode.
• ios::in | ios::binary: Binary read mode.
• ios::out | ios::trunc | ios::binary: Binary write mode with truncation (default for ofstream with binary).

3. Text File Read/Write (Most Common)

Text files store character sequences (human-readable). Newline characters (\n) are automatically translated per platform during read/write.

(1) Writing Text Files

#include <fstream>
#include <string>
#include <iostream>
using namespace std;

int main() {
  // 1. Create output file stream object, open file (default: ios::out | ios::trunc)
  ofstream ofs("test.txt");
  if (!ofs.is_open()) { // Check if file opened successfully
    cerr << "Failed to open file for writing!" << endl;
    return -1;
  }

  // 2. Write data (<< operator, similar to cout)
  ofs << "Name: Tom" << endl;
  ofs << "Age: 18" << endl;
  ofs << "Score: 90" << endl;

  // 3. Close file (release resources)
  ofs.close(); // Can be omitted as destructor calls close, but good practice
  return 0;
}

(2) Reading Text Files

#include <fstream>
#include <string>
#include <iostream>
using namespace std;

int main() {
  // 1. Create input file stream object, open file (default: ios::in)
  ifstream ifs("test.txt");
  if (!ifs.is_open()) {
    cerr << "Failed to open file for reading!" << endl;
    return -1;
  }

  // 2. Read data (three common ways)
  // Method 1: Character by character (includes spaces, newlines)
  char ch;
  while (ifs.get(ch)) { // get() reads single char, including '\n'
    cout << ch;
  }
  // Reset stream state and seek to beginning for next example
  ifs.clear(); // Clear eof/fail bits
  ifs.seekg(0, ios::beg); // Go back to start

  // Method 2: Line by line (ignores newline delimiter, recommended)
  string line;
  while (getline(ifs, line)) { // getline() reads line into string
    cout << line << endl;
  }
  ifs.clear();
  ifs.seekg(0, ios::beg);

  // Method 3: Word by word (delimited by whitespace)
  string word;
  while (ifs >> word) { // >> reads whitespace-separated tokens
    cout << word << " ";
  }

  // 3. Close file
  ifs.close();
  return 0;
}

4. Binary File Read/Write

Binary files store byte sequences (not human-readable). Used for structs, images, videos, etc. Use ios::binary mode; no newline translation occurs.

(1) Writing Binary Files (Storing Structs)

#include <fstream>
#include <cstring> // For strlen, strcpy (if needed)
#include <iostream>
using namespace std;

struct Person {
  char name[20]; // Fixed-length (avoid dynamic memory issues with string in binary I/O)
  int age;
  double height;
};

int main() {
  // Open in binary write mode
  ofstream ofs("person.bin", ios::out | ios::binary);
  if (!ofs.is_open()) {
    cerr << "Failed to open binary file for writing!" << endl;
    return -1;
  }

  // Prepare data
  Person p = {"Tom", 18, 1.75};
  // Ensure name is null-terminated if using C-string functions later
  // For fixed array initialization above, it is.

  // Write: reinterpret_cast Person* to const char* (byte stream)
  ofs.write(reinterpret_cast<const char*>(&p), sizeof(Person));

  ofs.close();
  return 0;
}

(2) Reading Binary Files (Restoring Structs)

#include <fstream>
#include <iostream>
using namespace std;

struct Person {
  char name[20];
  int age;
  double height;
};

int main() {
  // Open in binary read mode
  ifstream ifs("person.bin", ios::in | ios::binary);
  if (!ifs.is_open()) {
    cerr << "Failed to open binary file for reading!" << endl;
    return -1;
  }

  Person p;
  // Read: read bytes into p
  ifs.read(reinterpret_cast<char*>(&p), sizeof(Person));

  // Check if read was successful (e.g., read exactly sizeof(Person) bytes)
  if (ifs.gcount() != sizeof(Person)) {
    cerr << "Error reading complete struct!" << endl;
    return -1;
  }

  // Output read data
  cout << "Name: " << p.name << endl;
  cout << "Age: " << p.age << endl;
  cout << "Height: " << p.height << endl;

  ifs.close();
  return 0;
}

Important Note on Binary I/O:

• Binary I/O of complex classes with pointers/virtual functions is non-portable and generally unsafe. Use for Plain Old Data (POD) types or implement serialization.
• Structure padding can differ across compilers/platforms. Use #pragma pack or compiler attributes for control if cross-platform compatibility is needed.

5. File Pointer Manipulation

File pointers (stream position indicators) point to the current read/write location. They can be adjusted using seekg() (for read/get pointer) and seekp() (for write/put pointer), along with tellg()/tellp() to get the current position.

Core Functions

Function	Purpose
seekg(pos, mode)	Move read pointer: pos is offset, mode is base (ios::beg, ios::cur, ios::end)
seekp(pos, mode)	Move write pointer (same usage)
tellg()	Return current read pointer position (bytes from start)
tellp()	Return current write pointer position

Example: Read Last 10 Bytes of a File

#include <fstream>
#include <iostream>
using namespace std;

int main() {
  ifstream ifs("test.txt", ios::in | ios::binary);
  if (!ifs.is_open()) {
    cerr << "Failed to open file!" << endl;
    return -1;
  }

  // 1. Move to end, get file size
  ifs.seekg(0, ios::end);
  streampos fileSize = ifs.tellg(); // Use streampos for size

  // 2. Move to 10 bytes before end (or start if file smaller)
  streamoff offset = (fileSize > 10) ? -10 : 0;
  ifs.seekg(offset, ios::end);

  // 3. Read remaining bytes
  char buf[11] = {0}; // Store up to 10 chars + null terminator
  ifs.read(buf, 10);
  // Check read count
  if (ifs.gcount() > 0) {
    buf[ifs.gcount()] = '\0'; // Null-terminate based on actual bytes read
    cout << "Last 10 bytes: " << buf << endl;
  }

  ifs.close();
  return 0;
}

6. Data Persistence Notes

• For text files, string objects work directly with << and >>. For binary files, avoid storing string directly (due to dynamic memory), prefer fixed-size character arrays or serialize separately.
• Always check file open success (is_open() or !ifs.fail()) to avoid errors from incorrect paths, permissions, etc.
• Explicitly close files (close()) or rely on RAII (destructor calls close). For long-lived streams, closing frees resources early.
• Binary file cross-platform compatibility: Differences in endianness (byte order) and struct alignment can cause issues. Consider platform-independent serialization libraries for complex data.

III. Exception Handling

Exception handling is C++'s mechanism for dealing with runtime errors (e.g., division by zero, file open failure, memory allocation failure). The core idea is to “separate error detection from error handling,” leading to more robust and readable code.

1. Core Syntax: try, catch, throw

try {
  // Code that might throw an exception (error detection)
  if (errorCondition) {
    throw exceptionValue; // Throw exception (can be any type: int, string, custom class, etc.)
  }
} catch (exceptionType1& e) {
  // Handle exceptionType1 (error handling)
} catch (exceptionType2& e) {
  // Handle exceptionType2
} catch (...) {
  // Catch-all handler for any unmatched exception
}

Basic Example: Division by Zero

#include <iostream>
#include <string>
using namespace std;

int divide(int a, int b) {
  if (b == 0) {
    // Throw an exception (here a string)
    throw string("Error: Divisor cannot be zero!");
  }
  return a / b;
}

int main() {
  int x = 10, y = 0;
  try {
    int result = divide(x, y); // May throw
    cout << "Result: " << result << endl;
  } catch (const string& err) { // Catch string exception
    cout << "Caught exception: " << err << endl;
  } catch (...) { // Catch-all
    cout << "Caught unknown exception!" << endl;
  }
  return 0;
}

2. Custom Exception Classes (Recommended)

The C++ standard library provides the base exception class exception (in <exception>). Custom exception classes should inherit from exception (or its derived classes like runtime_error) and override the what() method (returns a C-style string description) for uniform handling.

Example: Custom Exception Class

#include <iostream>
#include <exception>
#include <string>
using namespace std;

// Custom exception class: inherit from exception
class DivideException : public exception {
private:
  string msg;
public:
  // Constructor: takes description
  DivideException(const string& message) : msg(message) {}

  // Override what() (should be const noexcept in C++11+)
  const char* what() const noexcept override {
    return msg.c_str(); // Return C-style string
  }
};

int divide(int a, int b) {
  if (b == 0) {
    throw DivideException("Divisor cannot be zero!");
  }
  if (b < 0) {
    throw runtime_error("Divisor cannot be negative!"); // Standard library exception
  }
  return a / b;
}

int main() {
  try {
    divide(10, -2);
  } catch (const DivideException& e) { // Catch custom exception first
    cout << "Custom exception: " << e.what() << endl;
  } catch (const exception& e) { // Catch all standard exceptions (base class)
    cout << "Standard exception: " << e.what() << endl; // Output: Divisor cannot be negative!
  }
  return 0;
}

3. Standard Library Exception Classes

The C++ standard library provides predefined exception classes, all derived from exception. Common ones:

Exception Class	Header	Typical Cause
runtime_error	<stdexcept>	Runtime errors that could be avoided (e.g., invalid argument, range error)
logic_error	<stdexcept>	Logic errors detectable before runtime (e.g., invalid argument, domain error)
bad_alloc	<new>	Memory allocation failure (new)
bad_cast	<typeinfo>	Failed dynamic_cast
out_of_range	<stdexcept>	Out-of-range access (e.g., vector::at(), string::at())
invalid_argument	<stdexcept>	Invalid argument passed to a function
length_error	<stdexcept>	Exceeds maximum allowed size (e.g., string too long)

Example: Using Standard Exceptions

#include <vector>
#include <stdexcept>
#include <iostream>
using namespace std;

int main() {
  vector<int> vec = {1,2,3};
  try {
    int val = vec.at(5); // Out of bounds, throws out_of_range
    cout << val << endl;
  } catch (const out_of_range& e) {
    cout << "Exception: " << e.what() << endl; // e.g., "vector::_M_range_check"
  }

  try {
    int* p = new int[1000000000000]; // Likely allocation failure
  } catch (const bad_alloc& e) {
    cout << "Memory allocation failed: " << e.what() << endl;
  }
  return 0;
}

4. noexcept (C++11+)

noexcept is an exception specifier indicating that a function does not throw any exceptions. Its core purposes are:

• Allows compiler optimizations (reduces exception handling overhead).
• Clearly documents function’s exception behavior for callers.
• If a function declared noexcept does throw, std::terminate() is called (default behavior).

Syntax and Examples

// Declare function as noexcept (does not throw)
void func1() noexcept {
  cout << "func1 does not throw" << endl;
}

// Conditional noexcept: func2 is noexcept if T's destructor is noexcept
template <typename T>
void func2(T& obj) noexcept(noexcept(obj.~T())) {
  // ...
}

// Error example: noexcept but throws (program will terminate)
void func3() noexcept {
  throw runtime_error("error"); // std::terminate() called
}

// noexcept operator: checks if expression is noexcept
bool isNoexcept = noexcept(func1()); // true

Typical Use Cases

• Destructors (implicitly noexcept since C++11 unless specified otherwise).
• Move constructors and move assignment operators (often marked noexcept for efficiency in containers like vector).
• Simple functions with no possibility of throwing (e.g., getters, simple calculations).

5. Exception Handling Best Practices

• Use exceptions only for exceptional, recoverable runtime errors (e.g., file not found, network disconnect). For logic errors (e.g., precondition violations), consider assertions (assert) or error codes.
• Prefer custom exception classes (derived from std::exception) to categorize errors.
• Throw exceptions by value, catch by const reference (catch (const ExceptionType& e)).
• Avoid throwing exceptions from destructors (can lead to termination if stack unwinding is already in progress).
• Catch exceptions in order from most derived to most base (specific to general).
• Use RAII to ensure resource cleanup even when exceptions are thrown.
• Document exception guarantees (nothrow, basic, strong) for functions.

IV. Memory Management

Memory management is a core and challenging aspect of C++, and a high-frequency interview topic. The goal is to “allocate memory appropriately, release it timely, and avoid leaks, dangling pointers, etc.”

1. Memory Layout

A C++ program’s memory at runtime is divided into several segments, each with different lifetimes and management:

Segment	Stores	Lifetime	Managed By
Stack	Local variables, function parameters, return addresses	Automatic (destroyed when scope ends)	Compiler (push/pop)
Heap (Free Store)	Dynamically allocated memory (new/malloc)	Manual (delete/free) or smart pointers	Programmer
Static/Global Storage	Global variables, static variables (local/class)	Entire program duration	Compiler (allocated at program start, freed at exit)
Constant Data	String literals, const global/static data	Entire program duration	Compiler, read-only
Code (Text)	Executable machine instructions	Entire program duration	Compiler, read-only

Key Differences: Stack vs. Heap

Aspect	Stack	Heap
Allocation	Automatic, compiler-managed	Manual, programmer-controlled (new, malloc)
Deallocation	Automatic (scope exit)	Manual (delete, free) or smart pointers
Size Limit	Limited (OS-dependent, typically MBs)	Large (limited by OS/address space)
Speed	Very fast (stack pointer adjustment)	Slower (involves OS, potential fragmentation)
Fragmentation	None (LIFO order)	Possible (frequent alloc/dealloc)
Growth Direction	Usually downwards (high to low addresses)	Usually upwards (low to high)
Access Pattern	Contiguous, local variables	Random, pointers required

2. new/delete vs. malloc/free Differences (Interview Core)

new/delete are C++ operators; malloc/free are C library functions. Both allocate heap memory, but new/delete are integrated with C++'s object model.

Aspect	new / delete	malloc / free
Nature	C++ operators	C library functions
Type Safety	Returns correctly typed pointer (no cast needed)	Returns void*, requires cast
Construction/Destruction	new calls constructor; delete calls destructor	Only allocates/frees memory; no constructor/destructor calls
On Failure	Throws std::bad_alloc (default)	Returns nullptr
Array Allocation	new Type[size] and delete[]	malloc(size * sizeof(Type)) and free
Overridable	Yes (class/global operator new/delete)	No (only through library hooks)
Size Calculation	Compiler calculates for new[]	Manual byte calculation required

Comparison Examples

// 1. Basic type
int* p1 = new int(10); // Allocate and initialize to 10
int* p2 = (int*)malloc(sizeof(int));
*p2 = 10; // Manual initialization

delete p1; // Calls destructor (if any) and deallocates
free(p2);  // Only deallocates

// 2. Array
int* arr1 = new int[5]; // Allocates array of 5 ints
int* arr2 = (int*)malloc(5 * sizeof(int));

delete[] arr1; // Must use delete[] for arrays allocated with new[]
free(arr2);

// 3. Custom class object
class Person {
public:
  Person() { cout << "Person constructor" << endl; }
  ~Person() { cout << "Person destructor" << endl; }
  void greet() { cout << "Hello" << endl; }
};

Person* p3 = new Person; // Calls constructor
p3->greet();
delete p3; // Calls destructor

Person* p4 = (Person*)malloc(sizeof(Person)); // Only allocates raw memory
// p4->greet(); // Undefined behavior - object not constructed!
free(p4); // No destructor called (potential resource leak if Person had owned resources)

Key Point: Never mix new with free or malloc with delete. They use different memory management infrastructures.

3. Smart Pointers (unique_ptr, shared_ptr, weak_ptr)

Smart pointers are a core C++11+ feature that wrap raw pointers and follow RAII (Resource Acquisition Is Initialization). They automatically manage heap memory (deallocating when the smart pointer goes out of scope), preventing memory leaks and dangling pointers.

(1) unique_ptr (Exclusive Ownership)

• Core characteristic: At any time, only one unique_ptr owns a given heap object. Cannot be copied, only moved.
• Use case: Single-owner scenarios (e.g., a local dynamic object, a member that uniquely owns a resource).
• Key operations:
  • make_unique<T>(args...): Creates a unique_ptr (preferred, exception-safe).
  • std::move(p): Transfers ownership.
  • reset(): Releases the owned object (calls deleter) and can take a new pointer.
  • release(): Releases ownership (returns raw pointer, caller must manage).
  • get(): Returns raw pointer (use with caution).
• Custom deleters are supported (e.g., for arrays, FILE*).

Example

#include <memory>
#include <iostream>
using namespace std;

class Person {
public:
  Person(string n) : name(n) { cout << name << " created." << endl; }
  ~Person() { cout << name << " destroyed." << endl; }
  void greet() { cout << "Hello, I'm " << name << endl; }
private:
  string name;
};

int main() {
  // Create unique_ptr (recommended way)
  unique_ptr<Person> p1 = make_unique<Person>("Alice");
  p1->greet();

  // Cannot copy
  // unique_ptr<Person> p2 = p1; // Compile error

  // Transfer ownership (move)
  unique_ptr<Person> p2 = move(p1);
  if (!p1) { // p1 is now empty
    cout << "p1 no longer owns." << endl;
  }
  p2->greet();

  // Reset (deletes object)
  p2.reset(); // Calls Person destructor for "Alice"

  // Custom deleter example (for array allocated with new[])
  unique_ptr<int[]> arr(new int[5]); // Uses default deleter for arrays (delete[])
  arr[0] = 10;

  return 0;
} // arr's deleter (delete[]) called automatically

(2) shared_ptr (Shared Ownership)

• Core characteristic: Multiple shared_ptr instances can share ownership of the same object. Uses reference counting; object is deleted when the last shared_ptr is destroyed/reset.
• Use case: Shared resources (e.g., stored in containers, shared across threads).
• Key operations:
  • make_shared<T>(args...): Creates shared_ptr (preferred, often more efficient due to single allocation for object and control block).
  • use_count(): Returns reference count (for debugging, not for program logic).
  • reset(): Decrements reference count, releases ownership if last.
  • get(): Returns raw pointer.
• Custom deleters are also supported.

Example

#include <memory>
#include <iostream>
using namespace std;

class Resource {
public:
  Resource() { cout << "Resource acquired." << endl; }
  ~Resource() { cout << "Resource released." << endl; }
};

int main() {
  // Create shared_ptr (recommended way)
  shared_ptr<Resource> sp1 = make_shared<Resource>(); // ref count = 1
  cout << "sp1 use_count: " << sp1.use_count() << endl; // 1

  {
    shared_ptr<Resource> sp2 = sp1; // Copy increases ref count
    cout << "sp1 use_count: " << sp1.use_count() << endl; // 2
    cout << "sp2 use_count: " << sp2.use_count() << endl; // 2
  } // sp2 destroyed, ref count decrements to 1

  cout << "sp1 use_count: " << sp1.use_count() << endl; // 1

  sp1.reset(); // Explicitly release ownership, ref count -> 0, object destroyed
  cout << "sp1 use_count: " << sp1.use_count() << endl; // 0

  return 0;
}

(3) weak_ptr (Weak Reference)

• Problem: shared_ptr circular reference (two shared_ptrs point to each other, reference count never reaches zero -> memory leak).
• Core characteristic: A weak_ptr refers to an object managed by a shared_ptr but does not contribute to the reference count. To use the object, it must be converted to a shared_ptr via lock().
• Use case: Breaking circular references, caches, observer patterns.

Circular Reference Example (Problem)

#include <memory>
#include <iostream>
using namespace std;

class B; // Forward declaration

class A {
public:
  shared_ptr<B> b_ptr;
  ~A() { cout << "A destroyed" << endl; }
};

class B {
public:
  shared_ptr<A> a_ptr;
  ~B() { cout << "B destroyed" << endl; }
};

int main() {
  shared_ptr<A> a = make_shared<A>();
  shared_ptr<B> b = make_shared<B>();
  a->b_ptr = b; // A's shared_ptr to B
  b->a_ptr = a; // B's shared_ptr to A

  // After main ends, ref counts: a=1 (from b->a_ptr), b=1 (from a->b_ptr)
  // Neither is destroyed -> MEMORY LEAK
  return 0; // No destructor output
}

Solution with weak_ptr

#include <memory>
#include <iostream>
using namespace std;

class B;

class A {
public:
  weak_ptr<B> b_ptr; // Use weak_ptr instead
  ~A() { cout << "A destroyed" << endl; }
};

class B {
public:
  weak_ptr<A> a_ptr; // Use weak_ptr instead
  ~B() { cout << "B destroyed" << endl; }
};

int main() {
  shared_ptr<A> a = make_shared<A>();
  shared_ptr<B> b = make_shared<B>();
  a->b_ptr = b; // weak_ptr assignment does NOT increase ref count for b
  b->a_ptr = a; // same for a

  // Now ref counts: a=1, b=1 (only the main shared_ptrs own)
  // At end of main, a and b destroyed, ref counts -> 0, objects deleted properly
  return 0; // Outputs: B destroyed, A destroyed (order may vary)
}

// Using the weak_ptr: need to lock() to get a temporary shared_ptr
void useWeakPtr(weak_ptr<A> w) {
  if (auto sptr = w.lock()) { // Convert to shared_ptr if object still exists
    cout << "A is still alive, can use it." << endl;
  } else {
    cout << "A has been destroyed." << endl;
  }
}

4. Memory Leaks and Prevention

A memory leak occurs when dynamically allocated heap memory is not deallocated, causing the memory to be permanently occupied, potentially exhausting system memory over time.

Common Leak Scenarios

• Forgetting to call delete/free after new/malloc.
• Circular references with shared_ptr (without weak_ptr).
• Exception thrown between new and delete (if not using RAII/smart pointers).
• Overwriting a pointer before deleting the old memory (e.g., int* p = new int(5); p = new int(10); leaks the first allocation).
• Incorrect use of delete instead of delete[] for arrays (undefined behavior, may leak).

Prevention Strategies

• Prefer smart pointers (unique_ptr, shared_ptr) over raw pointers for ownership.
• Use weak_ptr to break shared_ptr circular references.
• Adopt RAII for all resources (files, locks, memory) – acquire in constructor, release in destructor.
• Use containers (vector, string) instead of manual array allocation.
• In development, use memory debugging tools (Valgrind, AddressSanitizer, Visual Studio debugger memory checks).
• Establish and follow clear ownership conventions in code.

5. Memory Management Best Practices

• Prefer stack allocation for automatic management and speed. Use for small, short-lived objects.
• Prefer smart pointers over raw new/delete. Use unique_ptr by default for exclusive ownership; use shared_ptr only when shared ownership is necessary.
• Avoid raw new/delete in application code. If necessary, ensure they are paired and exception-safe (often using smart pointers immediately).
• Never return a pointer/reference to a local stack variable (dangling pointer/reference).
• Use standard containers (vector, map, etc.) which manage their own memory.
• Be mindful of object slicing when passing polymorphic objects by value.
• Understand the Rule of Three/Five/Zero for classes managing resources.

V. Modern C++ Features (C++11 and beyond)

C++11 and subsequent standards introduced many practical features, significantly improving development efficiency and code readability. They are high-frequency interview topics.

1. auto (Automatic Type Deduction)

• Purpose: The compiler deduces the variable’s type from its initializer, simplifying code, especially for complex types (iterators, smart pointers, lambda types).
• Rules:
  • auto variable must be initialized (type cannot be deduced otherwise).
  • Deduction strips top-level const, volatile, and references. Use const auto& to preserve them.
  • For arrays and functions, auto decays to pointer (unless auto& is used).

Examples

#include <vector>
#include <memory>
#include <typeinfo>
#include <iostream>
using namespace std;

int main() {
  // Basic types
  auto a = 10; // int
  auto b = 3.14; // double
  auto c = "hello"; // const char*
  auto d = 'X'; // char

  // Complex types (simplifies code)
  vector<int> vec = {1,2,3};
  auto it = vec.begin(); // vector<int>::iterator

  auto p = make_shared<int>(42); // shared_ptr<int>

  // Const and references
  const int ci = 100;
  auto e = ci; // e is int (const stripped)
  const auto f = ci; // f is const int
  auto& g = ci; // g is const int& (reference preserves const)

  // Arrays (decay to pointer)
  int arr[5] = {1,2,3,4,5};
  auto h = arr; // h is int*
  auto& i = arr; // i is int(&)[5] (reference to array)

  // Lambda type
  auto lambda = [](int x) { return x * 2; }; // type is unique unnamed lambda
  cout << lambda(5) << endl; // 10

  return 0;
}

Appropriate Use Cases

• Iterator and complex template type declarations.
• Lambda capture and storage.
• Generic code where the type is obvious or unimportant to the reader.
• Range-based for loops.

Inappropriate Use Cases

• Function parameters (use templates or concrete types).
• Class non-static data members (before C17; C17 allows auto for non-static members only with static const in-class initialization? Actually, auto is not allowed for non-static data members directly. Use decltype(auto) or a trailing return type for complex member types if needed).
• When the type is crucial for readability and not obvious from context.

2. decltype (Type Deduction)

• Purpose: Obtains the type of an expression or entity without evaluating it. Complementary to auto (auto deduces a variable’s type from its initializer, decltype deduces the type of any expression).
• Rules:
  • decltype(entity): If entity is a variable or function, yields its declared type (including const, volatile, references).
  • decltype((variable)) (note double parentheses): yields a reference type (lvalue reference).
  • decltype(expression): For other expressions, yields the type and value category of the expression (reference if expression is an lvalue).

Examples

#include <vector>
#include <iostream>
using namespace std;

int add(int a, int b) { return a + b; }

int main() {
  int x = 10;
  const int cx = 20;
  int& rx = x;

  // deducing variable types
  decltype(x) a = 5; // a is int
  decltype(cx) b = 15; // b is const int
  decltype(rx) c = x; // c is int& (bound to x)

  // deducing expression types
  decltype(x + cx) d = 25; // expression is int, d is int
  decltype(add(1,2)) e = 30; // function return type is int, e is int

  // double parentheses rule
  decltype((x)) f = x; // (x) is an lvalue expression, f is int&
  f = 100;
  cout << x << endl; // x is now 100

  // Useful in templates
  vector<int> vec = {1,2,3};
  decltype(vec[0]) g = vec[0]; // g is int& (operator[] returns reference)
  g = 99;
  cout << vec[0] << endl; // 99

  // Combined with auto for trailing return type (C++11)
  auto func() -> decltype(x + cx) {
    return x + cx; // Return type deduced as int
  }

  // In C++14, decltype(auto) can be used for return type deduction
  decltype(auto) h = (x); // h is int& (applies decltype rules to initializer)

  return 0;
}

Primary Uses

• Defining return types in templates (especially with decltype and auto together).
• Declaring variables that must match the type of an expression exactly.
• Metaprogramming and type traits.

3. Lambda Expressions (Detailed in STL Section)

Lambdas are anonymous function objects. Their core advantage is “define locally, use locally,” eliminating the need for separate function declarations.

Additional Notes: Lambda to Function Pointer Conversion

• A lambda with no capture can be implicitly converted to a function pointer with the same signature.
• A lambda with captures cannot be converted to a function pointer (needs to store captured variables).

void callFunc(int (*funcPtr)(int, int)) {
  cout << funcPtr(3, 4) << endl;
}

int main() {
  auto addNoCapture = [](int a, int b) { return a + b; };
  callFunc(addNoCapture); // OK: no-capture lambda converts to function pointer

  int x = 5;
  auto addWithCapture = [x](int a) { return a + x; };
  // callFunc(addWithCapture); // Error: cannot convert capture lambda to function pointer
  return 0;
}

4. Other Common Modern Features

(1) Range-based for loop (C++11)

Simplifies iteration over containers, arrays, or any range providing begin() and end().

vector<int> vec = {1,2,3,4,5};
// Read-only iteration
for (int val : vec) {
  cout << val << " ";
}
// Modify elements (use reference)
for (int& val : vec) {
  val *= 2;
}
// Use const reference for read-only access to large objects
for (const auto& elem : someContainer) {
  // ...
}

(2) Uniform Initialization and Initializer Lists (C++11)

Uses curly braces {} for initialization, providing a consistent syntax and preventing narrowing conversions.

// Variable initialization
int a{10}; // Direct initialization
int b = {20}; // Copy initialization

// Prevents narrowing
int c{5.0}; // Error: narrowing from double to int (compile-time error)
int d(5.0); // OK with parentheses (but truncates) - allowed but narrowing

// Aggregate initialization
int arr[]{1,2,3};
struct Point { int x, y; };
Point p{10, 20};

// Container initialization
vector<int> v = {1,2,3,4,5}; // Uses std::initializer_list constructor
map<string, int> m = {{"one", 1}, {"two", 2}};

// Class constructor call
class Widget {
public:
  Widget(int a, double b) { /* ... */ }
};
Widget w{42, 3.14}; // Calls constructor

(3) nullptr (C++11)

A keyword representing a null pointer constant of type std::nullptr_t. Safer than NULL (which is often 0) because it is not convertible to integral types.

void func(int) { cout << "func(int)" << endl; }
void func(char*) { cout << "func(char*)" << endl; }

int main() {
  func(NULL); // Might call func(int) if NULL is defined as 0
  func(nullptr); // Unambiguously calls func(char*)
  return 0;
}

// Also useful in templates
template<typename T>
void foo(T* ptr) {}

foo(nullptr); // T deduced as std::nullptr_t? Actually, T is deduced as std::nullptr_t for foo<std::nullptr_t>(std::nullptr_t*). More commonly:
int* p = nullptr; // p is null pointer of type int*

(4) constexpr (C++11/14)

Indicates that a variable/function can be evaluated at compile time. Enables compile-time computation, improving runtime performance.

// constexpr variables
constexpr int MAX_SIZE = 100;
constexpr double PI = 3.141592653589793;

// constexpr functions (C++11: limited, C++14: relaxed)
constexpr int square(int x) { // C++11: body must be a single return statement
  return x * x;
}
constexpr int factorial(int n) { // C++14: allows loops, local variables
  int result = 1;
  for (int i = 1; i <= n; ++i) result *= i;
  return result;
}

int main() {
  constexpr int val = square(5); // Computed at compile time
  int arr[factorial(3)]; // Array size 6, computed at compile time

  int runtime_input = 10;
  int runtime_val = factorial(runtime_input); // Can also be called at runtime

  return 0;
}

C++17 added if constexpr for compile-time conditional compilation within templates.

5. Modern Feature Usage Recommendations

• Use auto to reduce verbosity, especially with complex types, but not when the type is important for clarity.
• Prefer uniform initialization {} for its safety (no narrowing) and consistency.
• Use lambdas for short, local operations (e.g., predicates for STL algorithms). For complex logic, consider named functions or function objects.
• Adopt smart pointers as the default for dynamic memory ownership.
• Use nullptr instead of NULL or 0 for pointers.
• For new projects, target at least C11 (preferably C14/17/20) to leverage modern features.
• For interviews, be prepared to discuss auto, decltype, lambdas, smart pointers, nullptr, constexpr, move semantics, and maybe variadic templates.