How do I eliminate virtual functions with type erasure?

In C++, type erasure is a programming technique that allows you to hide the specific type of an object at runtime, enabling polymorphism without relying on virtual functions. This approach can reduce the overhead associated with virtual functions and improve performance in certain scenarios.
C++, type erasure, virtual functions, polymorphism, performance optimization, programming techniques
// Example implementation of type erasure in C++ #include #include #include class Any { public: template Any(T value) : content(std::make_shared>(value)) {} void call() { content->call(); } private: struct Concept { virtual void call() = 0; virtual ~Concept() = default; }; template struct Holder : Concept { Holder(T value) : value(value) {} void call() override { value(); } T value; }; std::shared_ptr content; }; void exampleFunction() { std::cout << "Hello from the example function!" << std::endl; } int main() { Any a = Any(exampleFunction); a.call(); // Outputs: Hello from the example function! return 0; }

C++ type erasure virtual functions polymorphism performance optimization programming techniques

Related Questions

How do I avoid rehashing overhead with std::set in multithreaded code?

How do I find elements with custom comparators with std::set for embedded targets?

How do I erase elements while iterating with std::set for embedded targets?

How do I provide stable iteration order with std::unordered_map for large datasets?

How do I reserve capacity ahead of time with std::unordered_map for large datasets?

How do I erase elements while iterating with std::unordered_map in multithreaded code?

How do I provide stable iteration order with std::map for embedded targets?

How do I provide stable iteration order with std::map in multithreaded code?

How do I avoid rehashing overhead with std::map in performance-sensitive code?

How do I merge two containers efficiently with std::map for embedded targets?