📖 Guide
C++ — Complete Reference
Comprehensive C++ cheat sheet covering STL containers, OOP, templates, smart pointers, and modern C++ features.
104 commands across 12 categories
BasicsStringsContainers (vector/map/set)IteratorsClasses & OOPTemplatesSmart PointersError HandlingFile I/OSTL AlgorithmsModern C++ (11/14/17/20)Lambda Expressions
Basics
| Command | Description |
|---|---|
#include <iostream> | Include I/O stream library |
int main() { return 0; } | Program entry point |
std::cout << "Hello" << std::endl; | Print to stdout |
std::cin >> x; | Read input from stdin |
using namespace std; | Use std namespace (avoid in headers) |
auto x = 42; | Type inference — compiler deduces the type (C++11) |
const int MAX = 100; | Compile-time or runtime constant |
constexpr int SQ = 5 * 5; | Guaranteed compile-time constant (C++11) |
int& ref = x; | Reference — alias for another variable |
Strings
| Command | Description |
|---|---|
#include <string> | Include string library |
std::string s = "hello"; | Declare a std::string |
s.length() s.size() | Get string length |
s.substr(pos, len)e.g. "hello".substr(1, 3) // "ell" | Extract substring |
s.find("sub") | Find substring position (string::npos if not found) |
s.append(" world") s += " world" | Append to string |
s.c_str() | Get C-style null-terminated char pointer |
std::to_string(42) | Convert number to string |
std::stoi(s) std::stod(s) | Parse string to int or double |
s.empty() | Check if string is empty |
Containers (vector/map/set)
| Command | Description |
|---|---|
std::vector<int> v = {1, 2, 3}; | Dynamic array |
v.push_back(4); | Add element to end of vector |
v.pop_back(); | Remove last element |
v.size() v.empty() | Get size / check if empty |
v[i] v.at(i) | Access element (at() throws on out-of-range) |
std::map<std::string, int> m; | Ordered key-value map (red-black tree) |
m["key"] = 42; | Insert or update map entry |
m.count("key") m.find("key") | Check existence / get iterator |
std::unordered_map<K, V> | Hash map — O(1) average lookup (C++11) |
std::set<int> s = {3, 1, 2}; | Ordered unique-element set |
Iterators
| Command | Description |
|---|---|
v.begin() v.end() | Iterator to first / past-the-end element |
for (auto it = v.begin(); it != v.end(); ++it) | Classic iterator loop |
for (auto& elem : v) { } | Range-based for loop (C++11) |
*it | Dereference iterator to get value |
std::advance(it, n) | Move iterator forward by n positions |
std::next(it) std::prev(it) | Get iterator to next/previous element (C++11) |
v.rbegin() v.rend() | Reverse iterators |
std::distance(first, last) | Count elements between two iterators |
Classes & OOP
| Command | Description |
|---|---|
class Name { public: ... private: ... }; | Declare a class with access specifiers |
Name obj; Name obj(args); | Create object on stack |
Name(int x) : x_(x) { } | Constructor with initializer list |
~Name() { } | Destructor — called when object is destroyed |
class Child : public Parent { }; | Public inheritance |
virtual void method() = 0; | Pure virtual method (makes class abstract) |
void method() override; | Override virtual method (C++11, catches errors) |
friend class Other; | Grant another class access to private members |
static int count; | Static member — shared across all instances |
explicit Name(int x); | Prevent implicit conversions in constructor |
Templates
| Command | Description |
|---|---|
template <typename T>\nT max(T a, T b) { return a > b ? a : b; } | Function template |
template <typename T>\nclass Stack { T data[100]; }; | Class template |
max<int>(3, 5) | Explicit template instantiation |
template <typename T, int N> | Non-type template parameter |
template <>\nclass Stack<bool> { }; | Template specialization |
template <typename... Args>\nvoid log(Args... args) | Variadic template (C++11) |
template <typename T>\nconcept Numeric = std::integral<T> || std::floating_point<T>;e.g. template <Numeric T> T add(T a, T b); | Concept constraint (C++20) |
Smart Pointers
| Command | Description |
|---|---|
#include <memory> | Include smart pointer library |
auto p = std::make_unique<Type>(args); | Create unique_ptr (exclusive ownership, C++14) |
auto p = std::make_shared<Type>(args); | Create shared_ptr (reference counted) |
std::weak_ptr<Type> w = shared; | Weak reference — doesn't prevent destruction |
p.get() | Get raw pointer without releasing ownership |
p.reset(); | Release ownership and destroy object |
std::move(unique_p) | Transfer unique_ptr ownership |
if (auto s = w.lock()) { } | Try to get shared_ptr from weak_ptr |
Error Handling
| Command | Description |
|---|---|
try { } catch (const std::exception& e) { } | Catch exceptions by const reference |
throw std::runtime_error("msg"); | Throw a runtime error |
e.what() | Get exception message string |
catch (...) { } | Catch any exception type |
noexcepte.g. void safe() noexcept { } | Declare function won't throw (C++11) |
std::optional<T>e.g. std::optional<int> find(int id); | Value that may or may not exist (C++17) |
static_assert(cond, "msg"); | Compile-time assertion (C++11) |
File I/O
| Command | Description |
|---|---|
#include <fstream> | Include file stream library |
std::ifstream in("file.txt"); | Open file for reading |
std::ofstream out("file.txt"); | Open file for writing (creates/overwrites) |
std::getline(in, line); | Read a full line into string |
out << "text" << std::endl; | Write to file using stream operator |
in.is_open() | Check if file was opened successfully |
in.close(); | Explicitly close file (auto-closes on destruction) |
while (std::getline(in, line)) { } | Read file line by line |
STL Algorithms
| Command | Description |
|---|---|
#include <algorithm> | Include algorithms library |
std::sort(v.begin(), v.end()); | Sort a container in ascending order |
std::sort(v.begin(), v.end(), cmp); | Sort with custom comparator |
std::find(v.begin(), v.end(), val); | Find first occurrence of value |
std::count(v.begin(), v.end(), val); | Count occurrences of value |
std::reverse(v.begin(), v.end()); | Reverse container in place |
std::accumulate(v.begin(), v.end(), 0);e.g. #include <numeric> | Sum all elements (numeric header) |
std::transform(in.begin(), in.end(), out.begin(), fn); | Apply function and store results |
std::any_of(v.begin(), v.end(), pred); | Check if any element satisfies predicate |
std::min_element(v.begin(), v.end()); | Iterator to smallest element |
Modern C++ (11/14/17/20)
| Command | Description |
|---|---|
auto [x, y] = pair;e.g. auto [key, val] = *map.begin(); | Structured bindings (C++17) |
if (auto it = m.find(k); it != m.end()) | If with initializer (C++17) |
std::variant<int, std::string> v; | Type-safe union (C++17) |
std::any a = 42; | Type-erased container for any value (C++17) |
std::string_view sv = "hello"; | Non-owning string reference (C++17) |
constexpr if (cond) { } | Compile-time branching (C++17) |
std::ranges::sort(v); | Ranges — cleaner algorithm syntax (C++20) |
auto result = v | std::views::filter(pred) | std::views::transform(fn); | Lazy range views with piping (C++20) |
co_await co_yield co_return | Coroutine keywords (C++20) |
Lambda Expressions
| Command | Description |
|---|---|
[](int x) { return x * 2; } | Basic lambda — no captures |
[&](int x) { return x + y; } | Capture all by reference |
[=](int x) { return x + y; } | Capture all by value (copy) |
[&x, y]() { } | Capture x by reference, y by value |
[](int x) -> double { return x / 2.0; } | Lambda with explicit return type |
auto fn = [](auto x) { return x * x; }; | Generic lambda (C++14) |
[x = std::move(ptr)]() { } | Init capture — move into lambda (C++14) |
[]<typename T>(T x) { return x; } | Templated lambda (C++20) |
📖 Free, searchable command reference. Bookmark this page for quick access.