C.CodeCompared.To/C++

std::cout is a stream object from <iostream>; << is the stream insertion operator. No format-string verbs like %s or %d — any type that defines operator<< can be streamed directly. std::endl also works but flushes the buffer on every call; "\n" is faster when flushing isn't needed.

g++ links the C++ standard library (libstdc++) automatically; using plain gcc to link C++ object files requires adding -lstdc++. The -std=c++23 flag unlocks the full C++23 standard library including std::format, ranges, and std::expected.

C++ provides C's standard headers as <c...> variants — <cstdio>, <cmath>, <cstring> — where every symbol also lives in the std:: namespace. The old <stdio.h> form still works but dumps names into the global namespace. Prefer <c...> in new C++ code.

std::format (C++23) provides Python-style {} placeholders with type-safe formatting — no %s/%d mismatch possible. Alignment uses < (left), > (right), ^ (center). printf still works in C++ but loses type safety.

Namespaces replace the C convention of prefixing every symbol with geometry_. Access is explicit with ::, keeping names short inside the namespace without risking collisions outside. std::numbers::pi (C++20) is the properly rounded compile-time constant; no M_PI needed.

using namespace std; is common in tutorials but risky in header files — it forces every includer to accept all 1000+ names from std:: into their global namespace, creating invisible collision hazards. Prefer qualified names (std::cout) or targeted using std::cout; declarations scoped to a function.

The namespace A::B::C {} shorthand (C++17) avoids the old triple-nested brace pyramid. The fully qualified name mylib::net::http::get is unambiguous regardless of scope. For deeply nested namespaces, a namespace alias (namespace http = mylib::net::http;) provides a shorter alias.

auto deduces the type at compile time from the initializer — the type is still fixed and static, not dynamic like a scripting language. It eliminates redundant repetition (std::map<std::string, std::vector<int>>::iterator) while keeping full type safety. Always provide an initializer; auto x; is a compile error.

nullptr has type std::nullptr_t, not int. This fixes NULL's ambiguity: in C++, NULL is the integer 0, so f(NULL) could resolve to f(int) instead of f(int*). nullptr always resolves to the pointer overload. Never use NULL in new C++ code.

using Name = Type; replaces typedef and reads naturally left-to-right for all types, including function pointers. Both are valid in C++; using is preferred in modern code. In C++, struct names are already usable without typedef — no typedef struct { ... } Name; idiom needed.

constexpr values and functions are evaluated at compile time, are type-safe, respect scopes, and are visible to the debugger — unlike #define macros, which are handled by the preprocessor before compilation. A constexpr function can also be called at runtime with non-constant arguments, making it more versatile than a C macro.

In C++, bool is a built-in type and true/false are keywords — no <stdbool.h> needed. Comparisons and logical operators return bool, not int. std::boolalpha makes cout print true/false instead of 1/0.

A reference is an alias for an existing variable — not a separate pointer value. It cannot be null, cannot be reseated to a different variable after initialization, and needs no * to dereference. At the call site the & is implicit. Internally the compiler usually implements references as pointers.

const T& is the C++ idiom for "read-only, no copy" — the C++ equivalent of const T * but without the & at the call site or -> for member access. For any type larger than a pointer (structs, strings, vectors), prefer const T& over pass-by-value to avoid an unnecessary deep copy.

std::swap works on any assignable type without duplicating code. For containers (std::vector, std::string), it is O(1) — it swaps internal pointers rather than copying elements. In C, you would need a separate swap per type, or an unsafe void*/memcpy version.

std::move transfers ownership of a value without copying — the source is left in a valid but unspecified state (usually empty). For std::string and containers this is O(1) instead of O(n). The compiler often applies Named Return Value Optimization (NRVO) automatically, eliminating even the move for returned locals.

std::string manages its own memory — no fixed-size buffers, no strcat overflow risk, no manual null termination. Assignment copies deeply. The + and += operators concatenate safely. Call .c_str() to get a const char * for C API compatibility.

substr(pos, len) returns a new std::string — no pointer arithmetic. find returns std::string::npos (the maximum size_t value) when not found — always check against npos, not -1. replace, insert, and erase modify the string in place.

std::stoi/std::stod throw std::invalid_argument if the string is not a valid number and std::out_of_range if the value overflows — unlike atoi, which silently returns 0 on failure. std::to_string replaces snprintf into a fixed buffer.

std::string_view is a non-owning read-only reference to a string — it stores a pointer and length without allocating. It accepts both std::string and const char * without conversion. Never return or store a string_view that may outlive its source — it is a view, not an owner.

std::vector<T> replaces the malloc/realloc/free dance. It doubles capacity when full (amortized O(1) push_back) and frees memory when it goes out of scope. Elements are contiguous — numbers.data() returns a T* for C API calls.

std::array<T, N> is a thin wrapper around a C array that knows its own size and works with STL algorithms. Unlike a plain C array, it does not decay to a pointer when passed to functions, so size() is always available. Stack-allocated, zero overhead — use it instead of int arr[N] in C++.

Range-based for works on anything with begin() and end() — vectors, arrays, strings, maps, and custom types. Use const auto & for large elements to avoid copies; use auto & to modify elements in place. Structured bindings (auto &[key, value]) unpack map pairs cleanly.

Brace initialization ({}) works uniformly for scalars, structs, vectors, and maps in C++11+. It prevents narrowing conversions at compile time — int value = {3.14}; is an error, not a silent truncation. C++20 added designated initializers matching C99's .field = value syntax.

In C++, struct and class are identical except for default access: struct members are public by default, class members are private. Methods defined inside the class body are implicitly inline. The const qualifier after a method signature means the method guarantees it will not modify the object.

The constructor runs automatically at creation; the destructor runs automatically when the object leaves scope. No separate _create/_destroy pattern, no manual free. The member initializer list (: name(...), age(...)) initializes members before the constructor body — the only way to initialize const or reference members.

private enforces encapsulation at compile time — no opaque pointer tricks or separate translation units needed. explicit on a single-argument constructor prevents accidental implicit conversions like BankAccount account = 100.0;. The compiler rejects any access to private members from outside the class.

virtual enables dynamic dispatch — calling through a base pointer or reference invokes the most-derived override. A pure virtual function (= 0) makes the class abstract. Always declare the base destructor virtual (or = default) to prevent undefined behavior when deleting a derived object through a base pointer. The compiler generates the vtable automatically.

Operator overloading lets user-defined types use built-in syntax. The compiler translates a + b into a.operator+(b). Prefer implementing binary operators as non-member functions (or friends) when both operands should be treated symmetrically. Overload sparingly — only when the operation has an obvious, unsurprising meaning.

RAII (Resource Acquisition Is Initialization) ties resource lifetime to object lifetime. Constructors acquire resources; destructors release them. Because destructors run automatically when a scope exits — whether by return, exception, or fall-through — there is no "remember to free on every path" problem. std::vector, std::fstream, and smart pointers are all RAII types.

std::unique_ptr owns the object exclusively — only one unique_ptr can point to a given object at a time. Ownership can be transferred with std::move but not copied. When the unique_ptr is destroyed, it calls delete automatically. Use std::make_unique rather than new directly.

std::shared_ptr implements reference-counted shared ownership. Each copy increments the count; each destruction decrements it. When the count reaches zero the object is deleted. Use std::weak_ptr to break ownership cycles — a weak_ptr does not increment the count and must be locked to access the object.

In modern C++, raw new/delete and malloc/free should almost never appear in application code. std::vector and std::string handle dynamic memory internally. When heap allocation is truly needed, std::make_unique or std::make_shared are the correct tools.

Templates are resolved at compile time — the compiler generates a separate copy of the function for each type used, with zero runtime overhead. Unlike C macros, templates are type-safe, respect scopes, work with references, and can be debugged. The C++ Standard Library is built almost entirely on templates.

A class template is instantiated for each type argument used — Stack<int> and Stack<std::string> are distinct classes, each fully type-safe. All template code is typically in headers because the compiler must see the definition to instantiate it.

Variadic templates accept any number and mix of types, resolved at compile time. No va_args hacks, no "count" parameter, no casts. The pack expansion rest... recursively unpacks the argument list. C++17 fold expressions simplify this further: (... + args) expands directly.

Concepts (C++20) name and enforce constraints on template arguments. Violations produce readable error messages at the call site ("constraint not satisfied") rather than deep template instantiation walls. The standard library provides built-in concepts: std::integral, std::floating_point, std::copyable, std::invocable, and many more.

std::map<K,V> is a sorted associative container (red-black tree) with O(log n) lookup. Iteration visits keys in sorted order. Note that scores["dave"] inserts a default-constructed value if the key is absent — use find or count for non-inserting lookups.

std::unordered_map<K,V> is a hash table with O(1) average lookup — faster than std::map for most access patterns, but iteration order is undefined. Requires the key type to be hashable (built-in types and std::string work out of the box). For custom key types, provide a std::hash specialization.

std::set<T> stores unique sorted elements with O(log n) insert and lookup. std::unordered_set<T> uses a hash table for O(1) average operations when order doesn't matter. Both containers guarantee uniqueness — inserting a duplicate is silently ignored.

std::sort is type-safe (no void* casts), typically faster than qsort (the comparator can be inlined), and works with any random-access range. Custom comparators are lambdas or function objects — no separate function needed. std::stable_sort preserves equal elements' relative order (at O(n log² n) cost).

STL algorithms return iterators pointing into the range. An iterator equal to end() means "not found". std::find_if accepts any predicate — a function, lambda, or function object. std::any_of, std::all_of, and std::none_of are short-circuit predicates over a range.

std::transform applies a function to each element and writes results to an output range (can be the same range for in-place transform). std::accumulate folds a range with a binary operation — the default is addition, but any binary function works. C++23 std::ranges versions of these algorithms are even more composable.

C++20 ranges compose operations with | into lazy pipelines — no intermediate vectors, no extra memory. The pipeline is evaluated element by element as it's consumed. std::views::filter, std::views::transform, std::views::take, std::views::drop, and many more are available in <ranges>.

A lambda is an anonymous function object created inline. The [] is the capture list; () is the parameter list; the return type is deduced automatically. Lambdas can be stored in auto variables or passed directly to algorithms. They replace the C pattern of naming a function solely to pass it as a callback.

The capture list lets a lambda close over local variables without global state or void* user-data tricks. [x] captures x by value (snapshot at creation); [&x] captures by reference (sees mutations but the lambda must not outlive x). [=] captures all accessed locals by value; [&] captures all by reference.

std::function<R(Args...)> is a type-erased callable wrapper that accepts lambdas, function pointers, and objects with operator(). It has a small overhead compared to a raw function pointer (heap allocation for large captures). For performance-critical callbacks, prefer template parameters or direct lambdas with auto.

Exceptions unwind the stack automatically — every RAII destructor runs between the throw and the catch, so resources are always released. Unlike errno, exceptions cannot be silently ignored. Catch by const ref to avoid slicing. std::exception::what() returns a human-readable description.

noexcept is a compile-time contract: the function will never throw. The compiler can generate faster code for noexcept functions (no stack-unwinding metadata). Move constructors and destructors should be noexcept — some STL operations (like std::vector resize) only use moves when they are guaranteed not to throw.

std::expected<T, E> (C++23) holds either a value or an error — like Rust's Result<T, E>. The error cannot be silently ignored: you must check whether the result holds a value before accessing it. Use it when errors are common and expected (not exceptional), avoiding exceptions for performance-critical or embedded code.

Operator overloading lets user-defined types use built-in syntax. The compiler translates a + b into a.operator+(b). = default on operator== (C++20) generates a member-by-member comparison automatically. Overload sparingly — only when the operation has an obvious unsurprising meaning matching the built-in semantics.

Defining operator<< as a non-member function lets your type work with any std::ostream — including std::cout, std::cerr, file streams, and string streams. Returning stream enables chaining: cout << a << b works because the first << returns the stream for the second.

The three-way comparison operator operator<=> (C++20) returns a category — std::strong_ordering, std::weak_ordering, or std::partial_ordering. When defaulted, the compiler generates it member-by-member in declaration order and automatically derives all six comparison operators. No more writing six separate operators by hand.

Structured bindings (C++17) unpack pairs, tuples, arrays, and structs into named variables. The names are bound to the actual members (references internally), not copies. They eliminate the need for .first/.second on pairs and are especially clean for map iteration.

std::optional<T> explicitly represents "a value that may or may not exist" — no sentinel values (-1, NULL, ""), no out-parameters, no boolean flags. Accessing a disengaged optional via * is undefined behavior; use value() (throws) or value_or(default) (safe) for guarded access.

std::variant<T...> is a type-safe tagged union — accessing the wrong alternative throws std::bad_variant_access rather than causing undefined behavior. std::visit dispatches to the right overload at runtime via a visitor. Use it instead of manual tagged unions or virtual dispatch when the set of types is closed.

C++17 allows an initializer in if and switch statements: if (init; condition). The initialized variable is scoped to the if/else block, preventing it from leaking into the surrounding scope. This is especially useful for map lookups and regex matches where you need the iterator only for the duration of the branch.

Variable-length arrays (VLAs) are C99 but not standard C++. GCC supports them as an extension, but using them in C++ is non-portable and disabled by -Wall -pedantic. Use std::vector<T>(count) for runtime-sized arrays — it's heap-allocated and safe. For compile-time sizes, use std::array<T, N>.

The One Definition Rule (ODR) says every entity must be defined exactly once across all translation units. In C++, inline variables (C++17) and inline functions can be defined in headers without violating the ODR — the linker merges them. Violating the ODR (two definitions with different bodies) is undefined behavior, not a guaranteed linker error.

The Most Vexing Parse: Widget c(); is parsed as a function declaration (a function named c that takes no arguments and returns Widget), not as a default-constructed Widget. Brace initialization Widget c{}; is always an object construction, never a function declaration — use it to avoid the ambiguity.

The Static Initialization Order Fiasco: when a global object in TU A depends on a global object in TU B, the initialization order between TUs is undefined. The solution is Meyers' Singleton: wrap the global in a function-local static — it is guaranteed to initialize on the first call to the function. Function-local statics are also thread-safe since C++11.

#pragma once is simpler than traditional include guards and supported by GCC, Clang, and MSVC. It cannot be accidentally broken by a mismatched macro name. C++20 modules (export module name;) eliminate headers entirely, but toolchain support is still maturing. New projects can start with #pragma once confidently.

Argument-Dependent Lookup (ADL, also called Koenig lookup): when you call an unqualified function, the compiler also searches the namespaces of the argument types. This is how std::swap(a, b) finds a type-specific swap in the type's namespace, and how operator<< for custom types works. ADL is powerful but can cause surprising name resolution — always qualify function calls when precision matters.