C++
उत्सुकता से आवर्ती टेम्पलेट पैटर्न (CRTP)

मान लें कि आपके पास कंटेनरों का एक सेट है जो सभी कार्यों को begin() और end() समर्थन करता है। कंटेनरों के लिए मानक पुस्तकालय की आवश्यकताओं को अधिक कार्यक्षमता की आवश्यकता होती है। हम एक CRTP बेस क्लास डिजाइन कर सकते हैं जो कि कार्यक्षमता प्रदान करता है, जो केवल begin() और end() पर आधारित है:

#include <iterator>
template <typename Sub>
class Container {
  private:
    // self() yields a reference to the derived type
    Sub& self() { return *static_cast<Sub*>(this); }
    Sub const& self() const { return *static_cast<Sub const*>(this); }

  public:
    decltype(auto) front() {
      return *self().begin();
    }

    decltype(auto) back() {
      return *std::prev(self().end());
    }

    decltype(auto) size() const {
      return std::distance(self().begin(), self().end());
    }

    decltype(auto) operator[](std::size_t i) {
      return *std::next(self().begin(), i);
    }
};

उपरोक्त वर्ग किसी भी उपवर्ग के लिए कार्य front() , back() , size() , और operator[] प्रदान करता है जो begin() और end() प्रदान करता है। एक उपवर्ग एक सरल गतिशील रूप से आवंटित सरणी है:

#include <memory>
// A dynamically allocated array
template <typename T>
class DynArray : public Container<DynArray<T>> {
  public:
    using Base = Container<DynArray<T>>;

    DynArray(std::size_t size)
      : size_{size},
      data_{std::make_unique<T[]>(size_)}
    { }

    T* begin() { return data_.get(); }
    const T* begin() const { return data_.get(); }
    T* end() { return data_.get() + size_; }
    const T* end() const { return data_.get() + size_; }

  private:
    std::size_t size_;
    std::unique_ptr<T[]> data_;
};

DynArray वर्ग के उपयोगकर्ता CRTP बेस क्लास द्वारा दिए गए इंटरफेस का उपयोग आसानी से कर सकते हैं:

DynArray<int> arr(10);
arr.front() = 2;
arr[2] = 5;
assert(arr.size() == 10);

उपयोगिता: यह पैटर्न विशेष रूप से रन-टाइम पर वर्चुअल फंक्शन कॉल से बचा जाता है जो कि वंशानुगत पदानुक्रम को कम करने के लिए होता है और बस स्थैतिक जातियों पर निर्भर करता है:

DynArray<int> arr(10);
DynArray<int>::Base & base = arr;
base.begin(); // no virtual calls

फंक्शन के अंदर एकमात्र स्टैटिक कास्ट begin() बेस क्लास Container<DynArray<int>> में कंपाइलर कोड को काफी ऑप्टिमाइज़ करने की अनुमति देता है और रनटाइम के दौरान कोई वर्चुअल टेबल नहीं दिखता है।

सीमाएँ: क्योंकि बेस क्लास को अलग किया जाता है और दो अलग-अलग DynArray लिए अलग-अलग है। यह संभव नहीं है कि टाइप-समरूप सरणी में अपने बेस कक्षाओं में पॉइंटर्स को स्टोर किया जा सके, क्योंकि आम तौर पर सामान्य वंशानुक्रम जहां बेस क्लास व्युत्पन्न पर निर्भर नहीं होता है प्रकार:

class A {};
class B: public A{};

A* a = new B;