Полиморфизм на основе стирания типа

 #include <iostream>  
 #include <vector>  
   
 class ConcreteStream1 {  
 private:  
   friend class IStream;  
   
   inline void foo() {   
     std::cout << "ConcreteStream1::foo" << std::endl;   
   }   
 };  
   
 class ConcreteStream2 {  
 private:  
   friend class IStream;  
   
   inline void foo() {   
     std::cout << "ConcreteStream2::foo" << std::endl;   
   }   
 };  
   
 class IStream {  
 public:  
   IStream(ConcreteStream1&& concreteStream1)  
   : streamType(StreamType::ConcreteStream1),  
    storage(Storage(std::forward<ConcreteStream1>(concreteStream1))) {}  
     
   IStream(ConcreteStream2&& concreteStream2)  
   : streamType(StreamType::ConcreteStream2),  
    storage(Storage(std::forward<ConcreteStream2>(concreteStream2))) {}  
   
   inline void foo() {  
     switch (streamType) {  
       case StreamType::ConcreteStream1:  
         storage.concreteStream1.foo();  
         break;  
       case StreamType::ConcreteStream2:  
         storage.concreteStream2.foo();  
         break;  
     }  
   }  
     
 private:  
   enum class StreamType {  
     ConcreteStream1,  
     ConcreteStream2,  
   };  
   
 private:  
   StreamType streamType;  
   union Storage{  
     Storage(ConcreteStream1&& concreteStream1)   
     : concreteStream1(std::move(concreteStream1)) {}  
     Storage(ConcreteStream2&& concreteStream2)   
     : concreteStream2(std::move(concreteStream2)) {}  
   
     ConcreteStream1 concreteStream1;  
     ConcreteStream2 concreteStream2;   
   } storage;  
 };  
   
 int main() {  
   std::vector<IStream> streams = { ConcreteStream1{}, ConcreteStream2{} };  
   
   streams[0].foo();  
   streams[1].foo();  
   
   return 0;   
 }  

Динамический полиморфизм vs Статический полиморфизм

Динамический полиморфизм

 #include <iostream>  
   
 class IStream {  
 public:  
   virtual ~IStream() = default;  
   virtual void foo() = 0;  
 };  
   
 class Stream : public IStream {  
 public:  
   void foo() override {  
     std::cout << "Stream::foo" << std::endl;  
   }  
 };  
   
 int main() {  
   IStream* stream = new Stream;  
   stream->foo();  
     
   return 0;   
 }  

Статический полиморфизм

 #include <iostream>  
   
 template<typename Stream>  
 class IStream : public Stream {  
 public:  
   inline void foo() {  
     return static_cast<Stream*>(this)->foo();  
   }  
 };   
   
 class Stream {  
 private:  
   friend class IStream<Stream>;  
     
   inline void foo() {  
     std::cout << "Stream::foo" << std::endl;  
   }  
 };  
     
 int main() {  
   IStream<Stream> stream;  
   stream.foo();  
   
   return 0;   
 }