C++26: Std:Polymorphic

always stores exactly a T. But what if you need to store a Circle or a Rectangle through a Shape base class — and copy it without slicing? That’s std::polymorphic, the other half of P3019R14. It owns a heap-allocated object whose dynamic type may be T or any type derived from T. Copying performs a type-erased deep copy that preserves the dynamic type. No virtual clone() needed." /> always stores exactly a T. But what if you need to store a Circle or a Rectangle through a Shape base class — and copy it without slicing? That’s std::polymorphic, the other half of P3019R14. It owns a heap-allocated object whose dynamic type may be T or any type derived from T. Copying performs a type-erased deep copy that preserves the dynamic type. No virtual clone() needed." /> C++26: std::polymorphic | Sandor Dargo's Blog Sandor Dargo's Blog On C++, software development and books

HOME TAGS ARCHIVES BOOKS SPEAKING DAILY C++ WORKSHOPS HI... SUBSCRIBE

Blog 2026 08 19 C++26: std::polymorphic Post Cancel

C++26: std::polymorphic Sandor Dargo Aug 19 2026-08-19T00:00:00+02:00 6 min

In the previous article, we looked at std::indirect — C++26’s answer to the “I need a heap-allocated member with value semantics” problem. indirect always stores exactly a T. But what if you need to store a Circle or a Rectangle through a Shape base class — and copy it without slicing? That’s std::polymorphic, the other half of P3019R14. It owns a heap-allocated object whose dynamic type may be T or any type derived from T. Copying performs a type-erased deep copy that preserves the dynamic type. No virtual clone() needed. The clone() tax To have a copyable collection of polymorphic objects, every derived class needs a virtual clone() method. Let’s see what that looks like: 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 class Shape { public: virtual ~Shape() = default; virtual std::unique_ptrShape> clone() const = 0; virtual double area() const = 0; };

class Circle : public Shape { double radius_; public: explicit Circle(double r) : radius_(r) {} std::unique_ptrShape> clone() const override { return std::make_uniqueCircle>(*this); double area() const override { return 3.14159 * radius_ * radius_; } };

class Rectangle : public Shape { double w_, h_; public: Rectangle(double w, double h) : w_(w), h_(h) {} std::unique_ptrShape> clone() const override { return std::make_uniqueRectangle>(*this); double area() const override { return w_ * h_; } };

Now you want a Picture that owns a collection of shapes with value semantics: 10 11 12 13 14 15 16 // full example at https://godbolt.org/z/Evz8b7r8o class Picture { std::vectorstd::unique_ptrShape>> shapes_; public: Picture(const Picture& other) { shapes_.reserve(other.shapes_.size()); for (const auto& s : other.shapes_) shapes_.push_back(s->clone()); Picture& operator=(const Picture& other) { auto tmp = other; // copy-and-swap swap(shapes_, tmp.shapes_); return *this; // ... move constructor, move assignment, destructor };

Every new shape has to implement clone(). Forget it once and you get slicing. The Picture class needs all five special member functions written by hand. This is a lot of ceremony for something conceptually simple: “I want a copyable collection of polymorphic objects.” Dropping the boilerplate with std::polymorphic std::polymorphic eliminates all of that. The shapes don’t need clone(), Picture doesn’t need any special member functions, and — perhaps surprisingly — Shape doesn’t even need a virtual destructor: 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 #include

class Shape { protected: ~Shape() = default; // no virtual destructor needed! public: virtual double area() const = 0; };

class Circle : public Shape { double radius_; public: explicit Circle(double r) : radius_(r) {} double area() const override { return 3.14159 * radius_ * radius_; } };

class Rectangle : public Shape { double w_, h_; public: Rectangle(double w, double h) : w_(w), h_(h) {} double area() const override { return w_ * h_; } };

class Picture { std::vectorstd::polymorphicShape>> shapes_; public: void add_circle(double r) { shapes_.emplace_back(std::in_place_typeCircle>, r); void add_rectangle(double w, double h) { shapes_.emplace_back(std::in_place_typeRectangle>, w, h);

double total_area() const { double sum = 0; for (const auto& s : shapes_) sum += s->area(); return sum;

size_t size() const { return shapes_.size(); }

// ALL special member functions are compiler-generated. // Copying deep-copies every shape, preserving its dynamic type. };

No clone(). No Rule of Five. Copying a Picture copies every shape — a Circle is copied as a Circle, a Rectangle as a Rectangle. The type-erasure machinery inside polymorphic handles this automatically. The only requirement is that every stored type must be copy-constructible. Deep copies just work 10 Picture a; a.add_circle(5.0); a.add_rectangle(3.0, 4.0);

Picture b = a; // deep copies both shapes, preserving...

C++26: Std:Polymorphic

Related Articles

Incident with Github.com

(no title)

Scientists reverse brain aging, with a nasal spray

NHS apologises and admits Palantir have access to identifiable patient data

Cursor Origin