C++.CodeCompared.To/Ruby

puts is a method call with the parentheses omitted, which Ruby allows almost everywhere and which is why Ruby code so often reads like a sentence. There is no main: a script executes top to bottom. Note also that puts is not an operator or a keyword but an ordinary private method on Object, so it is available everywhere for the same reason every other method is — which the object-model section makes precise.

Ruby made an unusual trade: the interpreter is slow by the standards of its peers, and the C API is unusually good — small, stable, and documented, with Init_ conventions that have barely changed in twenty years. The result is an ecosystem that assumes the expensive parts live in C. For a C++ programmer that is the opening: you are not being asked to write a Rails app, you are being asked to make something fast, and the next two sections are the two ways to do it.

Three things to internalize. VALUE is Ruby's universal value type, the equivalent of Godot's Variant and Lua's stack slot — every Ruby object is one, and the NUM2LONG/LONG2NUM family converts. Init_<name> is found by symbol name when the library loads, so it must be extern "C" or C++ name mangling hides it. And the arity argument (2) is checked by Ruby before your function is called, so you do not validate argument counts yourself. mkmf generates a Makefile that already knows Ruby's include paths and flags.

rb_thread_call_without_gvl is what turns a C++ extension from "faster interpreter" into "actually parallel": while it runs, other Ruby threads execute. The absolute rule is that the callback must not touch any Ruby API — no VALUEs, no allocation, no exceptions — because the interpreter's invariants are not held. Convert your inputs to plain C++ types before releasing, work, then convert back after reacquiring. This is the same shape as the GIL discussion on /cpp/python, and the same escape hatch.

mruby exists because CRuby is a poor fit for embedding: it assumes one interpreter per process, carries a large runtime, and its GVL is process-global. mruby fixes all three — mrb_state is fully self-contained, so a program can run several independently, and the build is assembled from "mrbgems" so you include only what you need. The trade against Lua is size and maturity of the embedding ecosystem: Lua is smaller and has far more prior art, while mruby gives you blocks, real classes and Enumerable. Where CRuby is what you extend, mruby is what you embed.

Every value is an object with a class, so 42.abs, 42.even? and nil.class all work, and Integer is itself an instance of Class. That uniformity is what makes the rest of the language possible: if integers are objects then they can be stored in generic containers without boxing rules, respond to <=> through Comparable, and be reopened like any other class. The cost is the obvious one — an Integer is a heap object unless the interpreter can tag it inline (small integers are, as "fixnums"), and every operation is a method dispatch.

The C++ column prints 3 4 and the Ruby column prints 4 4, because second = first aliases. There are no value types for your own classes and no way to ask for one — dup and clone are explicit and shallow, so an array of arrays duplicated with dup still shares its inner arrays. Integers, symbols, nil, true and false appear to have value semantics only because they are immutable. This is the single fact that explains most surprises a C++ programmer will hit.

A block is a chunk of code attached to a call site with its own syntax — { } for one line, do/end for several — and exactly one may be passed, which is why it needs no name. That privileged position is why Ruby's iteration, resource management, DSLs and callbacks all look the same: they are methods taking blocks. For a C++ programmer the closest analogy is a lambda that the language decided to make so cheap to write that it became the default way to structure control flow. yield, in the next row, is how a method calls it.

The method wraps the block: setup, yield, and an ensure that runs whether the block returned or raised. That is the with statement of Python, the use of Kotlin and the defer of Go, except that it reads as an ordinary method call — so the standard library exposes every resource this way and there is no second spelling to learn. The difference from RAII is the familiar one: the guarantee lives in the API rather than in the type, so a caller who uses File.open without a block gets an unclosed file and no warning.

Implement each on a class and include Enumerable, and you get map, select, reduce, sort_by, group_by, each_slice, partition, lazy and forty more — for free, on your own type. C++20 ranges reach a similar place through concepts, with the crucial difference that a ranges pipeline is lazy and compiles away, where Ruby's select and map each allocate a new array. readings.lazy.select{…}.map{…}.first(3) is the lazy form when the collection is large. Note &:even?, which turns a symbol into a block.

Both accept any type structurally supporting the operations used, and neither needs a common base class. The difference is when: instantiation time for the template, call time for Ruby — so the template gives a compile error and specialized machine code, and Ruby gives a NoMethodError at the moment the bad call is reached. respond_to? is the runtime capability check, the same role has_method plays in GDScript. Note def speak = "woof": endless method definition, Ruby 3.0 and later, for one-expression methods.

Reopening a class modifies it globally and retroactively, so "HELLO" created before the reopening still gains the method. That is what makes Rails' 2.days.ago possible and what makes a gem that patches String#to_json break another gem that patched it differently. Compare Swift and Rust, whose extensions are additive-only and bounded by an orphan rule, and Kotlin's, which are static functions in disguise — Ruby's is the unrestricted version. refine/using scopes a patch lexically and is the disciplined form, though it sees relatively little use.

Array is a growable vector of object references (so no contiguous ints and no cache locality — the same cost as Python's list) and Hash is a hash map that preserves insertion order, guaranteed. Two things with no C++ counterpart: negative indexing (readings[-1] is the last element) and slicing with ranges. And note gadget: 3 — that is a symbol key, the idiomatic choice for anything fixed, which the strings section explains.

<< appends in place rather than building a new string, so string building in a loop is O(n) here where it is O(n²) in Python. The + prefix asks for a mutable copy, which matters because Ruby has been moving toward frozen string literals for years: a literal is currently "chilled" — writable but warning — and frozen_string_literal: true at the top of a file makes literals genuinely immutable, which most modern codebases set. Interpolation with #{} runs arbitrary expressions and calls to_s, which is why Ruby rarely reaches for a format string.

A Symbol is an interned name: every occurrence of :status in a program is the same object, so equality is a pointer comparison and hashing is trivial. That is why they are the idiomatic choice for hash keys, method names, option flags and anything else drawn from a fixed vocabulary — the closest C++ analogue is an interned string or an enum used as a key. The rule of thumb: a symbol is a name, a string is data. Symbols were never garbage collected before Ruby 2.2, which is why old advice warns against generating them dynamically.

Instance variables are marked with @ and are always private — there is no way to read one from outside, which is why attr_reader, attr_writer and attr_accessor exist to generate the accessors. initialize is the constructor, called by new. And private applies to methods only, and is advisory: counter.send(:some_private_method) works, deliberately, on the same "we are all adults" reasoning Python uses. For a C++ programmer that is a real loss of enforcement in exchange for testability and introspection.

A module cannot be instantiated and holds no state of its own, so includeing several of them cannot produce two copies of a base — Ruby linearizes the ancestor chain instead, and ancestors shows you the resulting order. That resolves the diamond problem by construction rather than by virtual inheritance. Modules also serve as namespaces (Math::PI), which is the other half of what C++ uses namespace for. extend mixes into a single object rather than a class, and prepend inserts before the class, which is how method wrapping is done.

Everything raisable descends from Exception, and the conventional root for application errors is StandardError — a bare rescue catches that rather than everything, which is what you want. else runs when nothing raised, ensure always, and both have C++ counterparts only in the sense that destructors cover the second. The unusual one is retry: inside a rescue, it re-runs the begin block from the top, which makes "try three times with backoff" a five-line construct with no loop. Note Integer(text) rather than text.to_i, which returns 0 for garbage.

There is no destructor, and ObjectSpace.define_finalizer is a trap: it runs at an unpredictable time, may not run before exit, and capturing the object in the finalizer block keeps it alive forever. So cleanup is either an explicit method or — idiomatically — a block-taking method that ensures it, which is the row on yield above. The practical rule for a C++ programmer: any resource with a lifetime should be handed out through a block-taking API, so callers cannot forget. Ruby's collector is generational and incremental, and unlike Python's it is not reference counted, so cycles are collected but nothing is prompt.

define_method creates methods from data at runtime, and method_missing intercepts calls to methods that do not exist — together they are how ActiveRecord synthesizes find_by_name_and_email from a schema it read at boot. C++'s metaprogramming is strictly compile-time (templates, macros, and P2996 reflection in C++26), which is faster and checkable and cannot respond to a database. The cost is the one you would expect: no tooling can be sure what methods a class has, so autocomplete, static analysis and grep all get less reliable the more of this a codebase does.

Ruby is slow for the usual dynamic-language reasons: every value is an object, every operation is a dispatch, and open classes mean almost nothing can be resolved ahead of time. Three things change the picture. Range#sum and friends run the loop in C, exactly as sum(range(...)) does in Python. YJIT, shipped in Ruby 3.1 and mature since 3.3, gives real speedups on Rails-shaped workloads with no code changes and is enabled with --yjit. And a native extension moves the hot part to C++ entirely, which is where this page started.

Ruby's blocks plus optional parentheses plus method_missing make internal DSLs unusually pleasant to write, which is why so much infrastructure tooling landed here — a Rakefile, a Homebrew formula and a Podspec are all just Ruby with methods taking blocks, not bespoke config formats. For a C++ programmer that means the syntax is worth twenty minutes even if the language never enters your build: you will be editing these files, and knowing that task :build do … end is a method call with a symbol and a block turns a mysterious format into something you can reason about.

Like Lua and GDScript, Ruby is not competing with C++ for the same work — but unlike them it is not embedded in your program either. The arrangement is the reverse: your C++ goes inside its process, as an extension. That inversion is why the C API is so good and so stable, and why the ecosystem is full of thin Ruby over serious C. If you are a C++ programmer with a library worth using, writing the gem that wraps it is a well-trodden path — four lines of registration, an extconf.rb, and a VALUE conversion at each boundary.