值多態是一種介於傳統多態與類型擦除之間的多態實現方式，借鑒了值語義，保留了繼承，在單繼承的適用範圍內，程式和程式員都能從中受益。 ...
引言
我有一個顯示屏模塊：
模塊上有一個128*64的單色顯示屏，一個單片機（B）控制它顯示的內容。單片機的I²C匯流排通過四邊上的排針排母連接到其他單片機（A）上，A給B發送指令，B繪圖。
B可以向屏幕逐位元組發送顯示數據，但是不能讀取，所以程式中必須設置顯存。一幀需要1024位元組，但是單片機B只有512位元組記憶體，其中只有256位元組可以分配為顯存。解決這個問題的方法是在B的程式中把顯示屏分成4個區域，保存所有要繪製的圖形的信息，每次在256位元組中繪製1/4屏，分批繪製、發送。
簡而言之，我需要維護多個類型的數據。稍微具體點，我要把它們放在一個類似於數組的結構中，然後遍曆數組，繪製每一個元素。
不同的圖形，用相同的方式來對待，這是繼承與多態的最佳實踐。我可以設計一個Shape類，定義virtual void draw() const = 0;，每收到一個指令就new一個Line、Rectangle等類型的對象出來，放入std::vector<Shape*>中，在遍歷中對每個Shape*指針調用->draw()。
但是對不起，今天我跟new杠上了。單片機程式註重運行時效率，除了初始化以外，沒事最好別瞎new。每個指令new一下，清屏指令一起delete，恐怕不大合適吧！
我需要值多態，一種不需要指針或引用，通過對象本身就可以表現出的多態。
背景
我得先介紹一點知識，一些剛上完C++入門課程的新手不可能瞭解的，卻是深入C++底層和體會C++設計思想所必需的知識，正因為有了這些知識我才能想出“值多態”然後把它實現出來。如果你對這些知識瞭如指掌，或是已經迫不及待地想知道我是怎麼實現值多態的，可以直接拉到下麵實現一節。
多態
多態，是指為不同類型的實體提供統一的介面，或用相同的符號來代表多種不同的類型。C++里有很多種多態：
先說編譯期多態。非模板函數重載是一種多態，用相同的名字調用的函數可能是不同的，取決於參數類型。如果你需要一個函數名字能夠多處理一種類型，你就得多寫一個重載，這樣的多態是封閉式多態。好在新的重載不用和原有的函數寫在一起。
模板是一種開放式多態——適配一種新的類型是對那個新的類型提要求，而模板是不改動的。相比於後文中的運行時多態，C++鼓勵模板，“STL”的“T”就足以說明這一點。瞧，標準庫的演算法都是模板函數，而不是像《設計模式》中那樣讓各種迭代器繼承自Iterator<T>基類。
模板多態的弊端在於模板參數T類型的對象必須是即取即用的，函數返回以後就沒了，不能持久地維護。如果需要，那得使用類型擦除。
運行時多態大致可以分為繼承一套和類型擦除一套，它們都是開放式多態。繼承、虛函數這些東西，又稱OOP，我在本文標題中稱之為“傳統多態”，我認為是沒有異議的。面向對象編程語言的四個特點，抽象、封裝、繼承、多態，大家都熟記於心（有時候少了抽象），以致於有些人說到多態就是虛函數。的確，很多程式中廣泛使用繼承，但既然function/bind已經“救贖”了，那就要學它們、用它們，還要學它們的設計和思想，在合理範圍內取代繼承這一套工具，因為它們的確有很多問題——“蝙蝠是鳥也是獸，水上飛機能飛也能游”，多重繼承、虛繼承、各種overhead……連Lippman都看不下去了：
繼承的另一個主要問題，也是本文主要針對的問題，是多態需要一層間接，即指針或引用。仍然以迭代器為例，如果begin方法返回一個指向新new出來的Iterator<T>對象的指針，客戶在使用完迭代器後還得記得把它delete掉，或者用std::lock_guard一般的RAII類來負責迭代器的delete工作，總之需要多操一份心。
因此在現代C++中，基於類型擦除的多態逐漸占據了上風。類型擦除是用一個類來包裝多種具有相似介面的對象，在功能上屬於多態包裝器，如std::function就是一個多態函數包裝器，原計劃在C++20中標準化的polymorphic_value是一個多態值包裝器——與我的意圖很接近。後面會詳細討論這些。
私以為，這兩種運行時多態，只有語義上的不同。
虛函數的實現
《深度探索C++對象模型》中最吸引人的部分莫過於虛函數的實現了。儘管C++標準對於虛函數的實現方法沒有作出任何規定和假設，但是用指向虛函數表（vtable）的指針來實現多態是這個小圈子裡心照不宣的秘密。
假設有兩個類：
class Base
{
public:
Base(int i) : i(i) { }
virtual ~Base() { }
virtual void func() const {
std::cout << "Base: " << i << std::endl;
}
private:
int i;
};
class Derived : public Base
{
public:
Derived(int i, int j)
: Base(i), j(j) { }
virtual ~Derived() { }
virtual void func() const override {
std::cout << "Derived: " << j << std::endl;
}
private:
int j;
};
這兩個類的實例在記憶體中的佈局可能是這樣：
如果你把一個Derived實例的指針賦給Base*的變數，然後調用func()，程式會把這個指針指向的對象當作Base的實例，解引用它的第二格，在vtable中下標為2的位置找到func的函數指針，然後把this指針傳入調用它。雖然被當成Base實例，但該對象的vtable實際指向的是Derived類的vtable，因此被調用的函數是Derived::func，基於繼承的多態就是這樣實現的。
而如果你把一個Derived實例賦給Base變數，只有i會被拷貝，vtable會初始化成Base的vtable，j則被丟掉了。調用它的func，Base::func會執行，而且很可能是直接而非通過函數指針調用的。
這種實現可以推及到繼承樹（強調“樹”，即單繼承）的情況。至於多重繼承中的指針偏移和虛繼承中的子對象指針，過於複雜，我就不介紹了。
vtable指針不拷貝是虛函數指針語義的罪魁禍首，不過這也是不得已而為之的，拷貝vtable指針會引來更大的麻煩：如果Base實例中有Derived虛函數表指針，調用func就會訪問該對象的第三格，但第三格是無效的記憶體空間。相比之下，把維護指針的任務交給程式員是更好的選擇。
類型擦除
不拷貝vtable就不能實現值語義，拷貝vtable又會有訪問的問題，那麼是什麼原因導致了這個問題呢？是因為Base和Derived實例的大小不同。實現了類型擦除的類也使用了與vtable相同或類似的多態實現，而作為一個而非多個類，類型擦除類的大小是確定的，因此可以拷貝vtable或其類似物，也就可以實現值語義。C++想方設法讓類類型表現得像內置類型一樣，這是類型擦除更深刻的意義。
類型擦除，顧名思義，就是把對象的類型擦除掉，讓你在不知道它的類型的情況下對它執行一些操作。舉個例子，std::function有一個帶約束的模板構造函數，你可以用它來包裝任何參數類型匹配的可調用對象，在構造函數結束後，不光是你，std::function也不知道它包裝的是什麼類型的實例，但是operator()就可以調用那個可調用對象。我在一篇文章中剖析過std::function的實現，當然它還有很多種實現方法，其他類型擦除類的實現也都大同小異，它們都包含兩個要素：可能帶約束的模板構造函數，以及函數指針，無論是可見的（直接維護）還是不可見的（使用繼承）。
為了獲得更真切的感受，我們來寫一個最簡單的類型擦除：
class MyFunction
{
private:
class FunctorWrapper
{
public:
virtual ~FunctorWrapper() = default;
virtual FunctorWrapper* clone() const = 0;
virtual void call() const = 0;
};
template<typename T>
class ConcreteWrapper : public FunctorWrapper
{
public:
ConcreteWrapper(const T& functor)
: functor(functor) { }
virtual ~ConcreteWrapper() override = default;
virtual ConcreteWrapper* clone() const
{
return new ConcreteWrapper(*this);
}
virtual void call() const override
{
functor();
}
private:
T functor;
};
public:
MyFunction() = default;
template<typename T>
MyFunction(T&& functor)
: ptr(new ConcreteWrapper<T>(functor)) { }
MyFunction(const MyFunction& other)
: ptr(other.ptr->clone()) { }
MyFunction& operator=(const MyFunction& other)
{
if (this != &other)
{
delete ptr;
ptr = other.ptr->clone();
}
return *this;
}
MyFunction(MyFunction&& other) noexcept
: ptr(std::exchange(other.ptr, nullptr)) { }
MyFunction& operator=(MyFunction&& other) noexcept
{
if (this != &other)
{
delete ptr;
ptr = std::exchange(other.ptr, nullptr);
}
return *this;
}
~MyFunction()
{
delete ptr;
}
void operator()() const
{
if (ptr)
ptr->call();
}
FunctorWrapper* ptr = nullptr;
};
MyFunction類中維護一個FunctorWrapper指針，它指向一個ConcreteWrapper<T>實例，調用虛函數來實現多態。虛函數有析構、clone和call三個，它們分別用於MyFunction的析構、拷貝和函數調用。
類型擦除類的實現中總會保留一點類型信息。MyFunction類中關於T的類型信息表現在FunctorWrapper的vtable中，本質上是函數指針。類型擦除類也可以跳過繼承的工具，直接使用函數指針實現多態。無論使用哪種實現，類型擦除類總是可以被拷貝或移動或兩者兼有，多態性可以由對象本身體現。
不是每一滴牛奶都叫特侖蘇，也不是每一個類的實例都能被MyFunction包裝。MyFunction對T的要求是可以拷貝、可以用operator()() const調用，這些稱為類型T的“affordance”。說到affordance，普通的模板函數也對模板類型有affordance，比如std::sort要求迭代器可以隨機存取，否則編譯器會給你一堆冗長的錯誤信息。C++20引入了concept和requires子句，對編譯器和程式員都是有好處的。
每個類型擦除類的affordance都在寫成的時候確定下來。affordance被要求的方式不是繼承某個基類，而只看你這個類是否有相應的方法，就像Python那樣，只要函數介面匹配上就可以了。這種類型識別方式稱為“duck typing”，來源於“duck test”，意思是“If it looks like a duck, swims like a duck, and quacks like a duck, then it probably is a duck”。
類型擦除類要求的affordance通常都是一元的，也就是成員函數的參數中不含T，比如對於包裝整數的類，你可以要求T + 42，但是無法要求T + U，一個類型擦除類的實例是不知道另一個屬於同一個類但是構造自不同類型對象的實例的信息的。我覺得這條規則有一個例外，operator==是可以想辦法支持的。
MyFunction類雖然實現了值多態，但還是使用了new和delete語句。如果可調用對象只是一個簡單的函數指針，是否有必要在堆上開闢空間？
SBO
小的對象保存在類實例中，大的對象交給堆併在實例中維護指針，這種技巧稱為小緩衝優化（Small Buffer Optimization, SBO）。大多數類型擦除類都應該使用SBO以節省記憶體並提升效率，問題在於SBO與繼承不共存，維護每個實例中的一個vtable或幾個函數指針是件挺麻煩的事，還會拖慢編譯速度。
但是在記憶體和性能面前，這點工作量能叫事嗎？
class MyFunction
{
private:
static constexpr std::size_t size = 16;
static_assert(size >= sizeof(void*), "");
struct Data
{
Data() = default;
char dont_use[size];
} data;
template<typename T>
static void functorConstruct(Data& dst, T&& src)
{
using U = typename std::decay<T>::type;
if (sizeof(U) <= size)
new ((U*)&dst) U(std::forward<U>(src));
else
*(U**)&dst = new U(std::forward<U>(src));
}
template<typename T>
static void functorDestructor(Data& data)
{
using U = typename std::decay<T>::type;
if (sizeof(U) <= size)
((U*)&data)->~U();
else
delete *(U**)&data;
}
template<typename T>
static void functorCopyCtor(Data& dst, const Data& src)
{
using U = typename std::decay<T>::type;
if (sizeof(U) <= size)
new ((U*)&dst) U(*(const U*)&src);
else
*(U**)&dst = new U(**(const U**)&src);
}
template<typename T>
static void functorMoveCtor(Data& dst, Data& src)
{
using U = typename std::decay<T>::type;
if (sizeof(U) <= size)
new ((U*)&dst) U(*(const U*)&src);
else
*(U**)&dst = std::exchange(*(U**)&src, nullptr);
}
template<typename T>
static void functorInvoke(const Data& data)
{
using U = typename std::decay<T>::type;
if (sizeof(U) <= size)
(*(U*)&data)();
else
(**(U**)&data)();
}
template<typename T>
static void (*const vtables[4])();
void (*const* vtable)() = nullptr;
public:
MyFunction() = default;
template<typename T>
MyFunction(T&& obj)
: vtable(vtables<T>)
{
functorConstruct(data, std::forward<T>(obj));
}
MyFunction(const MyFunction& other)
: vtable(other.vtable)
{
if (vtable)
((void (*)(Data&, const Data&))vtable[1])(this->data, other.data);
}
MyFunction& operator=(const MyFunction& other)
{
this->~MyFunction();
vtable = other.vtable;
new (this) MyFunction(other);
return *this;
}
MyFunction(MyFunction&& other) noexcept
: vtable(std::exchange(other.vtable, nullptr))
{
if (vtable)
((void (*)(Data&, Data&))vtable[2])(this->data, other.data);
}
MyFunction& operator=(MyFunction&& other) noexcept
{
this->~MyFunction();
new (this) MyFunction(std::move(other));
return *this;
}
~MyFunction()
{
if (vtable)
((void (*)(Data&))vtable[0])(data);
}
void operator()() const
{
if (vtable)
((void (*)(const Data&))vtable[3])(this->data);
}
};
template<typename T>
void (*const MyFunction::vtables[4])() =
{
(void (*)())MyFunction::functorDestructor<T>,
(void (*)())MyFunction::functorCopyCtor<T>,
(void (*)())MyFunction::functorMoveCtor<T>,
(void (*)())MyFunction::functorInvoke<T>,
};
（如果你能完全看懂這段代碼，說明你的C語言功底非常扎實！如果看不懂，實現中有一個可讀性更好的版本。）
現在的MyFunction類就充當了原來的FunctorWrapper，用vtable實現多態性。每當MyFunction實例被賦以一個可調用對象時，vtable被初始化為指向vtables<T>，用於T類型的vtable（這裡用到了C++14的變數模板）的指針。vtable中包含4個函數指針，分別進行T實例的析構、拷貝、移動和調用。
以析構函數functorDestructor<T>為例，U是T經std::decay後的類型，用於處理函數轉換為函數指針等情況。MyFunction類中定義了size位元組的空間data，用於存放小的可調用對象或大的可調用對象的指針之一，functorDestructor<T>知道具體是哪種情況：當sizeof(U) <= size時，data存放可調用對象本身，把data解釋為U並調用其析構函數~U()；當sizeof(U) > size時，data存放指針，把data解釋為U*並delete它。其他函數原理相同，註意new ((U*)&dst) U(std::forward<U>(src));是定位new語句。
除了參數為T的構造函數以外，MyFunction的其他成員函數都通過vtable來調用T的方法，因為它們都不知道T是什麼。在拷貝時，與FunctorWrapper子類的實例被裁剪不同，MyFunction的vtable一起被拷貝，依然實現了值多態——還避免了一部分new，符合我的意圖。但是這還沒有結束。
polymorphic_value
polymorphic_value是一個實現了值多態的類模板，原定於在C++20中標準化，但是C++20沒有收錄，預計會進入C++23標準（那時候我還寫不寫C++都不一定呢）。到目前為止，我對polymorphic_value源碼的理解還處於一知半解的狀態，只能簡要地介紹一下。
polymorphic_value的模板參數T是一個類類型，任何T、T的子類U、polymorphic_value<U>的實例都可以用來構造polymorphic_value對象。polymorphic_value對象可以拷貝，其中的值也被拷貝，並且可以傳播const（通過const polymorphic_value得到的是const T&），這使它區別於unique_ptr和shared_ptr；polymorphic_value又與類型擦除不同，因為它尊重繼承，沒有使用duck typing。
然而，一個從2017年開始的，添加SBO的issue，一直沒有人回覆——這反映出polymorphic_value的實現並不簡單——目前的版本中，無論對象的大小，polymorphic_value總會new一個control_block出來；對於從一個不同類型的polymorphic_value構造出的實例，還會出現指針套指針的情況（delegating_control_block），對運行時性能有很大影響。個人認為，SBO可以把兩個問題一併解決，這也側面反映出繼承工具存在的問題。
介面
我要實現3個類：Shape，值多態的基類；Line，包含4個整數作為坐標，用於演示SBO的第一種情形；Rectangle，包含4個整數和一個bool值，後者指示矩形是否填充，用於演示第二種情形。它們的行為要像STL中的類一樣，有預設構造函數、析構函數、拷貝、移動構造和賦值、swap，還要支持operator==和draw。operator==在兩參數類型不同時返回false，相同時比較其內容；draw是一個多態的函數，在演示程式中輸出圖形的信息。
一個簡單的實現是用std::function加上適配器：
#include <iostream>
#include <functional>
#include <new>
struct Point
{
int x;
int y;
};
std::ostream& operator<<(std::ostream& os, const Point& point)
{
os << point.x << ", " << point.y;
return os;
}
class Shape
{
private:
template<typename T>
class Adapter
{
public:
Adapter(const T& shape)
: shape(shape) { }
void operator()() const
{
shape.draw();
}
private:
T shape;
};
public:
template<typename T>
Shape(const T& shape)
: function(Adapter<T>(shape)) { }
void draw() const
{
function();
}
private:
std::function<void()> function;
};
class Line
{
public:
Line() { }
Line(Point p0, Point p1)
: endpoint{ p0, p1 } { }
Line(const Line&) = default;
Line& operator=(const Line&) = default;
void draw() const
{
std::cout << "Drawing a line: " << endpoint[0] << "; " << endpoint[1]
<< std::endl;
}
private:
Point endpoint[2];
};
class Rectangle
{
public:
Rectangle() { }
Rectangle(Point v0, Point v1, bool filled)
: vertex{ v0, v1 }, filled(filled) { }
Rectangle(const Rectangle&) = default;
Rectangle& operator=(const Rectangle&) = default;
void draw() const
{
std::cout << "Drawing a rectangle: " << vertex[0] << "; " << vertex[1]
<< "; " << (filled ? "filled" : "blank") << std::endl;
}
private:
Point vertex[2];
bool filled;
};
下麵的實現與這段代碼的思路是一樣的，但是更加“純粹”。
實現
#include <iostream>
#include <new>
#include <type_traits>
#include <utility>
struct Point
{
int x;
int y;
bool operator==(const Point& rhs) const
{
return this->x == rhs.x && this->y == rhs.y;
}
};
std::ostream& operator<<(std::ostream& os, const Point& point)
{
os << point.x << ", " << point.y;
return os;
}
class Shape
{
protected:
using FuncPtr = void (*)();
using FuncPtrCopy = void (*)(Shape*, const Shape*);
static constexpr std::size_t funcIndexCopy = 0;
using FuncPtrDestruct = void (*)(Shape*);
static constexpr std::size_t funcIndexDestruct = 1;
using FuncPtrCompare = bool (*)(const Shape*, const Shape*);
static constexpr std::size_t funcIndexCompare = 2;
using FuncPtrDraw = void (*)(const Shape*);
static constexpr std::size_t funcIndexDraw = 3;
static constexpr std::size_t funcIndexTotal = 4;
class ShapeData
{
public:
static constexpr std::size_t size = 16;
template<typename T>
struct IsLocal : std::integral_constant<bool,
(sizeof(T) <= size) && std::is_trivially_copyable<T>::value> { };
private:
char placeholder[size];
template<typename T, typename U = void>
using EnableIfLocal =
typename std::enable_if<IsLocal<T>::value, U>::type;
template<typename T, typename U = void>
using EnableIfHeap =
typename std::enable_if<!IsLocal<T>::value, U>::type;
public:
ShapeData() { }
template<typename T, typename... Args>
EnableIfLocal<T> construct(Args&& ... args)
{
new (reinterpret_cast<T*>(this)) T(std::forward<Args>(args)...);
}
template<typename T, typename... Args>
EnableIfHeap<T> construct(Args&& ... args)
{
this->access<T*>() = new T(std::forward<Args>(args)...);
}
template<typename T>
EnableIfLocal<T> destruct()
{
this->access<T>().~T();
}
template<typename T>
EnableIfHeap<T> destruct()
{
delete this->access<T*>();
}
template<typename T>
EnableIfLocal<T, T&> access()
{
return reinterpret_cast<T&>(*this);
}
template<typename T>
EnableIfHeap<T, T&> access()
{
return *this->access<T*>();
}
template<typename T>
const T& access() const
{
return const_cast<ShapeData*>(this)->access<T>();
}
};
Shape(const FuncPtr* vtable)
: vtable(vtable) { }
public:
Shape() { }
Shape(const Shape& other)
: vtable(other.vtable)
{
if (vtable)
reinterpret_cast<FuncPtrCopy>(vtable[funcIndexCopy])(this, &other);
}
Shape& operator=(const Shape& other)
{
if (this != &other)
{
if (vtable)
reinterpret_cast<FuncPtrDestruct>(vtable[funcIndexDestruct])
(this);
vtable = other.vtable;
if (vtable)
reinterpret_cast<FuncPtrCopy>(vtable[funcIndexCopy])
(this, &other);
}
return *this;
}
Shape(Shape&& other) noexcept
: vtable(other.vtable), data(other.data)
{
other.vtable = nullptr;
}
Shape& operator=(Shape&& other) noexcept
{
swap(other);
return *this;
}
~Shape()
{
if (vtable)
reinterpret_cast<FuncPtrDestruct>(vtable[funcIndexDestruct])(this);
}
void swap(Shape& other) noexcept
{
using std::swap;
swap(this->vtable, other.vtable);
swap(this->data, other.data);
}
bool operator==(const Shape& rhs) const
{
if (this->vtable == nullptr || this->vtable != rhs.vtable)
return false;
return reinterpret_cast<FuncPtrCompare>(vtable[funcIndexCompare])
(this, &rhs);
}
bool operator!=(const Shape& rhs) const
{
return !(*this == rhs);
}
void draw() const
{
if (vtable)
reinterpret_cast<FuncPtrDraw>(vtable[funcIndexDraw])(this);
}
protected:
const FuncPtr* vtable = nullptr;
ShapeData data;
template<typename T>
static void defaultCopy(Shape* dst, const Shape* src)
{
dst->data.construct<T>(src->data.access<T>());
}
template<typename T>
static void defaultDestruct(Shape* shape)
{
shape->data.destruct<T>();
}
template<typename T>
static bool defaultCompare(const Shape* lhs, const Shape* rhs)
{
return lhs->data.access<T>() == rhs->data.access<T>();
}
};
namespace std
{
void swap(Shape& lhs, Shape& rhs) noexcept
{
lhs.swap(rhs);
}
}
class Line : public Shape
{
private:
struct LineData
{
Point endpoint[2];
LineData() { }
LineData(Point p0, Point p1)
: endpoint{ p0, p1 } { }
bool operator==(const LineData& rhs) const
{
return this->endpoint[0] == rhs.endpoint[0]
&& this->endpoint[1] == rhs.endpoint[1];
}
bool operator!=(const LineData& rhs) const
{
return !(*this == rhs);
}
};
static_assert(ShapeData::IsLocal<LineData>::value, "");
public:
Line()
: Shape(lineVtable)
{
data.construct<LineData>();
}
Line(Point p0, Point p1)
: Shape(lineVtable)
{
data.construct<LineData>(p0, p1);
}
Line(const Line&) = default;
Line& operator=(const Line&) = default;
Line(Line&&) = default;
Line& operator=(Line&&) = default;
~Line() = default;
private:
static const FuncPtr lineVtable[funcIndexTotal];
static ShapeData& accessData(Shape* shape)
{
return static_cast<Line*>(shape)->data;
}
static const ShapeData& accessData(const Shape* shape)
{
return accessData(const_cast<Shape*>(shape));
}
static void lineDraw(const Shape* line)
{
auto& data = static_cast<const Line*>(line)->data.access<LineData>();
std::cout << "Drawing a line: " << data.endpoint[0] << "; "
<< data.endpoint[1] << std::endl;
}
};
const Shape::FuncPtr Line::lineVtable[] =
{
reinterpret_cast<Shape::FuncPtr>(Shape::defaultCopy<LineData>),
reinterpret_cast<Shape::FuncPtr>(Shape::defaultDestruct<LineData>),
reinterpret_cast<Shape::FuncPtr>(Shape::defaultCompare<LineData>),
reinterpret_cast<Shape::FuncPtr>(Line::lineDraw),
};
class Rectangle : public Shape
{
private:
struct RectangleData
{
Point vertex[2];
bool filled;
RectangleData() { }
RectangleData(Point v0, Point v1, bool filled)
: vertex{ v0, v1 }, filled(filled) { }
bool operator==(const RectangleData& rhs) const
{
return this->vertex[0] == rhs.vertex[0]
&& this->vertex[1] == rhs.vertex[1]
&& this->filled == rhs.filled;
}
bool operator!=(const RectangleData& rhs) const
{
return !(*this == rhs);
}
};
static_assert(!ShapeData::IsLocal<RectangleData>::value, "");
public:
Rectangle()
: Shape(rectangleVtable)
{
data.construct<RectangleData>();
}
Rectangle(Point v0, Point v1, bool filled)
: Shape(rectangleVtable)
{
data.construct<RectangleData>(v0, v1, filled);
}
Rectangle(const Rectangle&) = default;
Rectangle& operator=(const Rectangle&) = default;
Rectangle(Rectangle&&) = default;
Rectangle& operator=(Rectangle&&) = default;
~Rectangle() = default;
private:
static const FuncPtr rectangleVtable[funcIndexTotal];
static ShapeData& accessData(Shape* shape)
{
return static_cast<Rectangle*>(shape)->data;
}
static const ShapeData& accessData(const Shape* shape)
{
return accessData(const_cast<Shape*>(shape));
}
static void rectangleDraw(const Shape* rect)
{
auto& data = accessData(rect).access<RectangleData>();
std::cout << "Drawing a rectangle: " << data.vertex[0] << "; "
<< data.vertex[1] << "; " << (data.filled ? "filled" : "blank")
<< std::endl;
}
};
const Shape::FuncPtr Rectangle::rectangleVtable[] =
{
reinterpret_cast<Shape::FuncPtr>(Shape::defaultCopy<RectangleData>),
reinterpret_cast<Shape::FuncPtr>(Shape::defaultDestruct<RectangleData>),
reinterpret_cast<Shape::FuncPtr>(Shape::defaultCompare<RectangleData>),
reinterpret_cast<Shape::FuncPtr>(Rectangle::rectangleDraw),
};
template<typename T>
Shape test(const T& s0)
{
s0.draw();
T s1 = s0;
s1.draw();
T s2;
s2 = s1;
s2.draw();
Shape s3 = s0;
s3.draw();
Shape s4;
s4 = s0;
s4.draw();
Shape s5 = std::move(s0);
s5.draw();
Shape s6;
s6 = std::move(s5);
s6.draw();
return s6;
}
int main()
{
Line line({ 1, 2 }, { 3, 4 });
auto l2 = test(line);
Rectangle rect({ 5, 6 }, { 7, 8 }, true);
auto r2 = test(rect);
std::swap(l2, r2);
l2.draw();
r2.draw();
}
對象模型
之前提到，傳統多態與類型擦除的本質是相同的，都使用了函數指針，放在vtable或對象中。在Shape的繼承體系中，Line和Rectangle都是具體的類，寫兩個vtable非常容易，所以我採用了vtable的實現。
Line和Rectangle繼承自Shape，為了在值拷貝時不被裁剪，三個類的記憶體佈局必須相同，也就是說Line和Rectangle不能定義新的數據成員。Shape預留了16位元組空間供子類使用，存儲Line的數據或指向Rectangle數據的指針，後者是我特意安排用於演示的（兩個static_assert只是為了確保演示到位，並非我對兩個子類的記憶體佈局有什麼假設）。
SBO類型
ShapeData是Shape中的數據空間，儲存值或指針由ShapeData和數據類型共同決定，如果把決定的任務交給具體的數據類型，ShapeData是很難修改大小的，因此我把ShapeData設計為一個帶有模板函數的類型，以數據類型為模板參數T，提供構造、析構、訪問的操作，各有兩個版本，具體調用哪個可以交給編譯器來決定，從而提高程式的可維護性。
std::function同樣使用SBO，在閱讀其源碼時我發現，兩種情形的分界線可以不只是數據類型的大小，還有is_trivially_copyable等，這樣做的好處是移動和swap可以使用接近預設的行為。
class ShapeData
{
public:
static constexpr std::size_t size = 16;
static_assert(size >= sizeof(void*), "");
template<typename T>
struct IsLocal : std::integral_constant<bool,
(sizeof(T) <= size) && std::is_trivially_copyable<T>::value> { };
private:
char placeholder[size];
template<typename T, typename U = void>
using EnableIfLocal =
typename std::enable_if<IsLocal<T>::value, U>::type;
template<typename T, typename U = void>
using EnableIfHeap =
typename std::enable_if<!IsLocal<T>::value, U>::type;
public:
ShapeData() { }
template<typename T, typename... Args>
EnableIfLocal<T> construct(Args&& ... args)
{
new (reinterpret_cast<T*>(this)) T(std::forward<Args>(args)...);
}
template<typename T, typename... Args>
EnableIfHeap<T> construct(Args&& ... args)
{
this->access<T*>() = new T(std::forward<Args>(args)...);
}
template<typename T>
EnableIfLocal<T> destruct()
{
this->access<T>().~T();
}
template<typename T>
EnableIfHeap<T> destruct()
{
delete this->access<T*>();
}
template<typename T>
EnableIfLocal<T, T&> access()
{
return reinterpret_cast<T&>(*this);
}
template<typename T>
EnableIfHeap<T, T&> access()
{
return *this->access<T*>();
}
template<typename T>
const T& access() const
{
return const_cast<ShapeData*>(this)->access<T>();
}
};
EnableIfLocal和EnableIfHeap用了SFNIAE的技巧（這裡有個類似的例子）。我習慣用SFINAE，如果你願意的話也可以用tag dispatch。
虛函數表
C99標準6.3.2.3 clause 8：
A pointer to a function of one type may be converted to a pointer to a function of another type and back again; the result shall compare equal to the original pointer. If a converted pointer is used to call a function whose type is not compatible with the pointed-to type, the behavior is undefined.
言下之意是所有函數指針大小相同。C++標準沒有這樣的規定，但是我作出這種假設（成員函數指針不包含在內）。據我所知，在所有的主流平臺中，這種假設都是成立的。於是，我定義類型using FuncPtr = void (*)();，以FuncPtr數組為vtable，可以存放任意類型的函數指針。
vtable中存放4個函數指針，它們分別負責對象的拷貝（沒有移動）、析構、比較（operator==）和draw。函數指針的類型各不相同，但是與子類無關，可以在Shape中定義，簡化後面的代碼。每個函數指針的下標顯然不能用0、1、2等magic number，也在Shape中定義了常量，方便維護。與default關鍵字類似地，Shape提供了前三個函數的預設實現，絕大多數情況下不用另寫。
class Shape
{
protected:
using FuncPtr = void (*)();
using FuncPtrCopy = void (*)(Shape*, const Shape*);
static constexpr std::size_t funcIndexCopy = 0;
using FuncPtrDestruct = void (*)(Shape*);
static constexpr std::size_t funcIndexDestruct = 1;
using FuncPtrCompare = bool (*)(const Shape*, const Shape*);
static constexpr std::size_t funcIndexCompare = 2;
using FuncPtrDraw = void (*)(const Shape*);
static constexpr std::size_t funcIndexDraw = 3;
static constexpr std::size_t funcIndexTotal = 4;
// ...
public:
// ...
protected:
const FuncPtr* vtable = nullptr;
ShapeData data;
template<typename T>
static void defaultCopy(Shape* dst, const Shape* src)
{
dst->data.construct<T>(src->data.access<T>());
}
template<typename T>
static void defaultDestruct(Shape* shape)
{
shape->data.destruct<T>();
}
template<typename T>
static bool defaultCompare(const Shape* lhs, const Shape* rhs)
{
return lhs->data.access<T>() == rhs->data.access<T>();
}
};
方法適配
所有具有多態性質的函數都得通過調用虛函數表中的函數來執行操作，這包括析構、拷貝構造、拷貝賦值（沒有移動）、operator==和draw。
class Shape
{
protected:
// ...
Shape(const FuncPtr* vtable)
: vtable(vtable) { }
public:
Shape() { }
Shape(const Shape& other)
: vtable(other.vtable)
{
if (vtable)
reinterpret_cast<FuncPtrCopy>(vtable[funcIndexCopy])(this, &other);
}
Shape& operator=(const Shape& other)
{
if (this != &other)
{
if (vtable)
reinterpret_cast<FuncPtrDestruct>(vtable[funcIndexDestruct])
(this);
vtable = other.vtable;
if (vtable)
reinterpret_cast<FuncPtrCopy>(vtable[funcIndexCopy])
(this, &other);
}
return *this;
}
Shape(Shape&& other) noexcept
: vtable(other.vtable), data(other.data)
{
other.vtable = nullptr;
}
Shape& operator=(Shape&& other) noexcept
{
swap(other);
return *this;
}
~Shape()
{
if (vtable)
reinterpret_cast<FuncPtrDestruct>(vtable[funcIndexDestruct])(this);
}
void swap(Shape& other) noexcept
{
using std::swap;
swap(this->vtable, other.vtable);
swap(this->data, other.data);
}
bool operator==(const Shape& rhs) const
{
if (this->vtable == nullptr || this->vtable != rhs.vtable)
return false;
return reinterpret_cast<FuncPtrCompare>(vtable[funcIndexCompare])
(this, &rhs);
}
bool operator!=(const Shape& rhs) const
{
return !(*this == rhs);
}
void draw() const
{
if (vtable)
reinterpret_cast<FuncPtrDraw>(vtable[funcIndexDraw])(this);
}
protected:
// ...
};
namespace std
{
void swap(Shape& lhs, Shape& rhs) noexcept
{
lhs.swap(rhs);
}
}
拷貝構造函數拷貝vtable和數據，析構函數銷毀數據，拷貝賦值函數先析構再拷貝。operator==先檢查兩個參數的vtable是否相同，只有相同，兩個參數才是同一類型，才能進行後續比較。draw調用vtable中的對應函數。所有方法都會先檢查vtable是否為nullptr，因為Shape是一個抽象類的角色，一個Shape對象是空的，任何操作都不執行。
比較特殊的是移動和swap。由於ShapeData data中存放的是is_trivially_copyable的數據類型或指針，都是“位置無關”（可以trivially拷貝）的，因此swap中data可以直接複製。（swap在這麼不trivial的情況下都能預設，給swap整一個運算符不好嗎？）
移動賦值把*this和other交換，把析構*this的任務交給other。移動構造也相當於swap，不過this->vtable == nullptr。其實我還可以寫copy-and-swap：
Shape& operator=(Shape other)
{
swap(other);
return *this;
}
用以替換Shape& operator=(const Shape&)和Shape& operator=(Shape&&)，可惜Shape& operator=(Shape)不屬於C++規定的特殊成員函數，子類不會繼承其行為。
子類繼承以上所有函數。我非常想寫上final以防止子類覆寫，但是這些函數並不是C++語法上的虛函數。所以我們獲得了virtual的拷貝構造和draw，實現了值多態。
討論
我翻開C++標準一查，這標準沒有實現細節，方方正正的每頁上都寫著“undefined behavior”幾個詞。我橫豎睡不著，仔細看了半夜，才從字縫裡看出字來，滿本都寫著一個詞是“trade-off”。如果要用一句話概括值多態，那就是“更多義務，更多權利”。
安全
Shape的實現代碼中充斥著強制類型轉換，很容易引起對其類型安全性的質疑。這是多慮，因為LineData和lineVtable是始終綁定在一起的，虛函數不會訪問到非對應類型的數據。即使在這一點上出錯，只要數據類型是比較trivial的（不包含指針之類的），起碼程式不會崩潰。不過類型安全性的前提是基類與派生類的大小相同，如果客戶違反了這一點，那我只好使出C/C++傳統藝能——undefined behavior了。
類型安全不等同於“類型正確”——我隨便起的名字。在上面的演示程式中，如果我std::swap(line, rect)，line就會存儲一個Rectangle實例，但line在語法上卻是一個Line實例！也就是說，Line和Rectangle只能在定義變數時保證類型正確，在此之後它們就和Shape通假了。
類型安全保證不會訪問到非法的地址空間，那麼記憶體泄漏是否會發生？構造時按照SBO的第二種情況new，而析構時按照第一種情況trivially析構，這種情況是不可能發生的。首先前提是數據類型與vtable配對，在此基礎上vtable中拷貝與析構配對。這些函數選擇哪個版本是在編譯期決定的，這更加讓人放心。
還有異常安全。只要客戶遵守一些異常處理的規則，使得Shape的析構函數能夠被調用，就能確保不會有資源未釋放。
性能
空間上，值多態難免浪費空間。預留的數據區域需要足夠大，才能存下大多數類型的數據，對於其中較小的有很多空間被浪費，對於大到放不進的只存放一個指針，也是一種浪費。富有創意的你還可以把一部分trivial的數據放在本地，其他的維護一個指針，但是那樣也太麻煩了吧。
時間上，值多態的動態部分有更好的表現。相比於基於繼承的類型擦除，值多態在創建對象時少一次new，使用時少一次解引用；相比於函數指針的類型擦除，值多態在創建值多態只需維護一個vtable指針。相比於虛函數，值多態的初衷就是避免new和delete。不過，虛函數是編譯器負責的，編譯器要是有什麼猥瑣優化，那我認輸。
但是值多態的靜態部分不盡人意。在傳統多態中，如果一個多態實例的類型在編譯期可以確定，那麼虛函數會靜態決議，不通過vtable而直接調用函數。在值多態中，子類可以覆寫基類的普通“虛函數”，提升運行時性能，但是對於拷貝控制函數，無論子類是否覆寫，編譯器總會調用基類的對應函數，而它們的任務是多態拷貝，子類沒有必要，有時也不能覆寫，更無法靜態決議了。不過考慮到line非Line的情況，還是老老實實用動態決議吧。
時間和空間有權衡的餘地。為了讓更多子類的數據可以放在本地，基類中的數據空間可以保留得大一些，但是也會浪費更多空間；可以把vtable中的函數指針直接放在對象中，多占用一些空間，換來每次使用時減少一次解引用；拷貝、析構和比較可以合併為一個函數以節省空間，但是需要多一個參數指明何種操作。總之，傳統藝能implementation-defined。
擴展
我要給Line加上一個子類ThickLine，表示一定寬度的直線。在電腦的屏幕上繪製傾斜曲線常用Bresenham演算法，我對它不太熟悉，希望程式能列印一些調試信息，所以給Line加上一個虛函數debug（而Rectangle繪製起來很容易）。當然，不是C++語法上的虛函數。
class Line : public Shape
{
protected:
static constexpr std::size_t funcIndexDebug = funcIndexTotal;
using FuncPtrDebug = void (*)(const Line*);
static constexpr std::size_t funcIndexTotalLine = funcIndexTotal + 1;
struct LineData
{
Point endpoint[2];
LineData() { }
LineData(Point p0, Point p1)
: endpoint{ p0, p1 } { }
bool operator==(const LineData& rhs) const
{
return this->endpoint[0] == rhs.endpoint[0]
&& this->endpoint[1] == rhs.endpoint[1];
}
bool operator!=(const LineData& rhs) const
{
return !(*this == rhs);
}
};
Line(const FuncPtr* vtable)
: Shape(vtable) { }
public:
Line()
: Shape(lineVtable)
{
data.construct<LineData>();
}
Line(Point p0, Point p1)
: Shape(lineVtable)
{
data.construct<LineData>(p0, p1);
}
Line(const Line&) = default;
Line& operator=(const Line&) = default;
Line(Line&&) = default;
Line& operator=(Line&&) = default;
~Line() = default;
void debug() const
{
if (vtable)
reinterpret_cast<FuncPtrDebug>(vtable[funcIndexDebug])(this);
}
private:
static const FuncPtr lineVtable[funcIndexTotalLine];
static ShapeData& accessData(Shape* shape)
{
return static_cast<Line*>(shape)->data;
}
static const ShapeData& accessData(const Shape* shape)
{
return accessData(const_cast<Shape*>(shape));
}
static void lineDraw(const Shape* line)
{
auto& data = static_cast<const Line*>(line)->data.access<LineData>();
std::cout << "Drawing a line: " << data.endpoint[0] << "; "
<< data.endpoint[1] << std::endl;
}
static void lineDebug(const Line* line)
{
std::cout << "Line debug:\n\t";
lineDraw(line);
}
};
const Shape::FuncPtr Line::lineVtable[] =
{
reinterpret_cast<Shape::FuncPtr>(Shape::defaultCopy<LineData>),
reinterpret_cast<Shape::FuncPtr>(Shape::defaultDestruct<LineData>),
reinterpret_cast<Shape::FuncPtr>(Shape::defaultCompare<LineData>),
reinterpret_cast<Shape::FuncPtr>(Line::lineDraw),
reinterpret_cast<Shape::FuncPtr>(Line::lineDebug),
};
class ThickLine : public Line
{
protected:
struct ThickLineData
{
LineData lineData;
int width;
ThickLineData() { }
ThickLineData(Point p0, Point p1, int width)
: lineData{ p0, p1 }, width(width) { }
ThickLineData(LineData data, int width)
: lineData(data), width(width) { }
bool operator==(const ThickLineData& rhs) const
{
return this->lineData == rhs.lineData
&& this->width == rhs.width;
}
bool operator!=(const ThickLineData& rhs) const
{
return !(*this == rhs);
}
};
public:
ThickLine()
: Line(thickLineVtable)
{
data.construct<ThickLineData>();
}
ThickLine(Point p0, Point p1, int width)
: Line(thickLineVtable)
{
data.construct<ThickLineData>(p0, p1, width);
}
ThickLine(const ThickLine&) = default;
ThickLine& operator=(const ThickLine&) = default;
ThickLine(ThickLine&&) = default;
ThickLine& operator=(ThickLine&&) = default;
~ThickLine() = default;
private:
static const FuncPtr thickLineVtable[funcIndexTotalLine];
static ShapeData& accessData(Shape* shape)
{
return static_cast<ThickLine*>(shape)->data;
}
static const ShapeData& accessData(const Shape* shape)
{
return accessData(const_cast<Shape*>(shape));
}
static void thickLineDraw(const Shape* line)
{
auto& data = static_cast<const ThickLine*>(line)->data.access<ThickLineData>();
std::cout << "Drawing a thick line: " << data.lineData.endpoint[0] << "; "
<< data.lineData.endpoint[1] << "; " << data.width << std::endl;
}
static void thickLineDebug(const Line* line)
{
std::cout << "ThickLine debug:\n\t";
thickLineDraw(line);
}
};
const Shape::FuncPtr ThickLine::thickLineVtable[] =
{
reinterpret_cast<Shape::FuncPtr>(Shape::defaultCopy<ThickLineData>),
reinterpret_cast<Shape::FuncPtr>(Shape::defaultDestruct<ThickLineData>),
reinterpret_cast<Shape::FuncPtr>(Shape::defaultCompare<ThickLineData>),
reinterpret_cast<Shape::FuncPtr>(ThickLine::thickLineDraw),
reinterpret_cast<Shape::FuncPtr>(ThickLine::thickLineDebug),
};
在非抽象類Line中加入數據比想象中困難。Line的構造函數會把SBO數據段作為LineData來構造，但是ThickLine需要的是ThickLineData，在LineData上再次構造ThickLine是不安全的，因此我仿照Shape給Line加上一個protected構造函數，並把LineData開放給ThickLine，定義ThickLineData，其中包含LineData。
這個例子說明，值多態不只適用於一群派生類直接繼承一個抽象基類的情況，可以擴展到任何單繼承的繼承鏈/樹，包括繼承抽象類與非抽象類，其中後者稍微麻煩一些，需要基類把數據類型開放給派生類，讓派生類將基類數據與新增數據進行組合。這一定程度上破壞了基類的封裝性，解決辦法是把方法定義在數據類型中，讓值多態類起適配器的作用。
單繼承並不能概括所有“is-a”的關係，有時多重繼承和虛繼承是必要的，值多態能否支持呢？答曰：不可能，因為多繼承下的派生類的實例的大小大於任何一個基類，這與值多態要求基類與派生類記憶體佈局一致相矛盾。這應該是值多態最明顯的局限性了吧。
模式
沒有強制子類不定義數據成員的手段帶來潛在的安全問題，編譯器自動調用基類拷貝函數使靜態決議不再可能，派生類甚至還要破壞基類數據的封裝性，這些問題有沒有解決方案呢？在C語言中，類似的問題被Cfront編譯器解決，很容易想到值多態是否可以成為一種編程語言的預設多態行為。我認為是可以的，它尤其適合比較小的設備，但是有些問題需要考慮。
剛剛證明瞭單繼承可行而多繼承不可行，這種編程語言只能允許單繼承。那麼介於單繼承和多繼承之間的，去除了數據成員的累贅的多繼承，類似於Java和C#中的interface，是否可行呢？我沒有細想，隱隱約約感覺是有解決方案的。
基類中預留多少數據空間？如果由程式員來決定，程式員胡亂寫個數字，單片機有8、16、32位的，這樣做使代碼可移植性降低。或者由編譯器來決定，比如要使50%的子類數據可以放在本地。這看起來很和諧，但是思考一下你會發現它對鏈接器不友好。更糟糕的是，如果有這樣的定義：
class A { };
class B { };
class A1 : public A { B b; };
class B1 : public B { A a; };
要決定A的大小，就得先決定B的；要決定B的大小，還得先決定A的……嗯，可以出一道演算法題了。
想那麼多乾什麼，說得好像我學過編譯原理似的。
次於語法，值多態是否可以一般化，寫成一個通用的庫？polymorphic_value是一個現成但不完美的答案，它的主要問題在於不能通過polymorphic_value<D>實例直接構造polymorphic_value<B>實例（其中D是B的派生類），這會導致極端情況下調用一個方法的時間複雜度為\(O(h)\)（其中\(h\)為繼承鏈的長度）。還有一個小細節是裸的值多態永遠勝於任何類庫的：可以直接寫shape.draw()而無需shape->draw()，後者形如指針的語義有一些誤導性。不過polymorphic_value支持多繼承與虛繼承，這是值多態永遠比不上的。
我苦思冥想了很久，覺得就算C++究極進化成了C++++也不可能存在一個類模板能對值多態類的設計有什麼幫助，唯有退而求其次地用巨集。Shape一家可以簡化成這樣：
class Shape
{
VP_BASE(Shape, 16, 1);
static constexpr std::size_t funcIndexDraw = 0;
public:
void draw() const
{
if (vtable)
VP_BASE_VFUNCTION(void(*)(const Shape*), funcIndexDraw)(this);
}
};
VP_BASE_SWAP(Shape);
class Line : public Shape
{
VP_DERIVED(Line);
private:
struct LineData
{
Point endpoint[2];
LineData() { }
LineData(Point p0, Point p1)
: endpoint{ p0, p1 } { }
bool operator==(const LineData& rhs) const
{
return this->endpoint[0] == rhs.endpoint[0]
&& this->endpoint[1] == rhs.endpoint[1];
}
bool operator!=(const LineData& rhs) const
{
return !(*this == rhs);
}
};
public:
Line()
: VP_DERIVED_INITIALIZE(Shape, Line)
{
VP_DERIVED_CONSTRUCT(LineData);
}
Line(Point p0, Point p1)
: VP_DERIVED_INITIALIZE(Shape, Line)
{
VP_DERIVED_CONSTRUCT(LineData, p0, p1);
}
private:
static void lineDraw(const Shape* line)
{
auto& data = VP_DERIVED_ACCESS(const Line, LineData, line);
std::cout << "Drawing a line: " << data.endpoint[0] << "; "
<< data.endpoint[1] << std::endl;
}
};
VP_DERIVED_VTABLE(Line, LineData,
VP_DERIVED_VFUNCTION(Line, lineDraw),
);
class Rectangle : public Shape
{
VP_DERIVED(Rectangle);
private:
struct RectangleData
{
Point vertex[2];
bool filled;
RectangleData() { }
RectangleData(Point v0, Point v1, bool filled)
: vertex{ v0, v1 }, filled(filled) { }
bool operator==(const RectangleData& rhs) const
{
return this->vertex[0] == rhs.vertex[0]
&& this->vertex[1] == rhs.vertex[1]
&& this->filled == rhs.filled;
}
bool operator!=(const RectangleData& rhs) const
{
return !(*this == rhs);
}
};
public:
Rectangle()
: VP_DERIVED_INITIALIZE(Shape, Rectangle)
{
VP_DERIVED_CONSTRUCT(RectangleData);
}
Rectangle(Point v0, Point v1, bool filled)
: VP_DERIVED_INITIALIZE(Shape, Rectangle)
{
VP_DERIVED_CONSTRUCT(RectangleData, v0, v1, filled);
}
private:
static void rectangleDraw(const Shape* rect)
{
auto& data = VP_DERIVED_ACCESS(const Rectangle, RectangleData, rect);
std::cout << "Drawing a rectangle: " << data.vertex[0] << "; "
<< data.vertex[1] << "; " << (data.filled ? "filled" : "blank")
<< std::endl;
}
};
VP_DERIVED_VTABLE(Rectangle, RectangleData,
VP_DERIVED_VFUNCTION(Rectangle, rectangleDraw),
);
效果一般，並沒有簡化很多。不僅如此，如果不想讓自己的值多態類支持operator==的話，還得寫一個新的巨集，非常死板。
再次於工具，值多態是否可以成為一種設計模式呢？我認為它具有成為設計模式的潛質，因為各個值多態類都具有相似的記憶體佈局，可以把共用代碼抽離出來寫成巨集。但是，由於我沒有在任何地方看到過這種用法，現在還不能大張旗鼓地把它作為一種設計模式來宣揚。Anyway，讓值多態成為一種設計模式是我的願景。（誰還不想搞一點發明創造呢？）
比較
值多態處於傳統多態與類型擦除之間，與C++中現有的各種多態實現方式相比，在它的適用範圍內，具有集大成的優勢。
與傳統多態相比，值多態保留了繼承的工具與思維方式，但是與傳統多態的指針語義不同，值多態是值語義的，多態性可以在值拷貝時被保留。值語義的多態的意義不僅在於帶來方便，更有消除潛在的bug——C/C++的指針被人詬病得還不夠嗎？
與類型擦除相比，值多態同樣使用值語義（類型擦除界也有引用語義的），但是並非duck typing而是選擇了較為傳統的繼承。duck typing在靜態類型語言C++中處處受限：類型擦除類的實例可以由duck來構造但是無法還原；類型擦除類有固定的affordance，如std::function要求operator()，即使用上適配器可以搞定Shape，但對於兩個多態函數的Line和ThickLine還是束手無策。繼承作為C++原生特性不存在這些問題，更重要的是繼承是C++和很多其他語言的程式員所習慣的思維方式。
與polymorphic_value相比，值多態用普適性換取了運行時的性能和實現上的自由——畢竟除SBOData以外的類都是自己寫的。在類型轉換時，polymorphic_value會套娃，而值多態不會，並且能不能轉換可以由編譯器說了算。值多態的類型對客戶完全開放，用不用SBO、SBO多大都可以按需控制，甚至可以人為干預向下類型轉換。當然，自由的代價是更長的代碼。
總結
值多態是一種介於傳統多態與類型擦除之間的多態實現方式，借鑒了值語義，保留了繼承，在單繼承的適用範圍內，程式和程式員都能從中受益。本文也是《深度探索C++對象模型》中“Function語意學”一章的最佳實踐。
換個記憶體大一點的單片機，屁事都沒有了——技術不夠，成本來湊。
參考
Polymorphism (computer science) - Wikipedia
A polymorphic value-type for C++
N3337: Working Draft, Standard for Programming Language C++
