詳解C++值多態(tài)中的傳統(tǒng)多態(tài)與類型擦除
引言
我有一個顯示屏模塊：
模塊上有一個128*64的單色顯示屏，一個單片機（B）控制它顯示的內(nèi)容。單片機的I²C總線通過四邊上的排針排母連接到其他單片機（A）上，A給B發(fā)送指令，B繪圖。
B可以向屏幕逐字節(jié)發(fā)送顯示數(shù)據(jù)，但是不能讀取，所以程序中必須設置顯存。一幀需要1024字節(jié)，但是單片機B只有512字節(jié)內(nèi)存，其中只有256字節(jié)可以分配為顯存。解決這個問題的方法是在B的程序中把顯示屏分成4個區(qū)域，保存所有要繪制的圖形的信息，每次在256字節(jié)中繪制1/4屏，分批繪制、發(fā)送。
簡而言之，我需要維護多個類型的數(shù)據(jù)。稍微具體點，我要把它們放在一個類似于數(shù)組的結(jié)構(gòu)中，然后遍歷數(shù)組，繪制每一個元素。
不同的圖形，用相同的方式來對待，這是繼承與多態(tài)的最佳實踐。我可以設計一個Shape類，定義virtual void draw() const = 0;，每收到一個指令就new一個Line、Rectangle等類型的對象出來，放入std::vector<Shape*>中，在遍歷中對每個Shape*指針調(diào)用->draw()。
但是對不起，今天我跟new杠上了。單片機程序注重運行時效率，除了初始化以外，沒事最好別瞎new。每個指令new一下，清屏指令一起delete，恐怕不大合適吧！
我需要值多態(tài)，一種不需要指針或引用，通過對象本身就可以表現(xiàn)出的多態(tài)。
背景
我得先介紹一點知識，一些剛上完C++入門課程的新手不可能了解的，卻是深入C++底層和體會C++設計思想所必需的知識，正因為有了這些知識我才能想出“值多態(tài)”然后把它實現(xiàn)出來。如果你對這些知識了如指掌，或是已經(jīng)迫不及待地想知道我是怎么實現(xiàn)值多態(tài)的，可以直接拉到下面實現(xiàn)一節(jié)。
多態(tài)
多態(tài)，是指為不同類型的實體提供統(tǒng)一的接口，或用相同的符號來代表多種不同的類型。C++里有很多種多態(tài)：
先說編譯期多態(tài)。非模板函數(shù)重載是一種多態(tài)，用相同的名字調(diào)用的函數(shù)可能是不同的，取決于參數(shù)類型。如果你需要一個函數(shù)名字能夠多處理一種類型，你就得多寫一個重載，這樣的多態(tài)是封閉式多態(tài)。好在新的重載不用和原有的函數(shù)寫在一起。
模板是一種開放式多態(tài)——適配一種新的類型是對那個新的類型提要求，而模板是不改動的。相比于后文中的運行時多態(tài)，C++鼓勵模板，“STL”的“T”就足以說明這一點。瞧，標準庫的算法都是模板函數(shù)，而不是像《設計模式》中那樣讓各種迭代器繼承自Iterator<T>基類。
模板多態(tài)的弊端在于模板參數(shù)T類型的對象必須是即取即用的，函數(shù)返回以后就沒了，不能持久地維護。如果需要，那得使用類型擦除。
運行時多態(tài)大致可以分為繼承一套和類型擦除一套，它們都是開放式多態(tài)。繼承、虛函數(shù)這些東西，又稱OOP，我在本文標題中稱之為“傳統(tǒng)多態(tài)”，我認為是沒有異議的。面向?qū)ο缶幊陶Z言的四個特點，抽象、封裝、繼承、多態(tài)，大家都熟記于心（有時候少了抽象），以致于有些人說到多態(tài)就是虛函數(shù)。的確，很多程序中廣泛使用繼承，但既然function/bind已經(jīng)“救贖”了，那就要學它們、用它們，還要學它們的設計和思想，在合理范圍內(nèi)取代繼承這一套工具，因為它們的確有很多問題——“蝙蝠是鳥也是獸，水上飛機能飛也能游”，多重繼承、虛繼承、各種overhead……連Lippman都看不下去了：
繼承的另一個主要問題，也是本文主要針對的問題，是多態(tài)需要一層間接，即指針或引用。仍然以迭代器為例，如果begin方法返回一個指向新new出來的Iterator<T>對象的指針，客戶在使用完迭代器后還得記得把它delete掉，或者用std::lock_guard一般的RAII類來負責迭代器的delete工作，總之需要多操一份心。
因此在現(xiàn)代C++中，基于類型擦除的多態(tài)逐漸占據(jù)了上風。類型擦除是用一個類來包裝多種具有相似接口的對象，在功能上屬于多態(tài)包裝器，如std::function就是一個多態(tài)函數(shù)包裝器，原計劃在C++20中標準化的polymorphic_value是一個多態(tài)值包裝器——與我的意圖很接近。后面會詳細討論這些。
私以為，這兩種運行時多態(tài)，只有語義上的不同。
虛函數(shù)的實現(xiàn)
《深度探索C++對象模型》中最吸引人的部分莫過于虛函數(shù)的實現(xiàn)了。盡管C++標準對于虛函數(shù)的實現(xiàn)方法沒有作出任何規(guī)定和假設，但是用指向虛函數(shù)表（vtable）的指針來實現(xiàn)多態(tài)是這個小圈子里心照不宣的秘密。
假設有兩個類：
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;
};
這兩個類的實例在內(nèi)存中的布局可能是這樣：
如果你把一個Derived實例的指針賦給Base*的變量，然后調(diào)用func()，程序會把這個指針指向的對象當作Base的實例，解引用它的第二格，在vtable中下標為2的位置找到func的函數(shù)指針，然后把this指針傳入調(diào)用它。雖然被當成Base實例，但該對象的vtable實際指向的是Derived類的vtable，因此被調(diào)用的函數(shù)是Derived::func，基于繼承的多態(tài)就是這樣實現(xiàn)的。
而如果你把一個Derived實例賦給Base變量，只有i會被拷貝，vtable會初始化成Base的vtable，j則被丟掉了。調(diào)用它的func，Base::func會執(zhí)行，而且很可能是直接而非通過函數(shù)指針調(diào)用的。
這種實現(xiàn)可以推及到繼承樹（強調(diào)“樹”，即單繼承）的情況。至于多重繼承中的指針偏移和虛繼承中的子對象指針，過于復雜，我就不介紹了。
vtable指針不拷貝是虛函數(shù)指針語義的罪魁禍首，不過這也是不得已而為之的，拷貝vtable指針會引來更大的麻煩：如果Base實例中有Derived虛函數(shù)表指針，調(diào)用func就會訪問該對象的第三格，但第三格是無效的內(nèi)存空間。相比之下，把維護指針的任務交給程序員是更好的選擇。
類型擦除
不拷貝vtable就不能實現(xiàn)值語義，拷貝vtable又會有訪問的問題，那么是什么原因?qū)е铝诉@個問題呢？是因為Base和Derived實例的大小不同。實現(xiàn)了類型擦除的類也使用了與vtable相同或類似的多態(tài)實現(xiàn)，而作為一個而非多個類，類型擦除類的大小是確定的，因此可以拷貝vtable或其類似物，也就可以實現(xiàn)值語義。C++想方設法讓類類型表現(xiàn)得像內(nèi)置類型一樣，這是類型擦除更深刻的意義。
類型擦除，顧名思義，就是把對象的類型擦除掉，讓你在不知道它的類型的情況下對它執(zhí)行一些操作。舉個例子，std::function有一個帶約束的模板構(gòu)造函數(shù)，你可以用它來包裝任何參數(shù)類型匹配的可調(diào)用對象，在構(gòu)造函數(shù)結(jié)束后，不光是你，std::function也不知道它包裝的是什么類型的實例，但是operator()就可以調(diào)用那個可調(diào)用對象。我在一篇文章中剖析過std::function的實現(xiàn)，當然它還有很多種實現(xiàn)方法，其他類型擦除類的實現(xiàn)也都大同小異，它們都包含兩個要素：可能帶約束的模板構(gòu)造函數(shù)，以及函數(shù)指針，無論是可見的（直接維護）還是不可見的（使用繼承）。
為了獲得更真切的感受，我們來寫一個最簡單的類型擦除：
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>實例，調(diào)用虛函數(shù)來實現(xiàn)多態(tài)。虛函數(shù)有析構(gòu)、clone和call三個，它們分別用于MyFunction的析構(gòu)、拷貝和函數(shù)調(diào)用。
類型擦除類的實現(xiàn)中總會保留一點類型信息。MyFunction類中關(guān)于T的類型信息表現(xiàn)在FunctorWrapper的vtable中，本質(zhì)上是函數(shù)指針。類型擦除類也可以跳過繼承的工具，直接使用函數(shù)指針實現(xiàn)多態(tài)。無論使用哪種實現(xiàn)，類型擦除類總是可以被拷貝或移動或兩者兼有，多態(tài)性可以由對象本身體現(xiàn)。
不是每一滴牛奶都叫特侖蘇，也不是每一個類的實例都能被MyFunction包裝。MyFunction對T的要求是可以拷貝、可以用operator()() const調(diào)用，這些稱為類型T的“affordance”。說到affordance，普通的模板函數(shù)也對模板類型有affordance，比如std::sort要求迭代器可以隨機存取，否則編譯器會給你一堆冗長的錯誤信息。C++20引入了concept和requires子句，對編譯器和程序員都是有好處的。
每個類型擦除類的affordance都在寫成的時候確定下來。affordance被要求的方式不是繼承某個基類，而只看你這個類是否有相應的方法，就像Python那樣，只要函數(shù)接口匹配上就可以了。這種類型識別方式稱為“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通常都是一元的，也就是成員函數(shù)的參數(shù)中不含T，比如對于包裝整數(shù)的類，你可以要求T + 42，但是無法要求T + U，一個類型擦除類的實例是不知道另一個屬于同一個類但是構(gòu)造自不同類型對象的實例的信息的。我覺得這條規(guī)則有一個例外，operator==是可以想辦法支持的。
MyFunction類雖然實現(xiàn)了值多態(tài)，但還是使用了new和delete語句。如果可調(diào)用對象只是一個簡單的函數(shù)指針，是否有必要在堆上開辟空間？
SBO
小的對象保存在類實例中，大的對象交給堆并在實例中維護指針，這種技巧稱為小緩沖優(yōu)化（Small Buffer Optimization, SBO）。大多數(shù)類型擦除類都應該使用SBO以節(jié)省內(nèi)存并提升效率，問題在于SBO與繼承不共存，維護每個實例中的一個vtable或幾個函數(shù)指針是件挺麻煩的事，還會拖慢編譯速度。
但是在內(nèi)存和性能面前，這點工作量能叫事嗎？
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語言功底非常扎實！如果看不懂，實現(xiàn)中有一個可讀性更好的版本。）
現(xiàn)在的MyFunction類就充當了原來的FunctorWrapper，用vtable實現(xiàn)多態(tài)性。每當MyFunction實例被賦以一個可調(diào)用對象時，vtable被初始化為指向vtables<T>，用于T類型的vtable（這里用到了C++14的變量模板）的指針。vtable中包含4個函數(shù)指針，分別進行T實例的析構(gòu)、拷貝、移動和調(diào)用。
以析構(gòu)函數(shù)functorDestructor<T>為例，U是T經(jīng)std::decay后的類型，用于處理函數(shù)轉(zhuǎn)換為函數(shù)指針等情況。MyFunction類中定義了size字節(jié)的空間data，用于存放小的可調(diào)用對象或大的可調(diào)用對象的指針之一，functorDestructor<T>知道具體是哪種情況：當sizeof(U) <= size時，data存放可調(diào)用對象本身，把data解釋為U并調(diào)用其析構(gòu)函數(shù)~U()；當sizeof(U) > size時，data存放指針，把data解釋為U*并delete它。其他函數(shù)原理相同，注意new ((U*)&dst) U(std::forward<U>(src));是定位new語句。
除了參數(shù)為T的構(gòu)造函數(shù)以外，MyFunction的其他成員函數(shù)都通過vtable來調(diào)用T的方法，因為它們都不知道T是什么。在拷貝時，與FunctorWrapper子類的實例被裁剪不同，MyFunction的vtable一起被拷貝，依然實現(xiàn)了值多態(tài)——還避免了一部分new，符合我的意圖。但是這還沒有結(jié)束。
polymorphic_value
polymorphic_value是一個實現(xiàn)了值多態(tài)的類模板，原定于在C++20中標準化，但是C++20沒有收錄，預計會進入C++23標準（那時候我還寫不寫C++都不一定呢）。到目前為止，我對polymorphic_value源碼的理解還處于一知半解的狀態(tài)，只能簡要地介紹一下。
polymorphic_value的模板參數(shù)T是一個類類型，任何T、T的子類U、polymorphic_value<U>的實例都可以用來構(gòu)造polymorphic_value對象。polymorphic_value對象可以拷貝，其中的值也被拷貝，并且可以傳播const（通過const polymorphic_value得到的是const T&），這使它區(qū)別于unique_ptr和shared_ptr；polymorphic_value又與類型擦除不同，因為它尊重繼承，沒有使用duck typing。
然而，一個從2017年開始的，添加SBO的issue，一直沒有人回復——這反映出polymorphic_value的實現(xiàn)并不簡單——目前的版本中，無論對象的大小，polymorphic_value總會new一個control_block出來；對于從一個不同類型的polymorphic_value構(gòu)造出的實例，還會出現(xiàn)指針套指針的情況（delegating_control_block），對運行時性能有很大影響。個人認為，SBO可以把兩個問題一并解決，這也側(cè)面反映出繼承工具存在的問題。
接口
我要實現(xiàn)3個類：Shape，值多態(tài)的基類；Line，包含4個整數(shù)作為坐標，用于演示SBO的第一種情形；Rectangle，包含4個整數(shù)和一個bool值，后者指示矩形是否填充，用于演示第二種情形。它們的行為要像STL中的類一樣，有默認構(gòu)造函數(shù)、析構(gòu)函數(shù)、拷貝、移動構(gòu)造和賦值、swap，還要支持operator==和draw。operator==在兩參數(shù)類型不同時返回false，相同時比較其內(nèi)容；draw是一個多態(tài)的函數(shù)，在演示程序中輸出圖形的信息。
一個簡單的實現(xiàn)是用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;
};
下面的實現(xiàn)與這段代碼的思路是一樣的，但是更加“純粹”。
實現(xiàn)
#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();
}
對象模型
之前提到，傳統(tǒng)多態(tài)與類型擦除的本質(zhì)是相同的，都使用了函數(shù)指針，放在vtable或?qū)ο笾?。?code>Shape的繼承體系中，Line和Rectangle都是具體的類，寫兩個vtable非常容易，所以我采用了vtable的實現(xiàn)。
Line和Rectangle繼承自Shape，為了在值拷貝時不被裁剪，三個類的內(nèi)存布局必須相同，也就是說Line和Rectangle不能定義新的數(shù)據(jù)成員。Shape預留了16字節(jié)空間供子類使用，存儲Line的數(shù)據(jù)或指向Rectangle數(shù)據(jù)的指針，后者是我特意安排用于演示的（兩個static_assert只是為了確保演示到位，并非我對兩個子類的內(nèi)存布局有什么假設）。
SBO類型
ShapeData是Shape中的數(shù)據(jù)空間，儲存值或指針由ShapeData和數(shù)據(jù)類型共同決定，如果把決定的任務交給具體的數(shù)據(jù)類型，ShapeData是很難修改大小的，因此我把ShapeData設計為一個帶有模板函數(shù)的類型，以數(shù)據(jù)類型為模板參數(shù)T，提供構(gòu)造、析構(gòu)、訪問的操作，各有兩個版本，具體調(diào)用哪個可以交給編譯器來決定，從而提高程序的可維護性。
std::function同樣使用SBO，在閱讀其源碼時我發(fā)現(xiàn)，兩種情形的分界線可以不只是數(shù)據(jù)類型的大小，還有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。
虛函數(shù)表
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.
言下之意是所有函數(shù)指針大小相同。C++標準沒有這樣的規(guī)定，但是我作出這種假設（成員函數(shù)指針不包含在內(nèi)）。據(jù)我所知，在所有的主流平臺中，這種假設都是成立的。于是，我定義類型using FuncPtr = void (*)();，以FuncPtr數(shù)組為vtable，可以存放任意類型的函數(shù)指針。
vtable中存放4個函數(shù)指針，它們分別負責對象的拷貝（沒有移動）、析構(gòu)、比較（operator==）和draw。函數(shù)指針的類型各不相同，但是與子類無關(guān)，可以在Shape中定義，簡化后面的代碼。每個函數(shù)指針的下標顯然不能用0、1、2等magic number，也在Shape中定義了常量，方便維護。與default關(guān)鍵字類似地，Shape提供了前三個函數(shù)的默認實現(xiàn)，絕大多數(shù)情況下不用另寫。
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>();
}
};
方法適配
所有具有多態(tài)性質(zhì)的函數(shù)都得通過調(diào)用虛函數(shù)表中的函數(shù)來執(zhí)行操作，這包括析構(gòu)、拷貝構(gòu)造、拷貝賦值（沒有移動）、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);
}
}
拷貝構(gòu)造函數(shù)拷貝vtable和數(shù)據(jù)，析構(gòu)函數(shù)銷毀數(shù)據(jù)，拷貝賦值函數(shù)先析構(gòu)再拷貝。operator==先檢查兩個參數(shù)的vtable是否相同，只有相同，兩個參數(shù)才是同一類型，才能進行后續(xù)比較。draw調(diào)用vtable中的對應函數(shù)。所有方法都會先檢查vtable是否為nullptr，因為Shape是一個抽象類的角色，一個Shape對象是空的，任何操作都不執(zhí)行。
比較特殊的是移動和swap。由于ShapeData data中存放的是is_trivially_copyable的數(shù)據(jù)類型或指針，都是“位置無關(guān)”（可以trivially拷貝）的，因此swap中data可以直接復制。（swap在這么不trivial的情況下都能默認，給swap整一個運算符不好嗎？）
移動賦值把*this和other交換，把析構(gòu)*this的任務交給other。移動構(gòu)造也相當于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++規(guī)定的特殊成員函數(shù)，子類不會繼承其行為。
子類繼承以上所有函數(shù)。我非常想寫上final以防止子類覆寫，但是這些函數(shù)并不是C++語法上的虛函數(shù)。所以我們獲得了virtual的拷貝構(gòu)造和draw，實現(xiàn)了值多態(tài)。
討論
我翻開C++標準一查，這標準沒有實現(xiàn)細節(jié)，方方正正的每頁上都寫著“undefined behavior”幾個詞。我橫豎睡不著，仔細看了半夜，才從字縫里看出字來，滿本都寫著一個詞是“trade-off”。如果要用一句話概括值多態(tài)，那就是“更多義務，更多權(quán)利”。
安全
Shape的實現(xiàn)代碼中充斥著強制類型轉(zhuǎn)換，很容易引起對其類型安全性的質(zhì)疑。這是多慮，因為LineData和lineVtable是始終綁定在一起的，虛函數(shù)不會訪問到非對應類型的數(shù)據(jù)。即使在這一點上出錯，只要數(shù)據(jù)類型是比較trivial的（不包含指針之類的），起碼程序不會崩潰。不過類型安全性的前提是基類與派生類的大小相同，如果客戶違反了這一點，那我只好使出C/C++傳統(tǒng)藝能——undefined behavior了。
類型安全不等同于“類型正確”——我隨便起的名字。在上面的演示程序中，如果我std::swap(line, rect)，line就會存儲一個Rectangle實例，但line在語法上卻是一個Line實例！也就是說，Line和Rectangle只能在定義變量時保證類型正確，在此之后它們就和Shape通假了。
類型安全保證不會訪問到非法的地址空間，那么內(nèi)存泄漏是否會發(fā)生？構(gòu)造時按照SBO的第二種情況new，而析構(gòu)時按照第一種情況trivially析構(gòu)，這種情況是不可能發(fā)生的。首先前提是數(shù)據(jù)類型與vtable配對，在此基礎上vtable中拷貝與析構(gòu)配對。這些函數(shù)選擇哪個版本是在編譯期決定的，這更加讓人放心。
還有異常安全。只要客戶遵守一些異常處理的規(guī)則，使得Shape的析構(gòu)函數(shù)能夠被調(diào)用，就能確保不會有資源未釋放。
性能
空間上，值多態(tài)難免浪費空間。預留的數(shù)據(jù)區(qū)域需要足夠大，才能存下大多數(shù)類型的數(shù)據(jù)，對于其中較小的有很多空間被浪費，對于大到放不進的只存放一個指針，也是一種浪費。富有創(chuàng)意的你還可以把一部分trivial的數(shù)據(jù)放在本地，其他的維護一個指針，但是那樣也太麻煩了吧。
時間上，值多態(tài)的動態(tài)部分有更好的表現(xiàn)。相比于基于繼承的類型擦除，值多態(tài)在創(chuàng)建對象時少一次new，使用時少一次解引用；相比于函數(shù)指針的類型擦除，值多態(tài)在創(chuàng)建值多態(tài)只需維護一個vtable指針。相比于虛函數(shù)，值多態(tài)的初衷就是避免new和delete。不過，虛函數(shù)是編譯器負責的，編譯器要是有什么猥瑣優(yōu)化，那我認輸。
但是值多態(tài)的靜態(tài)部分不盡人意。在傳統(tǒng)多態(tài)中，如果一個多態(tài)實例的類型在編譯期可以確定，那么虛函數(shù)會靜態(tài)決議，不通過vtable而直接調(diào)用函數(shù)。在值多態(tài)中，子類可以覆寫基類的普通“虛函數(shù)”，提升運行時性能，但是對于拷貝控制函數(shù)，無論子類是否覆寫，編譯器總會調(diào)用基類的對應函數(shù)，而它們的任務是多態(tài)拷貝，子類沒有必要，有時也不能覆寫，更無法靜態(tài)決議了。不過考慮到line非Line的情況，還是老老實實用動態(tài)決議吧。
時間和空間有權(quán)衡的余地。為了讓更多子類的數(shù)據(jù)可以放在本地，基類中的數(shù)據(jù)空間可以保留得大一些，但是也會浪費更多空間；可以把vtable中的函數(shù)指針直接放在對象中，多占用一些空間，換來每次使用時減少一次解引用；拷貝、析構(gòu)和比較可以合并為一個函數(shù)以節(jié)省空間，但是需要多一個參數(shù)指明何種操作?？傊?，傳統(tǒng)藝能implementation-defined。
擴展
我要給Line加上一個子類ThickLine，表示一定寬度的直線。在計算機的屏幕上繪制傾斜曲線常用Bresenham算法，我對它不太熟悉，希望程序能打印一些調(diào)試信息，所以給Line加上一個虛函數(shù)debug（而Rectangle繪制起來很容易）。當然，不是C++語法上的虛函數(shù)。
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中加入數(shù)據(jù)比想象中困難。Line的構(gòu)造函數(shù)會把SBO數(shù)據(jù)段作為LineData來構(gòu)造，但是ThickLine需要的是ThickLineData，在LineData上再次構(gòu)造ThickLine是不安全的，因此我仿照Shape給Line加上一個protected構(gòu)造函數(shù)，并把LineData開放給ThickLine，定義ThickLineData，其中包含LineData。
這個例子說明，值多態(tài)不只適用于一群派生類直接繼承一個抽象基類的情況，可以擴展到任何單繼承的繼承鏈/樹，包括繼承抽象類與非抽象類，其中后者稍微麻煩一些，需要基類把數(shù)據(jù)類型開放給派生類，讓派生類將基類數(shù)據(jù)與新增數(shù)據(jù)進行組合。這一定程度上破壞了基類的封裝性，解決辦法是把方法定義在數(shù)據(jù)類型中，讓值多態(tài)類起適配器的作用。
單繼承并不能概括所有“is-a”的關(guān)系，有時多重繼承和虛繼承是必要的，值多態(tài)能否支持呢？答曰：不可能，因為多繼承下的派生類的實例的大小大于任何一個基類，這與值多態(tài)要求基類與派生類內(nèi)存布局一致相矛盾。這應該是值多態(tài)最明顯的局限性了吧。
模式
沒有強制子類不定義數(shù)據(jù)成員的手段帶來潛在的安全問題，編譯器自動調(diào)用基類拷貝函數(shù)使靜態(tài)決議不再可能，派生類甚至還要破壞基類數(shù)據(jù)的封裝性，這些問題有沒有解決方案呢？在C語言中，類似的問題被Cfront編譯器解決，很容易想到值多態(tài)是否可以成為一種編程語言的默認多態(tài)行為。我認為是可以的，它尤其適合比較小的設備，但是有些問題需要考慮。
剛剛證明了單繼承可行而多繼承不可行，這種編程語言只能允許單繼承。那么介于單繼承和多繼承之間的，去除了數(shù)據(jù)成員的累贅的多繼承，類似于Java和C#中的interface，是否可行呢？我沒有細想，隱隱約約感覺是有解決方案的。
基類中預留多少數(shù)據(jù)空間？如果由程序員來決定，程序員胡亂寫個數(shù)字，單片機有8、16、32位的，這樣做使代碼可移植性降低?；蛘哂删幾g器來決定，比如要使50%的子類數(shù)據(jù)可以放在本地。這看起來很和諧，但是思考一下你會發(fā)現(xiàn)它對鏈接器不友好。更糟糕的是，如果有這樣的定義：
class A { };
class B { };
class A1 : public A { B b; };
class B1 : public B { A a; };
要決定A的大小，就得先決定B的；要決定B的大小，還得先決定A的……嗯，可以出一道算法題了。
想那么多干什么，說得好像我學過編譯原理似的。
次于語法，值多態(tài)是否可以一般化，寫成一個通用的庫？polymorphic_value是一個現(xiàn)成但不完美的答案，它的主要問題在于不能通過polymorphic_value<D>實例直接構(gòu)造polymorphic_value<B>實例（其中D是B的派生類），這會導致極端情況下調(diào)用一個方法的時間復雜度為\(O(h)\)（其中\(zhòng)(h\)為繼承鏈的長度）。還有一個小細節(jié)是裸的值多態(tài)永遠勝于任何類庫的：可以直接寫shape.draw()而無需shape->draw()，后者形如指針的語義有一些誤導性。不過polymorphic_value支持多繼承與虛繼承，這是值多態(tài)永遠比不上的。
我苦思冥想了很久，覺得就算C++究極進化成了C++++也不可能存在一個類模板能對值多態(tài)類的設計有什么幫助，唯有退而求其次地用宏。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),
);
效果一般，并沒有簡化很多。不僅如此，如果不想讓自己的值多態(tài)類支持operator==的話，還得寫一個新的宏，非常死板。
再次于工具，值多態(tài)是否可以成為一種設計模式呢？我認為它具有成為設計模式的潛質(zhì)，因為各個值多態(tài)類都具有相似的內(nèi)存布局，可以把共用代碼抽離出來寫成宏。但是，由于我沒有在任何地方看到過這種用法，現(xiàn)在還不能大張旗鼓地把它作為一種設計模式來宣揚。Anyway，讓值多態(tài)成為一種設計模式是我的愿景。（誰還不想搞一點發(fā)明創(chuàng)造呢？）
比較
值多態(tài)處于傳統(tǒng)多態(tài)與類型擦除之間，與C++中現(xiàn)有的各種多態(tài)實現(xiàn)方式相比，在它的適用范圍內(nèi)，具有集大成的優(yōu)勢。
與傳統(tǒng)多態(tài)相比，值多態(tài)保留了繼承的工具與思維方式，但是與傳統(tǒng)多態(tài)的指針語義不同，值多態(tài)是值語義的，多態(tài)性可以在值拷貝時被保留。值語義的多態(tài)的意義不僅在于帶來方便，更有消除潛在的bug——C/C++的指針被人詬病得還不夠嗎？
與類型擦除相比，值多態(tài)同樣使用值語義（類型擦除界也有引用語義的），但是并非duck typing而是選擇了較為傳統(tǒng)的繼承。duck typing在靜態(tài)類型語言C++中處處受限：類型擦除類的實例可以由duck來構(gòu)造但是無法還原；類型擦除類有固定的affordance，如std::function要求operator()，即使用上適配器可以搞定Shape，但對于兩個多態(tài)函數(shù)的Line和ThickLine還是束手無策。繼承作為C++原生特性不存在這些問題，更重要的是繼承是C++和很多其他語言的程序員所習慣的思維方式。
與polymorphic_value相比，值多態(tài)用普適性換取了運行時的性能和實現(xiàn)上的自由——畢竟除SBOData以外的類都是自己寫的。在類型轉(zhuǎn)換時，polymorphic_value會套娃，而值多態(tài)不會，并且能不能轉(zhuǎn)換可以由編譯器說了算。值多態(tài)的類型對客戶完全開放，用不用SBO、SBO多大都可以按需控制，甚至可以人為干預向下類型轉(zhuǎn)換。當然，自由的代價是更長的代碼。
總結(jié)
值多態(tài)是一種介于傳統(tǒng)多態(tài)與類型擦除之間的多態(tài)實現(xiàn)方式，借鑒了值語義，保留了繼承，在單繼承的適用范圍內(nèi)，程序和程序員都能從中受益。本文也是《深度探索C++對象模型》中“Function語意學”一章的最佳實踐。
換個內(nèi)存大一點的單片機，屁事都沒有了——技術(shù)不夠，成本來湊。
參考
Polymorphism (computer science) - Wikipedia
A polymorphic value-type for C++
N3337: Working Draft, Standard for Programming Language C++
到此這篇關(guān)于C++值多態(tài)中的傳統(tǒng)多態(tài)與類型擦除的文章就介紹到這了,更多相關(guān)c++ 值多態(tài)類型擦除內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！
相關(guān)文章
這篇文章主要為大家詳細介紹了C語言實現(xiàn)推箱子游戲完整代碼，文中示例代碼介紹的非常詳細，具有一定的參考價值，感興趣的小伙伴們可以參考一下2020-12-12
桶排序或所謂的箱排序，是一個排序算法，工作的原理是將數(shù)組分到有限數(shù)量的桶子，本文詳細的介紹了如何實現(xiàn)，感興趣的可以了解一下2021-07-07
C/C++?Qt?數(shù)據(jù)庫與TreeView組件綁定詳解
本篇文章主要介紹了QT數(shù)據(jù)庫與View組件的綁定，通過數(shù)據(jù)庫與組件關(guān)聯(lián)可實現(xiàn)動態(tài)展示數(shù)據(jù)庫中的表記錄。感興趣的小伙伴可以了解一下2021-12-12
本章主要介紹C語言與C++的內(nèi)存管理，以C++的內(nèi)存分布作為引入，介紹C++不同于C語言的內(nèi)存管理方式（new?delete對比?malloc?free)，感興趣的朋友來看看吧2022-07-07
這篇文章主要為大家詳細介紹了C++基于EasyX圖形庫實現(xiàn)2048小游戲，文中示例代碼介紹的非常詳細，具有一定的參考價值，感興趣的小伙伴們可以參考一下2020-02-02
今天小編就為大家分享一篇關(guān)于判斷兩顆二叉樹是否相似的兩種方法，小編覺得內(nèi)容挺不錯的，現(xiàn)在分享給大家，具有很好的參考價值，需要的朋友一起跟隨小編來看看吧2019-03-03
Visual?Studio?Code?配置C、C++?文件debug調(diào)試環(huán)境的詳細過程
這篇文章主要介紹了Visual?Studio?Code?配置C、C++?文件debug調(diào)試環(huán)境,本文通過圖文并茂的形式給大家介紹的非常詳細，對大家的學習或工作具有一定的參考借鑒價值，需要的朋友可以參考下2022-02-02
這篇文章主要介紹了C++保存HBITMAP為位圖文件的實現(xiàn)方法，幫助大家更好的理解和使用c++，感興趣的朋友可以了解下2021-01-01
最先看到這個游戲代碼是python版的，后來看到有小伙伴用VC++重寫了一遍，運行之后發(fā)現(xiàn)有些小bug，便嘗試這修復了一下，并增加了些小功能，這里分享給大家。2015-03-03
這篇文章主要介紹了C++按照正態(tài)分布來排列整型數(shù)組元素的相關(guān)資料,需要的朋友可以參考下2016-07-07