Vermeille · November 14, 2017 14:09
diff --git a/structural_polymorphism.cpp b/structural_polymorphism.cpp
 #include <iostream>
 #include <memory>
 #include <vector>

 /*
 * This snippet is demonstrating a powerful technique enabling local and
 * concept-based polymorphism. Think of it as interfaces on steroids:
 * They're local, non intrusive, which means you don't have to think of them
 * ahead, they don't make virtual calls when you don't want to use them, etc.
 *
 * Those are kinda one shot local interface inheritance and polymorphism.
 *
 * With black magic, it's even possible to reunite with the same interface
 * different functions, like reunite Print(), Show(), operator<<() under a
 * Printable trait. But those are dark arcanes that can be used only by
 * summoning Cthulhu and that I'd explain only if asked.
 *
 * In the same way, with some more black magic, the boiler plate code can be
 * reduced, but your soul has to be sold to Satan AND Cthulhu AND Quetzacoatl.
 * With a sample of your blood. (Or you can use macros, which just requires to
 * give up on your dignity)
 *
 * Credits: Sean Parent.
 */

 // Our toy classes. No common interface.
 struct A {
    void Print() const { std::cout << "I'm A!\n"; }
 };
 struct B {
    void Print() const { std::cout << "I'm B!\n"; }
 };

 // Our trait:
 struct Printable {
    template <class T>
    Printable(T&& x)
        : base_(std::make_unique<Printable_<T>>(std::forward<T>(x))) {}

    void Print() const { base_->Print(); }

    struct Base {
        virtual void Print() const = 0;
    };

    template <class T>
    struct Printable_ : public Base {
        template <class U>
        Printable_(U&& x) : x_(std::forward<U>(x)) {}

        void Print() const override { x_.Print(); }
        T x_;
    };
    std::unique_ptr<Base> base_;
 };

 int main() {
    // Tadaaam, store them in a vec as if they both inherited from the same
    // interface.
    std::vector<Printable> ps;
    ps.emplace_back(A());
    ps.emplace_back(A());
    ps.emplace_back(A());
    ps.emplace_back(B());
    ps.emplace_back(B());
    ps.emplace_back(A());
    for (auto& p : ps) {
        p.Print();
    }
    return 0;
 }
	#include <iostream>
	#include <memory>
	#include <vector>

	/*
	* This snippet is demonstrating a powerful technique enabling local and
	* concept-based polymorphism. Think of it as interfaces on steroids:
	* They're local, non intrusive, which means you don't have to think of them
	* ahead, they don't make virtual calls when you don't want to use them, etc.
	*
	* Those are kinda one shot local interface inheritance and polymorphism.
	*
	* With black magic, it's even possible to reunite with the same interface
	* different functions, like reunite Print(), Show(), operator<<() under a
	* Printable trait. But those are dark arcanes that can be used only by
	* summoning Cthulhu and that I'd explain only if asked.
	*
	* In the same way, with some more black magic, the boiler plate code can be
	* reduced, but your soul has to be sold to Satan AND Cthulhu AND Quetzacoatl.
	* With a sample of your blood. (Or you can use macros, which just requires to
	* give up on your dignity)
	*
	* Credits: Sean Parent.
	*/

	// Our toy classes. No common interface.
	struct A {
	void Print() const { std::cout << "I'm A!\n"; }
	};
	struct B {
	void Print() const { std::cout << "I'm B!\n"; }
	};

	// Our trait:
	struct Printable {
	template <class T>
	Printable(T&& x)
	: base_(std::make_unique<Printable_<T>>(std::forward<T>(x))) {}

	void Print() const { base_->Print(); }

	struct Base {
	virtual void Print() const = 0;
	};

	template <class T>
	struct Printable_ : public Base {
	template <class U>
	Printable_(U&& x) : x_(std::forward<U>(x)) {}

	void Print() const override { x_.Print(); }
	T x_;
	};
	std::unique_ptr<Base> base_;
	};

	int main() {
	// Tadaaam, store them in a vec as if they both inherited from the same
	// interface.
	std::vector<Printable> ps;
	ps.emplace_back(A());
	ps.emplace_back(A());
	ps.emplace_back(A());
	ps.emplace_back(B());
	ps.emplace_back(B());
	ps.emplace_back(A());
	for (auto& p : ps) {
	p.Print();
	}
	return 0;
	}