Ruby.CodeCompared.To/C++

#include <iostream> pulls in the standard I/O library. std::cout is the standard output stream; << is the stream insertion operator that sends values to it. Unlike Ruby's puts, std::cout does not add a newline automatically — you must provide std::endl (which flushes the buffer) or "\n" (which does not flush). Every C++ program starts in main(); returning 0 signals success to the OS.

C++ supports both // single-line comments (added in C++98) and /* ... */ block comments inherited from C. Block comments cannot be nested — a /* inside a block comment does not open a second level. The idiomatic choice is // for most in-code comments and /* ... */ for temporarily disabling large code regions.

The << operator can be chained — each call returns the stream, so you can feed multiple values in one statement. There is no string interpolation syntax like Ruby's #{}; you concatenate values into the stream directly. C++20 adds std::format (covered in the Modern C++ section) for printf-style interpolation.

In Ruby, a variable is just a name that can point to any object regardless of type. In C++, every variable has a fixed type declared at compile time, and the compiler rejects assignments of the wrong type. This catches an entire class of bugs before the program ever runs — at the cost of more explicit declarations.

auto tells the compiler to deduce the variable's type from its initializer — similar to how Ruby always infers types, but in C++ the deduced type is fixed at compile time and cannot change. auto is idiomatic in modern C++ to reduce verbosity, especially with long iterator or template types. Note that auto greeting = "hello"; would deduce const char* (a C-style pointer), not std::string — the explicit std::string{} construction is required.

C++ has a richer set of numeric primitives than Ruby: int (typically 32-bit), long (32 or 64-bit), long long (64-bit), float (32-bit), and double (64-bit). Ruby's Integer is arbitrary-precision; C++'s integers overflow silently. A bool prints as 1 or 0 by default — use std::boolalpha to print true/false.

const declares a variable whose value cannot be changed after initialization — the compiler rejects any attempt to assign to it. constexpr (C++11) goes further: the value must be computable at compile time, enabling the optimizer to substitute it as a literal with zero runtime cost. Prefer constexpr for true mathematical constants and const for runtime values that happen to be immutable.

C++ integers have fixed sizes that vary by platform — int may be 32 or 64 bits depending on the architecture. The <cstdint> header provides types with guaranteed sizes: int32_t, uint64_t, etc. Unlike Ruby's arbitrary-precision integers, C++ integers overflow silently when they exceed their range — a common source of bugs. The int8_t value must be cast to int for printing since cout treats int8_t as a character.

std::string is C++'s standard string class — it manages its own memory and supports all the operations you'd expect. It lives in <string>. The raw C-style string literal "Hello" is a const char*; assigning it to a std::string copies the characters into a managed heap buffer. The method .size() and .length() are identical — both return the number of bytes (not Unicode code points).

The + operator on std::string allocates a new string containing both halves — just like Ruby. For performance-sensitive code with many concatenations, prefer += (appends in place) or std::string::append() to avoid repeated allocations. You cannot use + to concatenate two C-style string literals directly ("a" + "b" is a compile error); at least one operand must be a std::string.

std::format (C++20) is C++'s answer to Ruby's string interpolation. The {} placeholders are replaced by the arguments in order. Unlike Ruby's #{}, the format string is separate from the arguments — but it supports rich formatting: {:.2f} for floats, {:>10} for right-alignment, {:05} for zero-padding. Pre-C++20 code uses std::ostringstream or printf for the same purpose.

std::string::find() returns the index of the first match, or the sentinel std::string::npos (the largest possible size_t value) if not found — always check against npos before using the result. substr(pos, length) extracts a substring. Unlike Ruby, std::string has no built-in upcase or downcase — you use std::transform with std::toupper from <algorithm>.

std::to_string() converts numbers to strings; std::stoi() ("string to int"), std::stod() ("string to double"), and friends do the reverse. Note that std::to_string(3.14) produces "3.140000" with six decimal places — use std::format("{}", 3.14) (C++20) for cleaner output. The std::sto* functions throw std::invalid_argument if the string cannot be parsed.

std::vector<T> is C++'s closest equivalent to Ruby's Array — a dynamic, resizable, contiguous sequence. The type parameter <int> is mandatory: a vector is a homogeneous collection, unlike Ruby arrays which can mix types. numbers[2] does not bounds-check (undefined behavior on out-of-bounds access); use numbers.at(2) for a checked access that throws std::out_of_range.

push_back() appends to the end, pop_back() removes the last element (without returning it — use back() first if you need the value). To insert or remove from the middle, use insert(it, value) and erase(it) with an iterator. The range-based for loop shown here is the C++ equivalent of Ruby's each.

std::map<K, V> is an ordered map backed by a red-black tree — iteration always yields keys in sorted order. Ruby's Hash preserves insertion order; if you need that in C++, use std::unordered_map instead (average O(1) lookup vs O(log n) for std::map). Accessing a missing key with [] silently inserts a default-constructed value — use .at(key) to throw instead, or .count(key) / .contains(key) to check existence first.

The C++17 structured binding const auto& [name, score] unpacks each std::pair<const K, V> entry into named variables — exactly like Ruby's block parameters in each { |name, score| }. The const auto& avoids copying the pair; omitting & would copy every entry. Because std::map is ordered, the output is alphabetical by key.

std::set<T> stores unique values in sorted order (backed by a red-black tree). Inserting a duplicate is silently ignored. Like std::map, it uses count() or contains() to check membership — there is no include? method. For unordered unique elements with O(1) average lookup, use std::unordered_set. Ruby's Set requires require 'set'; C++'s std::set is built into the standard library.

std::pair holds exactly two values of potentially different types, accessed via .first and .second. std::tuple generalizes this to any number of typed elements, accessed via std::get<N>() with a compile-time index. C++17 structured bindings (auto [first, second] = point;) give both types a cleaner access syntax. These types are useful for returning multiple values from a function without defining a dedicated struct.

The C++ if/else if/else chain works identically to Ruby's if/elsif/else — note the spelling difference: elsif in Ruby vs else if in C++. The condition must be in parentheses. In C++ any non-zero integer, non-null pointer, or non-empty std::optional is truthy — unlike Ruby where only nil and false are falsy.

The range-based for loop (C++11) is C++'s equivalent of Ruby's each — it works on any type that provides begin() and end() iterators, including std::vector, std::map, arrays, and strings. The const std::string& avoids copying each element; use std::string& (without const) if you need to modify elements in place, or auto to let the compiler deduce the type.

The while loop is structurally identical in both languages. C++ adds the ++ and -- increment/decrement operators that Ruby lacks — they are the origin of the name "C++". C++ also has a do { ... } while (condition); variant that always executes the body at least once, and the classic for (init; condition; step) loop for index-based iteration.

C++'s switch only dispatches on integer values (or enums) — it cannot match strings or arbitrary objects like Ruby's case/when. Each case requires an explicit break to stop falling through to the next case; forgetting break is a common bug. C++17 adds [[fallthrough]] as an intentional fall-through annotation. For string dispatch, use an if/else if chain or a std::map<std::string, std::function<void()>>.

The ternary operator condition ? value_if_true : value_if_false is identical in Ruby and C++. It is an expression (produces a value), not a statement, so it can appear anywhere an expression is valid — in an initializer, a function argument, or a return. The parentheses around the condition are optional but improve readability.

Every C++ function must declare its return type before its name, and the types of all parameters. Unlike Ruby, which returns the value of the last expression, C++ requires an explicit return statement (except for void functions). Functions must be declared before they are used — either by defining them above main, or by providing a forward declaration (prototype) beforehand.

Default parameter values in C++ work the same as in Ruby — omitted arguments use the default. However, C++ requires that all parameters with defaults appear after all parameters without them. There are no keyword arguments in C++ (unlike Ruby's name: syntax) — all arguments are positional. Multiple overloads (next example) are often used instead of complex default-argument combinations.

C++ allows multiple functions with the same name if they differ in parameter types — the compiler selects the right one at compile time based on the argument types. Ruby achieves similar flexibility at runtime via duck typing: a single method handles many types because it calls methods on the arguments (which may or may not exist). C++ overloading is resolved at compile time with zero runtime cost; Ruby's duck typing is resolved at runtime with maximum flexibility.

In Ruby, integers are immutable value objects — passing one to a method cannot change the caller's variable. In C++, passing by reference (int&) gives the function a direct alias to the caller's variable, allowing in-place modification. Passing by value (int) copies the argument, leaving the caller's variable unchanged. References are also used for efficiency — passing a large std::string by const std::string& avoids copying.

C++ functions return exactly one value, but a std::pair or std::tuple packs multiple values into that single return. C++17 structured bindings (auto [minimum, maximum] = ...) then unpack the pair cleanly at the call site — achieving the same ergonomics as Ruby's multiple assignment. The * before std::min_element dereferences the iterator it returns into the actual value.

C++ lambdas use the syntax [captures](parameters) { body }. The [] is the capture list (empty here — the lambda uses no variables from the surrounding scope). The return type is deduced automatically when the body is a single return statement. Stored in an auto variable, a lambda acts just like Ruby's ->(x) { ... } lambda — it is called with () syntax.

The capture list [multiplier] captures multiplier by value — a copy is made when the lambda is created, and later changes to the original variable do not affect the lambda. Capturing by reference [&multiplier] gives the lambda a live view of the variable; modifications to either side are visible from the other. Use [=] to capture all locals by value, [&] to capture all by reference — but prefer explicit captures to make dependencies clear.

std::function<ReturnType(ParamTypes...)> is a type-erased wrapper that can hold any callable: a lambda, a function pointer, or a functor (an object with operator()). It is analogous to Ruby's Proc stored in a variable. The type std::function<int(int)> holds any callable that accepts an int and returns an int. For performance-critical code, prefer templated functions with auto parameters (or concepts) over std::function, which has runtime overhead from type erasure.

STL algorithms like std::sort, std::find_if, and std::transform accept lambdas as their last argument, playing the role that blocks play in Ruby's sort_by, find, and map. The lambda [](int first, int second) { return first > second; } is a custom comparator that sorts in descending order. This pattern — algorithm + lambda — is the idiomatic C++ alternative to Ruby's Enumerable methods.

C++ classes use public: and private: access specifiers to control visibility — all members are private by default in a class (the opposite of struct where all members are public by default). The : name(name), age(age) after the constructor signature is a member initializer list — the idiomatic way to initialize member variables, more efficient than assignment in the constructor body. Objects are created on the stack without new.

The destructor (~ClassName()) runs automatically and deterministically when an object goes out of scope — this is the foundation of RAII (Resource Acquisition Is Initialization). Unlike Ruby's garbage collector, which reclaims memory at unpredictable times, C++ destructors run at a precisely defined point. This makes C++ destructors the right place to release resources like file handles, network connections, and mutex locks.

The const after a member function declaration means the function promises not to modify the object — calling a non-const method on a const object is a compile error. This is more explicit than Ruby's convention of naming mutating methods with !. C++ has no built-in equivalent of Ruby's attr_reader/attr_writer macros — getter and setter methods must be written explicitly.

C++ inheritance uses class Child : public Parent syntax — public inheritance preserves the parent's public interface. A virtual function enables runtime polymorphism; = 0 makes it pure virtual (abstract — must be overridden by subclasses, analogous to Ruby's raise NotImplementedError convention). The override keyword is a C++11 safety net — the compiler verifies that the function actually overrides a virtual base method. The protected: specifier allows subclasses to access name while hiding it from external code.

C++ polymorphism requires pointers or references — calling a virtual method on a value type uses the static (compile-time) type, not the runtime type. std::unique_ptr (covered in the Memory section) manages the heap-allocated objects automatically. The virtual ~Shape() = default virtual destructor is essential: without it, deleting a Circle via a Shape* would only call Shape's destructor, leaking memory. The -> operator dereferences a pointer and accesses a member in one step.

C++ allows overloading almost any operator — +, -, *, [], (), <<, and more. Ruby similarly allows defining +, [], and other operators as methods. Overloading << for std::ostream is the C++ equivalent of Ruby's to_s — it tells cout how to print the object. A struct is identical to a class except that members default to public.

Templates achieve what Ruby achieves through duck typing — a single definition that works for any type — but the mechanism is different: the compiler generates a separate specialized version of the function for each type used. This is resolved at compile time with zero runtime overhead. The typename T declares a type parameter. C++20 adds auto parameters and concepts (type constraints) for cleaner template definitions: auto largest(auto first, auto second) works in C++20.

A class template parameterizes an entire class over a type. Stack<int> and Stack<std::string> are two different classes generated from the same template definition. The STL containers (std::vector<T>, std::map<K, V>) are all class templates. Unlike Ruby's single Array class that holds any object, each std::vector instantiation holds exactly one type — enforced at compile time.

C++20 concepts let you express type requirements on template parameters that the compiler verifies at the call site, producing clear error messages instead of cryptic template expansion errors. std::integral and std::floating_point are standard concepts from <concepts>. You can define your own: template<typename T> concept Printable = requires(T t) { std::cout << t; };. This is the C++ equivalent of Ruby's duck-typing checks, made explicit and compiler-enforced.

In Ruby every object lives on the garbage-collected heap. In C++, local variables live on the stack and are freed automatically and deterministically when they leave scope — no GC required. Types like std::string and std::vector internally manage heap memory for their data, but their ownership bookkeeping lives on the stack and is released via their destructors. Modern C++ avoids raw new/delete entirely; use stack allocation and smart pointers instead.

std::unique_ptr<T> (C++11) is a smart pointer that owns its object exclusively — when the unique_ptr is destroyed (goes out of scope, or is explicitly reset), it automatically deletes the managed object. There can be only one unique_ptr to any given object; ownership can be transferred with std::move but not copied. Use std::make_unique<T>(args) rather than new directly. Access members via -> just like a raw pointer.

std::shared_ptr<T> uses reference counting — the managed object is deleted only when the last shared_ptr pointing to it is destroyed. This is similar to Ruby's internal reference counting for garbage collection. Use shared_ptr when multiple parts of the program share ownership of the same object; use unique_ptr when ownership is clear and singular. Prefer unique_ptr by default — the explicit transfer of ownership via std::move makes code intent clearer.

RAII (Resource Acquisition Is Initialization) means tying a resource's lifetime to an object's lifetime — acquire in the constructor, release in the destructor. When the object goes out of scope, the destructor runs and the resource is freed, even if an exception is thrown. Ruby achieves the same pattern with blocks (File.open { |f| ... }), but C++ RAII is automatic for any stack-allocated object. The file in this example is marked norun because Compiler Explorer restricts filesystem access.

The C++ exception model maps cleanly to Ruby's: throw ↔ raise, try { ... } catch (...) { ... } ↔ begin/rescue/end. The standard exception hierarchy lives in <stdexcept>: std::runtime_error, std::invalid_argument, std::out_of_range, etc. — analogous to Ruby's StandardError hierarchy. Catching by const& avoids copying. Unlike Ruby, C++ exceptions are not used for flow control in performance-sensitive code — they are slower than return values when the error path is frequently taken.

Multiple catch clauses are tried in order — the first matching type is used, just like Ruby's multiple rescue clauses. The catch-all catch (...) matches any thrown value, including non-exception types (C++ allows throwing integers or strings, though this is considered bad practice). In Ruby, any object can be raised with raise; in C++, best practice is to always throw objects derived from std::exception so catch (const std::exception& e) works as a safe catch-all.

std::optional<T> (C++17) represents a value that may or may not be present — a type-safe alternative to returning a sentinel value or null pointer. It plays the role of Ruby's nil for functions that may fail to find a result. Check for a value with if (result) or result.has_value(); access the value with *result or result.value() (which throws std::bad_optional_access if empty). std::nullopt is the "empty optional" constant, analogous to nil.

std::sort sorts a range defined by two iterators — begin() and end() — in place. Unlike Ruby's sort (which returns a new array), std::sort always modifies the collection in place (like Ruby's sort!). The optional third argument is a custom comparator lambda. C++20 ranges allow std::ranges::sort(numbers) — shorter and equivalent.

std::find_if returns an iterator to the first element matching the predicate — not the element itself. To get the value, dereference it with *iterator. Always check against end() before dereferencing; dereferencing an end iterator is undefined behavior. This is analogous to Ruby's find/detect, which returns nil when nothing matches. C++23 adds std::ranges::find_if for a cleaner API.

std::transform applies a function to each element and writes the results to an output iterator — the C++ equivalent of Ruby's map. Unlike map, it writes into a pre-allocated destination (here squares, sized to match numbers); it does not return a new collection. C++20 ranges offer std::views::transform(numbers, fn) as a lazy, non-allocating alternative that is more composable.

std::accumulate from <numeric> folds a range into a single value, starting from an initial value — equivalent to Ruby's reduce/inject. The third argument is the starting value (0 for sum, 1 for product). The optional fourth argument is a custom binary operation. C++17 adds std::reduce (same as accumulate but parallelizable) and std::inclusive_scan/exclusive_scan for running totals.

std::copy_if is the C++ equivalent of Ruby's select/filter. std::back_inserter(evens) is an output iterator that calls push_back on evens for each element that passes the predicate — it grows the destination vector automatically. The C++20 ranges version is more concise: auto evens = numbers | std::views::filter([](int n){ return n % 2 == 0; });.

std::all_of, std::any_of, and std::none_of are direct counterparts to Ruby's all?, any?, and none?. They short-circuit: all_of stops at the first failing element, any_of stops at the first passing element. All three print 1 for true and 0 for false — use std::boolalpha to print true/false instead.

Structured bindings (auto [a, b, c] = ..., C++17) let you unpack tuples, pairs, arrays, and structs into named variables — exactly like Ruby's multiple assignment. They work in for loops to destructure map entries, and with function return values of type std::pair or std::tuple. The binding const auto& avoids copying; auto alone copies the element.

Brace initialization ({...}, C++11) is the modern, preferred way to initialize objects in C++ — it works uniformly for arrays, containers, structs, and class objects, and prevents narrowing conversions. int count{42} is equivalent to int count = 42 but would reject int count{3.14} (whereas int count = 3.14 silently truncates). The = {1, 2, 3} syntax on a std::vector invokes its std::initializer_list constructor.

enum class (C++11) creates a strongly-typed, scoped enum — values must be qualified with the enum name (Direction::North, not just North), and they cannot be implicitly converted to integers. This is safer than the old C-style enum, which polluted the enclosing namespace. The concept is similar to Ruby module constants (Direction::NORTH) but enforced by the compiler's type system — you cannot accidentally compare a Direction with a Color.

constexpr functions (C++11) can be evaluated at compile time when all their arguments are compile-time constants, embedding the result directly in the binary with zero runtime overhead. The same function also works at runtime when called with runtime values. This is a superpower Ruby lacks entirely — Ruby evaluates all code at runtime. constexpr is widely used for mathematical constants, lookup table generation, and compile-time validation.

C++20 ranges introduce a pipeline syntax using | that composes lazily — no intermediate containers are allocated. This is the C++ equivalent of Ruby's chained Enumerable methods (select.map.first). The std::views::filter, std::views::transform, and std::views::take adaptors create lazy views that only compute values as they are consumed by the for loop. This lazy evaluation is similar to Ruby's lazy enumerator.

std::format (C++20) uses a mini-language for format specifiers: {:<10} is left-aligned in a 10-character field, {:>5.2f} is right-aligned with 2 decimal places, {:#x} is hexadecimal with 0x prefix. The syntax is inspired by Python's str.format() and is considerably more powerful than printf. A companion std::println (C++23) adds the newline automatically.

C++ namespaces play the same organizational role as Ruby's modules: they prevent name collisions and group related declarations. The :: scope resolution operator is the same as Ruby's. C++17 allows the compact form namespace A::B::C { ... } instead of three nested namespace blocks. The often-seen using namespace std; brings all of std into scope — convenient but considered poor practice in headers, since it can cause unexpected name collisions.