{"id":2089,"date":"2024-09-18T08:21:11","date_gmt":"2024-09-18T08:21:11","guid":{"rendered":"https:\/\/cppdepend.com\/blog\/?p=2089"},"modified":"2024-09-18T08:21:17","modified_gmt":"2024-09-18T08:21:17","slug":"c-generic-programming-from-libraries-to-core-projects","status":"publish","type":"post","link":"https:\/\/cppdepend.com\/blog\/c-generic-programming-from-libraries-to-core-projects\/","title":{"rendered":"C++ Generic Programming: From Libraries to Core Projects"},"content":{"rendered":"\n

C++ generic programming, initially popularized for creating reusable libraries like the Standard Template Library (STL), has recently seen widespread adoption in many C++ projects. The power of templates<\/strong> allows developers to write code that is flexible, reusable, and type-safe, reducing redundancy while ensuring performance. With modern C++ standards (C++11, C++17, and C++20), template programming has evolved, featuring advanced concepts like variadic templates<\/strong>, constexpr<\/strong>, and SFINAE<\/strong>, which help manage complexity. This trend has made generic programming an integral part of contemporary C++ development.<\/p>\n\n\n\n\n\n\n\n

Shifting from OOP to generics in core projects: Runtime Polymorphism to Static Polymorphism<\/strong><\/p>\n\n\n\n

Runtime polymorphism plays a crucial role in many OOP design patterns<\/strong> by allowing objects to be treated uniformly through a common interface or base class. Here’s how it is used in popular design patterns:<\/p>\n\n\n\n

    \n
  1. Strategy Pattern<\/strong>: Encapsulates algorithms in classes, allowing them to be swapped at runtime through polymorphism.<\/li>\n\n\n\n
  2. Observer Pattern<\/strong>: Allows multiple observers to react to changes in a subject, with dynamic binding of observer methods.<\/li>\n\n\n\n
  3. Factory Method Pattern<\/strong>: Returns different types of objects, which share a common interface, decided at runtime.<\/li>\n<\/ol>\n\n\n\n

    Runtime polymorphism, is implemented using inheritance<\/strong> and virtual functions<\/strong>. Here, the method to be invoked is determined at runtime using a vtable. This approach adds flexibility because the exact type doesn\u2019t need to be known until runtime, but it introduces some overhead due to virtual function lookups.<\/p>\n\n\n\n

    Example:<\/p>\n\n\n\n

    class Base {\npublic:\n    virtual void doSomething() = 0;\n};\n\nclass Derived : public Base {\npublic:\n    void doSomething() override {\n        \/\/ Implementation\n    }\n};<\/pre><\/div>\n\n\n\n
    Static polymorphism, on the other hand, is achieved through templates<\/strong> or function overloading<\/strong>, where the method to be invoked is determined at compile time. This provides better performance since there’s no overhead of function lookup at runtime. A common example is CRTP (Curiously Recurring Template Pattern)<\/strong>, which uses templates to achieve polymorphism without virtual functions.<\/p>\n\n\n\n
    Example:<\/p>\n\n\n\n
    template<typename T>\nclass Base {\n    void doSomething() {\n        static_cast<T*>(this)->doSomething();\n    }\n};<\/pre><\/div>\n\n\n\n
    Key Differences:<\/h3>\n\n\n\n