Gist 10288187

100%

✓ Published0🌍 Public

Last edited Apr 9, 2014

Created on Apr 9, 2014

This example demonstrates the importance of bounds checking in C++ vector access. It uses the `std::vector` class and its `.at()` method, which throws an exception when the given index is out of range, in contrast to the unchecked `[]` operator. A loop iterates from zero to four over a vector containing three integers, triggering an out-of-range error that is caught by an `exception` handler. The code also shows a custom destructor message when a `Foo` object, managed via `make_shared`, is cleaned up.

AI-generated description

Similar vizzes

Loading thumbnail…

C++ abuse: simple example

This example demonstrates the dangerous consequences of low-level memory manipulation in C++, where swapping an object’s vtable pointer with another object’s changes its runtime behavior. The code uses raw `void*` casts and pointer arithmetic in the `transmigrate` and `brain_damage` functions to overwrite the virtual function table entries of a `Dog` object with those of a `Cat`, causing the program to call the wrong virtual methods. The output sequence—showing `Dog::food()` initially, then `Cat::food()` after the swap, and finally undefined behavior after the vtable corruption—illustrates how such manual pointer juggling bypasses type safety and virtual dispatch. The example relies solely on standard C++ features like virtual functions, inheritance, and explicit pointer casts, with no external libraries.

FFranklin Chen

55% match

Loading thumbnail…

Gist 598a74e0cb4c65102232

This example demonstrates a C++ program that first simulates traversal and deletion of nodes in a singly linked list, printing the values as it moves and removes each node, and then reads a board from the file `board.txt` into a 2D vector of characters. The rendering shows the board as a grid, printing each cell with its indices and value, and then updates two specific positions to display a modified board. The code relies on standard C++ libraries such as `<iostream>`, `<fstream>`, and `<vector>`, with no external visualization APIs.

NN0taN3rd

53% match

Loading thumbnail…

Gist 40a7b304a32e2e0db885

This example visualizes a peg-based board game using C++ with standard libraries including iostream, fstream, vector, and unordered_map. It defines classes for pegs, board spots, and players, tracking movement through a pegMove structure with coordinates and begin/end flags. The code renders board positions as characters and supports multiple peg colors (blue, green, red, big blue) with distinct identifiers. It demonstrates object-oriented design for game state management, including move tracking, occupancy checks, and position resets, though it does not include any graphics or plotting libraries, appearing to be a logical simulation rather than a visual data display.

NN0taN3rd

49% match

Loading thumbnail…

Shared via Rust Playground

This example demonstrates how multiple threads can safely share and mutate a counter using Rust’s concurrency primitives. It shows the `Arc<Mutex<Toaster>>` pattern, where an atomic mutex lock protects the `count` field from race conditions. The code spawns three threads via `thread::spawn`, each cloning the `Arc` handle and acquiring the lock with `toaster.lock().unwrap()` before incrementing the count. The output prints each thread’s index, which is assigned from the prior value of `count` before incrementing. The example uses the standard library’s `std::sync::{Arc, Mutex}` and `std::thread` APIs, with no external data source or rendering—purely console output.

FFranklin Chen

48% match

Loading thumbnail…

Gist 174550b27bb8df39e57baa2bc01e6314

This example demonstrates a custom C++ operator overloading trick that redefines `operator<<` for a `print` class, causing two instances of `print` to mimic the behavior of `std::cout` when used with the insertion syntax. The code defines a class `print` with an integer member `a` and a member function that overloads the shift operator to output the value of `a` to the standard output stream. It references a Stack Overflow discussion on modifying `std::cout` behavior. A global `print` object is instantiated with `a` set to 1, and then the overloaded operator is invoked with `obj<<obj`, printing the value 1 to the console.

MMistyBlunch

48% match

Loading thumbnail…

Gist 5ef57ecbfb116e6b42706fb6a30b0987

This example demonstrates a common JavaScript scoping pitfall with the `var` keyword, contrasting it with `let`. It shows that declaring multiple variables in a single statement like `var i, r = 0;` only initializes the last variable (`r`), leaving `i` as `undefined`. Consequently, while loops testing `i < 10` never execute, while loops on `r` run ten times, printing "chau". The visualization, presented as a code gist, uses plain JavaScript console output via `console.log` within `while` loops, relying on the browser's or Node.js runtime rather than any external libraries. The gist highlights the importance of explicit initialization for each variable.

MMistyBlunch

46% match

Loading thumbnail…

Most basic inheritance in C

This example contrasts the most basic inheritance pattern in C and C++ by displaying side-by-side source code. It shows how C++ uses virtual functions and classes to achieve runtime polymorphism, while C relies on manual vtable structs and function pointers to mimic the same behavior. The visualization highlights the structural differences in API design, such as C++’s `virtual` keyword and `class` syntax versus C’s explicit `Animal_vtable` and cast function pointers. The code’s output—identical for both languages—is implied through the `printf` and `cout` calls, but no rendering library is used; the data is the source itself.

FFranklin Chen

46% match

Loading thumbnail…

find a thread safety bug

This example demonstrates a subtle thread-safety bug in a C# .NET console application. Two `ThreadUnsafe` instances execute a `Go()` method concurrently across 10,000 iterations, with a shared static `_val2` flag reset after each attempt. The code uses the `lock` keyword on a `syncObj` to guard the division `_val1/_val2`, but the assignment `_val2 = 0` occurs outside the lock. The visualization—rendered via console output—shows the iteration index and an `AggregateException` when a race condition triggers an arithmetic error, revealing the unprotected write that breaks the intended synchronization.

RRestuta

46% match