Davide Santangelo

Posted on Jun 25

Simulating C-Style Pointers in Ruby: A Complete Guide

#ruby #tutorial

Introduction

When transitioning from low-level languages like C to high-level languages like Ruby, one concept that developers often miss is direct pointer manipulation. While Ruby's garbage-collected, object-oriented nature abstracts away memory management, understanding pointers and their simulation can deepen your appreciation for both languages and open up interesting programming techniques.

In this comprehensive guide, we'll explore what pointers are, how they work in C, and most importantly, how we can simulate similar behavior in Ruby using various techniques and patterns.

What Are Pointers? A Deep Dive

Memory and Addresses

Before diving into pointers, let's understand computer memory. Every piece of data in your program lives somewhere in memory, and each memory location has a unique address. Think of memory like a massive apartment building where each apartment (memory location) has a unique address and can store one piece of data.

// In C, when you declare a variable
int age = 25;

The computer allocates memory to store the value 25, and that memory location has an address, something like 0x7fff5fbff6ac.

What Is a Pointer?

A pointer is simply a variable that stores the memory address of another variable. Instead of storing the actual data, it stores the location where that data can be found.

// C pointer example
int age = 25;           // Regular variable storing a value
int *age_ptr = &age;    // Pointer storing the address of 'age'

printf("Value of age: %d\n", age);           // Prints: 25
printf("Address of age: %p\n", &age);        // Prints: 0x7fff5fbff6ac
printf("Value of age_ptr: %p\n", age_ptr);   // Prints: 0x7fff5fbff6ac
printf("Value pointed to: %d\n", *age_ptr);  // Prints: 25

Why Are Pointers Powerful?

Pointers enable several powerful programming patterns:

Indirection: Access data through multiple levels of references
Dynamic Memory Management: Allocate and deallocate memory at runtime
Efficient Parameter Passing: Pass large structures by reference instead of copying
Data Structure Implementation: Build linked lists, trees, and graphs
Function Pointers: Treat functions as first-class citizens

Ruby's Memory Model vs. C's Memory Model

C's Explicit Memory Management

In C, you have direct control over memory:

#include <stdio.h>
#include <stdlib.h>

int main() {
    // Stack allocation
    int stack_var = 42;

    // Heap allocation
    int *heap_var = malloc(sizeof(int));
    *heap_var = 42;

    printf("Stack variable: %d at address %p\n", stack_var, &stack_var);
    printf("Heap variable: %d at address %p\n", *heap_var, heap_var);

    // Manual cleanup required
    free(heap_var);

    return 0;
}

Ruby's Object-Oriented Memory Model

Ruby abstracts memory management:

# Everything is an object in Ruby
stack_var = 42
heap_var = 42

puts "Stack variable: #{stack_var} with object_id #{stack_var.object_id}"
puts "Heap variable: #{heap_var} with object_id #{heap_var.object_id}"

# Garbage collection handles cleanup automatically

In Ruby, object_id is the closest thing to a memory address, but it's abstracted and managed by the Ruby interpreter.

Simulating Pointers in Ruby

While Ruby doesn't have true pointers, we can simulate pointer-like behavior using several techniques. Let's explore each approach with detailed examples.

Method 1: Using Arrays as Reference Containers

The simplest way to simulate pointers is using single-element arrays:

class Pointer
  def initialize(value = nil)
    @container = [value]
  end

  # Dereference operator equivalent
  def value
    @container[0]
  end

  # Assignment through pointer
  def value=(new_value)
    @container[0] = new_value
  end

  # Address-like identifier
  def address
    @container.object_id
  end

  # Pointer arithmetic simulation
  def +(offset)
    raise "Cannot perform arithmetic on single-value pointer" if offset != 0
    self
  end

  def to_s
    "Pointer[#{address}] -> #{value}"
  end
end

# Usage example
puts "=== Array-based Pointer Simulation ==="

# Create pointers
age_ptr = Pointer.new(25)
name_ptr = Pointer.new("Alice")

puts "Initial values:"
puts age_ptr
puts name_ptr

# Modify through pointers
age_ptr.value = 30
name_ptr.value = "Bob"

puts "\nAfter modification:"
puts age_ptr
puts name_ptr

# Demonstrate reference behavior
def increment_through_pointer(ptr)
  ptr.value += 1
end

puts "\nBefore increment: #{age_ptr.value}"
increment_through_pointer(age_ptr)
puts "After increment: #{age_ptr.value}"

Method 2: Object Reference Simulation

Using objects to simulate pointer behavior:

class RefPointer
  attr_reader :target, :attribute

  def initialize(target_object, attribute_name)
    @target = target_object
    @attribute = attribute_name
  end

  # Dereference
  def value
    @target.send(@attribute)
  end

  # Assignment
  def value=(new_value)
    @target.send("#{@attribute}=", new_value)
  end

  # Pointer comparison
  def ==(other)
    other.is_a?(RefPointer) && 
    @target.equal?(other.target) && 
    @attribute == other.attribute
  end

  def address
    "#{@target.object_id}:#{@attribute}"
  end

  def to_s
    "RefPointer[#{address}] -> #{value}"
  end
end

# Example usage with a person class
class Person
  attr_accessor :name, :age, :email

  def initialize(name, age, email)
    @name = name
    @age = age
    @email = email
  end

  def to_s
    "Person(#{@name}, #{@age}, #{@email})"
  end
end

puts "\n=== Object Reference Pointer Simulation ==="

person = Person.new("Alice", 25, "[email protected]")
puts "Original person: #{person}"

# Create pointers to different attributes
name_ptr = RefPointer.new(person, :name)
age_ptr = RefPointer.new(person, :age)
email_ptr = RefPointer.new(person, :email)

puts "\nPointers created:"
puts name_ptr
puts age_ptr
puts email_ptr

# Modify through pointers
name_ptr.value = "Alice Smith"
age_ptr.value = 26
email_ptr.value = "[email protected]"

puts "\nAfter modification through pointers:"
puts "Person: #{person}"
puts name_ptr
puts age_ptr
puts email_ptr

Method 3: Advanced Pointer Simulation with Memory-like Behavior

For a more sophisticated simulation that mimics C pointers more closely:

class MemorySimulator
  def initialize
    @memory = {}
    @next_address = 0x1000
  end

  def allocate(value)
    address = @next_address
    @memory[address] = value
    @next_address += 8  # Simulate 8-byte alignment
    CPointer.new(address, self)
  end

  def read(address)
    @memory[address]
  end

  def write(address, value)
    @memory[address] = value
  end

  def addresses
    @memory.keys.sort
  end

  def dump
    puts "Memory dump:"
    @memory.each do |addr, value|
      puts sprintf("0x%04x: %s", addr, value.inspect)
    end
  end
end

class CPointer
  attr_reader :address, :memory

  def initialize(address, memory_simulator)
    @address = address
    @memory = memory_simulator
  end

  # Dereference operator (*)
  def *
    @memory.read(@address)
  end

  # Assignment through dereference
  def []=(offset, value)
    @memory.write(@address + offset * 8, value)
  end

  def [](offset)
    @memory.read(@address + offset * 8)
  end

  # Pointer arithmetic
  def +(offset)
    CPointer.new(@address + offset * 8, @memory)
  end

  def -(offset)
    CPointer.new(@address - offset * 8, @memory)
  end

  # Pointer comparison
  def ==(other)
    other.is_a?(CPointer) && @address == other.address
  end

  def <(other)
    @address < other.address
  end

  def >(other)
    @address > other.address
  end

  # Address display
  def to_s
    sprintf("CPointer[0x%04x] -> %s", @address, self.*.inspect)
  end

  def inspect
    to_s
  end
end

puts "\n=== Advanced C-style Pointer Simulation ==="

memory = MemorySimulator.new

# Allocate some variables
ptr1 = memory.allocate(42)
ptr2 = memory.allocate("Hello")
ptr3 = memory.allocate([1, 2, 3, 4, 5])

puts "Initial allocations:"
puts ptr1
puts ptr2
puts ptr3

# Dereference pointers
puts "\nDereferencing pointers:"
puts "ptr1 points to: #{ptr1.*}"
puts "ptr2 points to: #{ptr2.*}"
puts "ptr3 points to: #{ptr3.*}"

# Pointer arithmetic
ptr4 = ptr1 + 1
ptr4[0] = 100

puts "\nAfter pointer arithmetic and assignment:"
puts "ptr4 (ptr1 + 1): #{ptr4}"
puts "ptr4 points to: #{ptr4.*}"

memory.dump

Method 4: Simulating Function Pointers

Ruby's blocks and Proc objects naturally simulate function pointers:

class FunctionPointer
  def initialize(&block)
    @proc = block
  end

  # Call the function pointer
  def call(*args)
    @proc.call(*args)
  end

  # Allow direct invocation
  def [](*args)
    call(*args)
  end

  def address
    @proc.object_id
  end

  def to_s
    "FunctionPointer[#{address}]"
  end
end

puts "\n=== Function Pointer Simulation ==="

# Create function pointers
add_func = FunctionPointer.new { |a, b| a + b }
multiply_func = FunctionPointer.new { |a, b| a * b }
greet_func = FunctionPointer.new { |name| "Hello, #{name}!" }

puts "Function pointers created:"
puts add_func
puts multiply_func  
puts greet_func

# Use function pointers
puts "\nCalling function pointers:"
puts "add_func[5, 3] = #{add_func[5, 3]}"
puts "multiply_func[4, 7] = #{multiply_func[4, 7]}"
puts "greet_func['Alice'] = #{greet_func['Alice']}"

# Function pointer arrays (jump tables)
operations = [
  FunctionPointer.new { |a, b| a + b },
  FunctionPointer.new { |a, b| a - b },
  FunctionPointer.new { |a, b| a * b },
  FunctionPointer.new { |a, b| a / b }
]

operation_names = %w[Add Subtract Multiply Divide]

puts "\nFunction pointer array (jump table):"
operations.each_with_index do |op, i|
  result = op[10, 2]
  puts "#{operation_names[i]}: 10, 2 = #{result}"
end

Method 5: Simulating Linked Data Structures

One of the most common uses of pointers is building linked data structures:

class ListNode
  attr_accessor :data, :next_ptr

  def initialize(data)
    @data = data
    @next_ptr = nil
  end

  def to_s
    "Node[#{object_id}](#{@data}) -> #{@next_ptr ? @next_ptr.object_id : 'nil'}"
  end
end

class LinkedList
  def initialize
    @head = nil
    @size = 0
  end

  def push(data)
    new_node = ListNode.new(data)
    new_node.next_ptr = @head
    @head = new_node
    @size += 1
  end

  def pop
    return nil unless @head

    data = @head.data
    @head = @head.next_ptr
    @size -= 1
    data
  end

  def traverse(&block)
    current = @head
    while current
      yield current.data, current.object_id
      current = current.next_ptr
    end
  end

  def find(data)
    current = @head
    while current
      return current if current.data == data
      current = current.next_ptr
    end
    nil
  end

  def to_s
    result = []
    traverse { |data, addr| result << "#{data}@#{addr}" }
    "LinkedList[#{@size}]: #{result.join(' -> ')}"
  end

  def dump_structure
    puts "Linked List Structure:"
    current = @head
    index = 0
    while current
      puts "  [#{index}] #{current}"
      current = current.next_ptr
      index += 1
    end
    puts "  Total nodes: #{@size}"
  end
end

puts "\n=== Linked Data Structure Simulation ==="

list = LinkedList.new

# Build the list
%w[Alice Bob Charlie Diana].each { |name| list.push(name) }

puts "After building list:"
puts list
list.dump_structure

# Traverse and modify
puts "\nTraversing list:"
list.traverse do |data, addr|
  puts "  Visiting: #{data} at address #{addr}"
end

# Find operations
puts "\nFinding operations:"
node = list.find("Bob")
puts "Found Bob: #{node}"

node = list.find("Eve")
puts "Found Eve: #{node || 'Not found'}"

Method 6: Double Pointers (Pointer to Pointer)

Simulating double pointers for advanced operations:

class DoublePointer
  def initialize(pointer)
    @pointer_container = [pointer]
  end

  # Single dereference (*ptr)
  def *
    @pointer_container[0]
  end

  # Double dereference (**ptr)
  def **
    pointer = @pointer_container[0]
    pointer ? pointer.value : nil
  end

  # Assignment to single pointer (*ptr = new_pointer)
  def pointer=(new_pointer)
    @pointer_container[0] = new_pointer
  end

  # Assignment through double dereference (**ptr = value)
  def value=(new_value)
    pointer = @pointer_container[0]
    pointer.value = new_value if pointer
  end

  def address
    @pointer_container.object_id
  end

  def to_s
    pointer = @pointer_container[0]
    if pointer
      "DoublePointer[#{address}] -> #{pointer.address} -> #{pointer.value}"
    else
      "DoublePointer[#{address}] -> nil"
    end
  end
end

puts "\n=== Double Pointer Simulation ==="

# Create a regular pointer
original_ptr = Pointer.new(100)
puts "Original pointer: #{original_ptr}"

# Create a double pointer
double_ptr = DoublePointer.new(original_ptr)
puts "Double pointer: #{double_ptr}"

# Access through double pointer
puts "Value through double dereference: #{double_ptr.**}"

# Modify through double pointer
double_ptr.value = 200
puts "After modification through double pointer:"
puts "Original pointer: #{original_ptr}"
puts "Double pointer: #{double_ptr}"

# Change what the double pointer points to
new_ptr = Pointer.new(300)
double_ptr.pointer = new_ptr
puts "\nAfter changing pointer target:"
puts "Double pointer: #{double_ptr}"
puts "Original pointer (unchanged): #{original_ptr}"
puts "New pointer: #{new_ptr}"

Practical Applications

Application 1: Implementing a Binary Tree with Pointer-like Navigation

class TreeNode
  attr_accessor :data, :left, :right, :parent

  def initialize(data)
    @data = data
    @left = nil
    @right = nil
    @parent = nil
  end

  def leaf?
    @left.nil? && @right.nil?
  end

  def to_s
    "TreeNode(#{@data})"
  end
end

class BinaryTree
  def initialize
    @root = nil
  end

  def insert(data)
    if @root.nil?
      @root = TreeNode.new(data)
    else
      insert_recursive(@root, data)
    end
  end

  private

  def insert_recursive(node, data)
    if data < node.data
      if node.left.nil?
        node.left = TreeNode.new(data)
        node.left.parent = node
      else
        insert_recursive(node.left, data)
      end
    else
      if node.right.nil?
        node.right = TreeNode.new(data)
        node.right.parent = node
      else
        insert_recursive(node.right, data)
      end
    end
  end

  public

  def traverse_inorder(&block)
    traverse_inorder_recursive(@root, &block)
  end

  def traverse_with_pointers(&block)
    traverse_pointer_style(@root, &block)
  end

  private

  def traverse_inorder_recursive(node, &block)
    return unless node

    traverse_inorder_recursive(node.left, &block)
    yield node
    traverse_inorder_recursive(node.right, &block)
  end

  def traverse_pointer_style(current, &block)
    # Simulate pointer-style traversal
    stack = []

    while current || !stack.empty?
      # Go to leftmost node
      while current
        stack.push(current)
        current = current.left
      end

      # Process current node
      current = stack.pop
      yield current, current.parent

      # Move to right subtree
      current = current.right
    end
  end
end

puts "\n=== Binary Tree with Pointer Navigation ==="

tree = BinaryTree.new
[50, 30, 70, 20, 40, 60, 80].each { |value| tree.insert(value) }

puts "In-order traversal with pointer information:"
tree.traverse_with_pointers do |node, parent|
  parent_info = parent ? "parent: #{parent.data}" : "parent: nil (root)"
  puts "  #{node.data} (#{parent_info})"
end

Application 2: Memory Pool Simulation

class MemoryPool
  def initialize(size)
    @pool = Array.new(size)
    @free_list = (0...size).to_a
    @allocated = {}
  end

  def allocate
    return nil if @free_list.empty?

    address = @free_list.shift
    @allocated[address] = true
    PoolPointer.new(address, self)
  end

  def deallocate(pointer)
    address = pointer.address
    if @allocated[address]
      @pool[address] = nil
      @allocated.delete(address)
      @free_list.push(address)
      @free_list.sort!
      true
    else
      false
    end
  end

  def read(address)
    @pool[address]
  end

  def write(address, value)
    @pool[address] = value if @allocated[address]
  end

  def stats
    {
      total_size: @pool.size,
      allocated: @allocated.size,
      free: @free_list.size,
      fragmentation: @free_list.size > 0 ? (@free_list.max - @free_list.min + 1 - @free_list.size) : 0
    }
  end

  def dump
    puts "Memory Pool State:"
    @pool.each_with_index do |value, index|
      status = @allocated[index] ? "ALLOC" : "FREE"
      puts sprintf("  [%3d] %-8s %s", index, status, value.inspect)
    end
    puts "Stats: #{stats}"
  end
end

class PoolPointer
  attr_reader :address, :pool

  def initialize(address, pool)
    @address = address
    @pool = pool
  end

  def value
    @pool.read(@address)
  end

  def value=(new_value)
    @pool.write(@address, new_value)
  end

  def free
    @pool.deallocate(self)
  end

  def to_s
    "PoolPointer[#{@address}] -> #{value.inspect}"
  end
end

puts "\n=== Memory Pool Simulation ==="

pool = MemoryPool.new(10)

# Allocate some pointers
ptrs = []
5.times do |i|
  ptr = pool.allocate
  ptr.value = "Data #{i}"
  ptrs << ptr
  puts "Allocated: #{ptr}"
end

puts "\nPool state after allocation:"
pool.dump

# Free some pointers
puts "\nFreeing every other pointer:"
ptrs.each_with_index do |ptr, i|
  if i.even?
    puts "Freeing: #{ptr}"
    ptr.free
  end
end

puts "\nPool state after partial deallocation:"
pool.dump

# Allocate again to show reuse
puts "\nAllocating new pointers:"
2.times do |i|
  ptr = pool.allocate
  ptr.value = "New Data #{i}"
  puts "Allocated: #{ptr}"
end

puts "\nFinal pool state:"
pool.dump

Performance Considerations

When simulating pointers in Ruby, consider these performance implications:

Memory Overhead

require 'benchmark'

def benchmark_pointer_methods
  puts "\n=== Performance Comparison ==="

  n = 100_000

  Benchmark.bm(20) do |x|
    x.report("Direct access:") do
      values = Array.new(n) { |i| i }
      sum = 0
      values.each { |v| sum += v }
    end

    x.report("Array pointers:") do
      pointers = Array.new(n) { |i| Pointer.new(i) }
      sum = 0
      pointers.each { |p| sum += p.value }
    end

    x.report("Object references:") do
      objects = Array.new(n) { |i| OpenStruct.new(value: i) }
      sum = 0
      objects.each { |o| sum += o.value }
    end
  end
end

benchmark_pointer_methods

Memory Usage Analysis

def analyze_memory_usage
  puts "\n=== Memory Usage Analysis ==="

  # Measure object creation overhead
  direct_values = []
  pointer_values = []

  1000.times do |i|
    direct_values << i
    pointer_values << Pointer.new(i)
  end

  puts "Direct values object_id range: #{direct_values.map(&:object_id).minmax}"
  puts "Pointer objects object_id range: #{pointer_values.map(&:object_id).minmax}"
  puts "Average object_id difference (pointer overhead): #{
    (pointer_values.map(&:object_id).sum - direct_values.map(&:object_id).sum) / 1000.0
  }"
end

analyze_memory_usage

Best Practices and Common Pitfalls

Best Practices

Use pointer simulation sparingly: Ruby's object model usually provides better alternatives
Prefer composition over simulation: Use Ruby's native object references when possible
Document pointer-like behavior: Make it clear when objects behave like pointers
Consider thread safety: Ruby's GIL helps, but pointer-like objects can still cause issues

Common Pitfalls

def demonstrate_common_pitfalls
  puts "\n=== Common Pitfalls ==="

  # Pitfall 1: Forgetting Ruby's object semantics
  puts "1. Object identity vs. value equality:"
  ptr1 = Pointer.new([1, 2, 3])
  ptr2 = Pointer.new([1, 2, 3])

  puts "ptr1.value == ptr2.value: #{ptr1.value == ptr2.value}"  # true
  puts "ptr1.value.equal?(ptr2.value): #{ptr1.value.equal?(ptr2.value)}"  # false

  # Pitfall 2: Circular references
  puts "\n2. Circular references (potential memory leak):"
  node1 = { data: "A", next: nil }
  node2 = { data: "B", next: nil }
  node1[:next] = node2
  node2[:next] = node1  # Circular reference!

  puts "Created circular reference between nodes"

  # Pitfall 3: Modifying shared state
  puts "\n3. Unintended shared state modification:"
  shared_array = [1, 2, 3]
  ptr_a = Pointer.new(shared_array)
  ptr_b = Pointer.new(shared_array)

  puts "Before modification: ptr_a.value = #{ptr_a.value}"
  ptr_b.value << 4
  puts "After ptr_b modification: ptr_a.value = #{ptr_a.value}"
  puts "Both pointers affected by shared state change!"
end

demonstrate_common_pitfalls

Conclusion

While Ruby doesn't have true pointers like C, we can simulate pointer-like behavior using various techniques ranging from simple array containers to sophisticated memory simulators. Each approach has its own trade-offs:

Array containers: Simple and lightweight, good for basic reference simulation
Object references: Natural Ruby way, leverages the object model
Memory simulators: Most C-like, but with significant overhead
Function pointers: Ruby's blocks and Proc objects are actually superior to C function pointers

The key is understanding when pointer simulation adds value versus when Ruby's native object model provides a better solution. Use these techniques when you need:

Educational purposes or porting C algorithms
Specific indirection patterns
Custom memory management simulation
Advanced data structure implementations

Remember that Ruby's strength lies in its high-level abstractions, and pointer simulation should be used judiciously to complement, not replace, Ruby's natural object-oriented approach.

Whether you're coming from C and missing pointers, or you're a Ruby developer curious about low-level concepts, understanding both the power and limitations of pointer simulation will make you a more well-rounded programmer in both languages.

DEV Community