Does C++11's decltype make clone unnecessary?

The clone paradigm is used to make a copy of a derived class without casting down to the base class type. Unfortunately, `clone` must be implemented in each subclass (or with a mixin with CRTP). Is there any chance that C++11's `decltype` makes this unnecessary? I don't think the code below actually copies `original`, but simply points a reference to it. When I tried to use `new decltype(*original)`, I get an error: `error: new cannot be applied to a reference type`. Is `clone` still the way to go in C++11? Or is there some new way to use RTTI to copy a derived class object from a base class pointer? ``` #include <iostream> struct Base { virtual void print() { std::cout << "Base" << std::endl; } }; struct Derived : public Base { int val; Derived() {val=0;} Derived(int val_param): val(val_param) {} virtual void print() { std::cout << "Derived " << val << std::endl; } }; int main() { Base * original = new Derived(1); original->print(); // copies by casting down to Base: you need to know the type of *original Base * unworking_copy = new Base(*original); unworking_copy->print(); decltype(*original) on_stack = *original; on_stack.print(); return 0; } ```