Top 7 most used C++ idioms (Part2).

In the first part we discovered the RAII and Pimpl idioms, and in this second part, we will explore the CRTP, Copy-and-Swap, and Type Erasure idioms.

But before talking about these interesting idioms, let’s first discover the benefits of mastering C++ idioms and why it’s worth investing time to understand how they work:

  1. Expressiveness: Idioms allow developers to express common design patterns and solutions concisely and clearly within the syntax of the language. By leveraging language-specific features and conventions, idioms can make code more readable and self-explanatory.
  2. Performance: Language-specific idioms often leverage language features optimized for performance. For example, in C++, idioms like RAII (Resource Acquisition Is Initialization) leverage constructors and destructors to manage resources efficiently, reducing the likelihood of resource leaks and improving performance.
  3. Safety and Reliability: Idioms can enforce best practices and safety measures specific to the language. For instance, in languages like Rust, ownership and borrowing idioms enforce memory safety at compile time, preventing common pitfalls such as null pointer dereferencing and data races.
  4. Compatibility: Idioms often align with the conventions and idiomatic style of the language community. Adhering to idiomatic practices makes code more compatible with existing libraries, frameworks, and coding standards, promoting interoperability and collaboration among developers.
  5. Maintainability: By following language-specific idioms and conventions, code becomes more consistent and predictable. This facilitates code maintenance, debugging, and refactoring, as developers familiar with the language can quickly understand and reason about idiomatic code.
  6. Performance Optimization: Idioms in languages like C++ and Rust enable performance optimizations by leveraging language features such as move semantics, compile-time polymorphism, and zero-cost abstractions. By using idiomatic constructs, developers can write efficient code without sacrificing readability or maintainability.
  7. Tooling Support: Language-specific idioms often benefit from dedicated tooling and static analysis tools tailored to the language’s syntax and semantics. These tools can help identify and enforce idiomatic patterns, detect potential issues, and provide automated refactorings to align code with best practices.

In summary, idioms in a specific programming language offer benefits such as expressiveness, performance, safety, compatibility, maintainability, performance optimization, and tooling support. By following idiomatic practices, developers can write code that is efficient, reliable, and easy to maintain within the context of the language ecosystem.

Let’s continue exploring our 7 idioms:

3- Curiously Recurring Template Pattern (CRTP)

The Curiously Recurring Template Pattern (CRTP) is an advanced template-based design pattern in C++. It is a technique that involves using inheritance and static polymorphism to achieve a form of compile-time polymorphism. Indeed the CRTP allows for compile-time optimization and inlining of code since the method calls are resolved at compile time. It also eliminates the runtime overhead associated with virtual function calls, making it suitable for performance-critical code.

The CRTP is commonly used in libraries and frameworks for tasks such as implementing mixin classes, static interfaces, and type-safe callback mechanisms. It is also used in some design patterns, such as the Curiously Recurring Template Singleton Pattern (CRSP), which employs CRTP to implement singletons.

Here’s a simple example demonstrating the CRTP:

template <typename Derived>
class Base {
    void commonFunction() {
        // Base class implementation
        static_cast<Derived*>(this)->specificFunction(); // Call derived class method

    // Virtual destructor to ensure correct destruction
    virtual ~Base() = default;

class DerivedClass : public Base<DerivedClass> {
    void specificFunction() {
        // Derived class implementation
        // ...

int main() {
    DerivedClass d;
    d.commonFunction(); // Calls both base and derived class methods
    return 0;

In this example, Base is a template class that serves as the base class, and DerivedClass inherits from Base with itself as the template argument. Base contains a method commonFunction() that calls specificFunction() defined in the derived class. When an instance of DerivedClass calls commonFunction(), it invokes both the base class’s and the derived class’s implementations.

To resume here’s a brief overview of how the CRTP works:

  1. Basic Structure: In the CRTP, a base class template is defined with a template parameter representing the derived class. The derived class then inherits from the base class and provides its own type as the template argument.
  2. Implementation: The base class template typically contains methods or members that depend on the derived class’s functionality. These methods or members can call methods defined in the derived class using static polymorphism.
  3. Usage: The derived class provides its own implementation of the methods required by the base class template. This allows the derived class to customize the behavior of the base class methods while still benefiting from the common functionality provided by the base class.

4-Copy-and-swap Idiom

The Copy and Swap idiom is a C++ programming technique used to implement the copy assignment operator and ensure strong exception safety guarantees. It involves swapping the contents of the current object with a copy of the object being assigned, thereby providing a robust and exception-safe way to perform assignments.

Here’s how the Copy and Swap idiom works:

  1. Define a Swap Function: First, you need to define a swap function for your class. This function swaps the internal state of the current object with the internal state of another object of the same type.
  2. Implement the Copy Assignment Operator: Implement the copy assignment operator (operator=) for your class. Instead of performing the assignment directly, create a copy of the right-hand side object, swap its contents with the current object using the swap function, and let the copy destructors clean up the swapped contents.
  3. Exception Safety: Since the swap operation and destruction of temporary objects are performed within the copy assignment operator, any exceptions thrown during the operation will leave the state of the current object unchanged. This provides the strong exception safety guarantee.

Here’s a basic example demonstrating the Copy and Swap idiom:

#include <algorithm> // For std::swap

class MyClass {
    int* data;
    size_t size;

    // Constructor
    MyClass(size_t size) : size(size), data(new int[size]) {}

    // Destructor
    ~MyClass() {
        delete[] data;

    // Copy constructor
    MyClass(const MyClass& other) : size(other.size), data(new int[other.size]) {
        std::copy(, + size, data);

    // Swap function
    friend void swap(MyClass& first, MyClass& second) noexcept {
        using std::swap;
        swap(first.size, second.size);

    // Copy assignment operator using Copy and Swap idiom
    MyClass& operator=(MyClass other) noexcept {
        swap(*this, other); // Swap contents with a copy of 'other'
        return *this;

In this example, the swap function swaps the data and size members of two MyClass objects. The copy assignment operator takes advantage of the swap function by creating a copy of the right-hand side object (other), swapping its contents with the current object (*this), and returning a reference to the current object. This ensures that the assignment is both exception-safe and efficient.

However, In C++11 the new move feature. The copy-swap idiom and move semantics are both techniques used in C++ for managing the copying and moving of objects, but they serve different purposes and have different implementations.

  1. Copy-Swap Idiom:
  • The copy-swap idiom is a programming technique used to implement copy assignment operators in C++. It involves creating a copy of the object to be assigned, then swapping the contents of the current object with the copy.
  • The copy constructor creates a copy of the object to be assigned, ensuring that modifications to the original object do not affect the new object. The swap operation then exchanges the contents of the current object with the copied object.
  • This technique provides strong exception safety guarantees because the swap operation is typically implemented using no-throw operations.
  • While the copy-swap idiom ensures robustness and safety, it may incur unnecessary overhead if the object being copied is large or expensive to copy.
  1. Move Semantics:
  • Move semantics is a feature introduced in C++11 that allows objects to be moved from one location to another efficiently. It enables the transfer of resources, such as dynamically allocated memory or file handles, from temporary objects or rvalue references to other objects.
  • Unlike copying, moving involves transferring ownership of resources from one object to another without creating a copy. This can result in significant performance improvements, especially for large or expensive-to-copy objects.
  • Move semantics are implemented using move constructors and move assignment operators, which are used to efficiently transfer the resources of temporary objects or rvalue references.
  • Move semantics are particularly useful in situations where copying objects is expensive or unnecessary, such as when returning objects from functions or passing objects by value.

In summary, the copy-swap idiom and move semantics are complementary techniques used in C++ for managing object copying and moving. The copy-swap idiom provides strong exception safety guarantees but may incur overhead for large objects, while move semantics offer efficiency improvements by enabling the transfer of resources between objects without copying. Depending on the specific requirements and characteristics of the objects involved, developers can choose between these techniques to achieve the desired balance between safety and performance.

5-Type Erasure Idiom

Type erasure is a design pattern in C++ that allows for the implementation of polymorphic behavior without using virtual functions or inheritance. It enables the creation of generic interfaces and containers that can operate on objects of different types, providing type safety and flexibility. The type erasure idiom is particularly useful when dealing with heterogeneous collections or when the exact types of objects are not known at compile time.

The basic idea behind type erasure is to encapsulate objects of different types behind a common interface, hiding their specific types and allowing them to be treated uniformly. This is typically achieved using templates and dynamic polymorphism.

Here’s a high-level overview of how type erasure works in C++:

  1. Define a Conceptual Interface: Start by defining a conceptual interface that represents the common behavior or operations that objects of different types should support. This interface is often expressed using templates or abstract classes.
  2. Implement Type-Erased Wrapper: Create a type-erased wrapper class or template that can hold objects of different types but presents them through the common interface defined in step 1. This wrapper class usually uses dynamic memory allocation and polymorphism internally to store and manipulate objects of varying types.
  3. Use Type-Erased Objects: Use instances of the type-erased wrapper class in your code wherever polymorphic behavior is needed. Since the wrapper presents a uniform interface, you can call methods and access properties without knowing the exact underlying types.
  4. Dealing with Type Information: Optionally, provide mechanisms to query or retrieve type information from the type-erased objects, such as runtime type identification (RTTI) or custom mechanisms for type introspection.
  5. Benefits of Type Erasure: Type erasure provides flexibility and type safety by allowing heterogeneous collections and generic algorithms to be implemented without sacrificing performance or introducing complex inheritance hierarchies. It decouples the interface from the implementation, making it easier to maintain and extend codebases.

One common example of type erasure in C++ is the use of std::function from the C++ Standard Library. std::function can hold callable objects of different types (e.g., functions, lambdas, function objects) but presents them through a common interface, allowing them to be invoked uniformly.

Type erasure is a powerful and versatile technique in C++, but it may introduce some overhead due to dynamic memory allocation and virtual function calls. As with any design pattern, it’s essential to consider the trade-offs and choose the right approach based on the specific requirements and constraints of your application.

Here’s a simplified example of type erasure in C++, using a type-erased wrapper to store and manipulate objects of different types through a common interface:

#include <iostream>
#include <memory> // For std::unique_ptr

// Interface representing the common behavior for all types
class Shape {
    virtual ~Shape() = default;
    virtual double area() const = 0;

// Concrete implementation of the Shape interface for a Circle
class Circle : public Shape {
    double radius;

    Circle(double r) : radius(r) {}

    double area() const override {
        return 3.14159 * radius * radius;

// Concrete implementation of the Shape interface for a Rectangle
class Rectangle : public Shape {
    double width;
    double height;

    Rectangle(double w, double h) : width(w), height(h) {}

    double area() const override {
        return width * height;

// Type-erased wrapper class to hold objects of different types
class AnyShape {
    // Pointer to the base class (Shape), allowing polymorphic behavior
    std::unique_ptr<Shape> ptr;

    // Constructor taking any object that implements the Shape interface
    template<typename T>
    AnyShape(T shape) : ptr(std::make_unique<Model<T>>(std::move(shape))) {}

    // Delegate area() method call to the underlying object
    double area() const {
        return ptr->area();

    // Private inner class (model) to hold objects of any type
    template<typename T>
    class Model : public Shape {
        T shape;

        Model(T s) : shape(std::move(s)) {}

        double area() const override {
            return shape.area();

int main() {
    // Create instances of different shapes
    Circle circle(5.0);
    Rectangle rectangle(4.0, 6.0);

    // Create type-erased wrapper objects
    AnyShape anyCircle(circle);
    AnyShape anyRectangle(rectangle);

    // Call the area() method on the type-erased objects
    std::cout << "Circle area: " << anyCircle.area() << std::endl;
    std::cout << "Rectangle area: " << anyRectangle.area() << std::endl;

    return 0;

In this example, we have an interface Shape with a pure virtual function area(), which represents the common behavior for all shapes. We then have concrete implementations of the Shape interface for Circle and Rectangle.

The AnyShape class serves as a type-erased wrapper to hold objects of different types that implement the Shape interface. It uses template metaprogramming to create an inner class (Model) for each type that is stored. This inner class delegates the area() method call to the underlying object. Finally, in the main() function, we demonstrate creating instances of different shapes, wrapping them in AnyShape objects, and calling the area() method on them uniformly.