C++: Production Code Snippets

C++ patterns: memory management, multithreading, allocation-free data structures.

Python JavaScript TypeScript Java C# C++ Go PHP Rust SQL

On this page:

26. C++: Smart Pointers 27. C++: Multithreaded Thread Pool 28. C++: Efficient CSV Tokenizer 29. C++: Lock-free Ring Buffer 30. C++: Logging System with Macros

26. C++: Smart Pointers

C++

Safe use of std::unique_ptr and std::shared_ptr.

#include <memory>

class Node {
public:
    int value;
    std::shared_ptr<Node> next;
    Node(int val) : value(val) {}
};

void createList() {
    auto head = std::make_shared<Node>(10);
    head->next = std::make_shared<Node>(20);
}

When to use

Use it instead of raw pointers wherever you manage dynamic memory — it eliminates most memory leaks.

Common pitfalls

Circular references between shared_ptr objects (e.g. parent-child) cause memory leaks — a weak_ptr is needed in such cases.

27. C++: Multithreaded Thread Pool

C++

A task queue based on std::mutex and condition_variable.

#include <vector>
#include <thread>
#include <queue>
#include <mutex>

class SimplePool {
    std::vector<std::thread> workers;
    std::queue<std::function<void()>> tasks;
    std::mutex queue_lock;
};

When to use

Useful for processing many independent tasks in parallel without spawning a new thread for each one.

Common pitfalls

The class skeleton alone isn't enough — you also need synchronization logic (condition_variable) to wake threads waiting for tasks.

28. C++: Efficient CSV Tokenizer

C++

Fast processing of large text files without allocation.

#include <sstream>
#include <string>
#include <vector>

std::vector<std::string> split(const std::string&s, char delimiter) {
    std::vector<std::string> tokens;
    std::string token;
    std::stringstream tokenStream(s);
    while (std::getline(tokenStream, token, delimiter)) {
        tokens.push_back(token);
    }
    return tokens;
}

When to use

Useful for quickly parsing simple text files without pulling in an external CSV library.

Common pitfalls

This solution doesn't correctly handle quoted fields containing commas (typical for CSV) — full standard compliance needs a more elaborate parser.

29. C++: Lock-free Ring Buffer

C++

A circular buffer for low-overhead inter-thread communication.

#include <atomic>
#include <vector>

template<typename T, size_t Size>
class RingBuffer {
    T data[Size];
    std::atomic<size_t> head{0};
    std::atomic<size_t> tail{0};
};

When to use

Use it for inter-thread communication with high performance requirements, e.g. in real-time or audio systems.

Common pitfalls

Lock-free programming is exceptionally prone to subtle concurrency bugs — test thoroughly on multi-core hardware, not just locally.

30. C++: Logging System with Macros

C++

Conditional log compilation depending on debug flags.

#include <iostream>

#ifdef DEBUG_MODE
    #define LOG(msg) std::cout << "[DEBUG] " << msg << std::endl;
#else
    #define LOG(msg)
#endif

When to use

Useful for debug logs you want to strip entirely from the production build with no performance impact.

Common pitfalls

Macros aren't namespace-aware and can collide with other symbols of the same name — a real logging library works better in larger projects.