CRTP realizes static polymorphism for derived class types through base class template parameters. 1. The base class uses the template parameter Derived to obtain derived class types, and uses static distribution to call derived class methods through static_cast; 2. All classes that inherit Cloneable automatically obtain type-safe clone() functions; 3. Advantages include virtual function overhead, high compilation period parsing performance, code reuse and type safety; 4. Notes include that derived classes must correctly inherit Base, and implement the desired methods of the base class, and cannot directly manage different derived class objects through base class pointers. This mode is widely used in high-performance libraries such as Eigen and Boost.

CRTP (Curiously Recurring Template Pattern) is a template programming technique in C. It allows a base class to "know" the type of the derived class with the derived class as a template parameter. This "singular recursive template pattern" is often used to implement static polymorphism, performance optimization (avoid virtual function overhead), and code generation.

Here is a simple CRTP example showing how to implement a common clone() function without the need for virtual functions.

? Basic CRTP example: Automatically implement clone()

 #include <iostream>
#include <memory>

// Base class template, use CRTP
template <typename Derived>
class Cloneable {
public:
    // Provide a clone interface to return the object of derived class type std::unique_ptr<Derived> clone() const {
        return std::make_unique<Derived>(static_cast<const Derived&>(*this));
    }
};

// Specific derived class MyClass: public Cloneable<MyClass> {
public:
    int value;

    MyClass(int v = 0) : value(v) {}

    void print() const {
        std::cout << "MyClass with value: " << value << std::endl;
    }
};

int main() {
    MyClass obj1(42);
    auto obj2 = obj1.clone(); // Automatically generate clone, return unique_ptr<MyClass>

    obj1.print(); // Output: MyClass with value: 42
    obj2->print(); // Output: MyClass with value: 42

    return 0;
}

? explain

• Cloneable<MyClass> is the base class of MyClass .
• The base class knows the specific type of the derived class through the template parameter Derived .
• clone() function uses static_cast to safely convert *this into a derived class reference and then constructs a new object.
• All classes that inherit Cloneable<T> automatically obtain the type-safe clone() function.

? Another common use: static polymorphism (avoid virtual functions)

 template <typename Derived>
class Shape {
public:
    void draw() const {
        // Static distribution to the derived class static_cast<const Derived*>(this)->draw();
    }

    double area() const {
        return static_cast<const Derived*>(this)->area();
    }
};

class Circle : public Shape<Circle> {
public:
    double radius;
    Circle(double r) : radius(r) {}

    void draw() const {
        std::cout << "Drawing a circle with radius " << radius << std::endl;
    }

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

class Rectangle : public Shape<Rectangle> {
public:
    double width, height;
    Rectangle(double w, double h) : width(w), height(h) {}

    void draw() const {
        std::cout << "Drawing a rectangle " << width << "x" << height << std::endl;
    }

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

Example of usage:

 int main() {
    Circle c(5.0);
    Rectangle r(3.0, 4.0);

    c.draw(); // Output: Drawing a circle with radius 5
    r.draw(); // Output: Drawing a rectangle 3x4

    std::cout << "Circle area: " << c.area() << std::endl; // 78.54
    std::cout << "Rectangle area: " << r.area() << std::endl; // 12

    return 0;
}

? Advantages

• No virtual function overhead : The call is a compilation analysis and has higher performance.
• Type safety : dynamic_cast is not required.
• Code reuse : General logic is written in the base class, and derived classes only implement interfaces.

?? Notes

• The derived class must inherit Base<derived></derived> correctly, otherwise the behavior is undefined.
• Don't forget to implement the functions you expect from the base class (such as draw() and area() ), otherwise an error will be reported during compilation.
• Different derived classes cannot be managed uniformly through base class pointers like virtual functions (unless combined with other mechanisms such as std::variant or type erasing).

Basically that's it. CRTP is a powerful idiom, commonly found in high-performance libraries (such as Eigen, Boost). Not complicated but easy to ignore.

The above is the detailed content of C CRTP example. For more information, please follow other related articles on the PHP Chinese website!