引言
我有一個顯示屏模塊：
模塊上有一個128*64的單色顯示屏，一個單片機（B）控制它顯示的內容，單片機的I2C總線通過四邊上的排針排母連接到其他單片機（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 = https://www.cnblogs.com/jerry-fuyi/p/static_cast(line)->data.access();
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::defaultCopy),
reinterpret_cast(Shape::defaultDestruct),
reinterpret_cast(Shape::defaultCompare),
reinterpret_cast(Line::lineDraw),
reinterpret_cast(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();
}
ThickLine(Point p0, Point p1, int width)
: Line(thickLineVtable)
{
data.construct(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(shape)->data;
}
static const ShapeData& accessData(const Shape* shape)
{
return accessData(const_cast(shape));
}
static void thickLineDraw(const Shape* line)
{
auto& data = static_cast(line)->data.access();
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::defaultCopy),
reinterpret_cast(Shape::defaultDestruct),
reinterpret_cast(Shape::defaultCompare),
reinterpret_cast(ThickLine::thickLineDraw),
reinterpret_cast(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 = https://www.cnblogs.com/jerry-fuyi/p/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
function/bind的救贖（上）
What is Type Erasure?
A polymorphic value-type for C++
N3337: Working Draft, Standard for Programming Language C++
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/38507.html
標籤：C++
上一篇：給定一個由 0 和 1 組成的矩陣，找出每個元素到最近的 0 的距離。
下一篇：函式延遲系結的C++實作