Типы техники стирания
(Под стиранием типов я имею в виду скрытие некоторой или всей информации о типах, относящихся к классу, что-то вроде Boost.Any.)
Я хочу овладеть техниками стирания типов, а также поделиться теми, о которых я знаю. Я надеюсь найти какую-то сумасшедшую технику, о которой кто-то подумал в свой мрачный час.:)
Первый и наиболее очевидный и общепринятый подход, который я знаю, - это виртуальные функции. Просто скройте реализацию вашего класса в иерархии классов на основе интерфейса. Многие библиотеки Boost делают это, например Boost.Any делает это, чтобы скрыть ваш тип, а Boost.Shared_ptr делает это, чтобы скрыть (de) механизм выделения.
Затем есть опция с указателями на шаблонные функции, в то же время удерживая реальный объект в void* указатель, как Boost.Function делает, чтобы скрыть реальный тип функтора. Примеры реализации можно найти в конце вопроса.
Итак, для моего актуального вопроса:
Какие еще методы стирания вы знаете? Пожалуйста, предоставьте им, если возможно, пример кода, варианты использования, ваш опыт работы с ними и, возможно, ссылки для дальнейшего чтения.
редактировать
(Поскольку я не был уверен, стоит ли добавлять это в качестве ответа или просто редактировать вопрос, я просто сделаю более безопасный.)
Еще один приятный способ скрыть фактический тип чего-либо без виртуальных функций или void* Это то, что GMan использует здесь, в связи с моим вопросом о том, как именно это работает.
Пример кода:
#include <iostream>
#include <string>
// NOTE: The class name indicates the underlying type erasure technique
// this behaves like the Boost.Any type w.r.t. implementation details
class Any_Virtual{
struct holder_base{
virtual ~holder_base(){}
virtual holder_base* clone() const = 0;
};
template<class T>
struct holder : holder_base{
holder()
: held_()
{}
holder(T const& t)
: held_(t)
{}
virtual ~holder(){
}
virtual holder_base* clone() const {
return new holder<T>(*this);
}
T held_;
};
public:
Any_Virtual()
: storage_(0)
{}
Any_Virtual(Any_Virtual const& other)
: storage_(other.storage_->clone())
{}
template<class T>
Any_Virtual(T const& t)
: storage_(new holder<T>(t))
{}
~Any_Virtual(){
Clear();
}
Any_Virtual& operator=(Any_Virtual const& other){
Clear();
storage_ = other.storage_->clone();
return *this;
}
template<class T>
Any_Virtual& operator=(T const& t){
Clear();
storage_ = new holder<T>(t);
return *this;
}
void Clear(){
if(storage_)
delete storage_;
}
template<class T>
T& As(){
return static_cast<holder<T>*>(storage_)->held_;
}
private:
holder_base* storage_;
};
// the following demonstrates the use of void pointers
// and function pointers to templated operate functions
// to safely hide the type
enum Operation{
CopyTag,
DeleteTag
};
template<class T>
void Operate(void*const& in, void*& out, Operation op){
switch(op){
case CopyTag:
out = new T(*static_cast<T*>(in));
return;
case DeleteTag:
delete static_cast<T*>(out);
}
}
class Any_VoidPtr{
public:
Any_VoidPtr()
: object_(0)
, operate_(0)
{}
Any_VoidPtr(Any_VoidPtr const& other)
: object_(0)
, operate_(other.operate_)
{
if(other.object_)
operate_(other.object_, object_, CopyTag);
}
template<class T>
Any_VoidPtr(T const& t)
: object_(new T(t))
, operate_(&Operate<T>)
{}
~Any_VoidPtr(){
Clear();
}
Any_VoidPtr& operator=(Any_VoidPtr const& other){
Clear();
operate_ = other.operate_;
operate_(other.object_, object_, CopyTag);
return *this;
}
template<class T>
Any_VoidPtr& operator=(T const& t){
Clear();
object_ = new T(t);
operate_ = &Operate<T>;
return *this;
}
void Clear(){
if(object_)
operate_(0,object_,DeleteTag);
object_ = 0;
}
template<class T>
T& As(){
return *static_cast<T*>(object_);
}
private:
typedef void (*OperateFunc)(void*const&,void*&,Operation);
void* object_;
OperateFunc operate_;
};
int main(){
Any_Virtual a = 6;
std::cout << a.As<int>() << std::endl;
a = std::string("oh hi!");
std::cout << a.As<std::string>() << std::endl;
Any_Virtual av2 = a;
Any_VoidPtr a2 = 42;
std::cout << a2.As<int>() << std::endl;
Any_VoidPtr a3 = a.As<std::string>();
a2 = a3;
a2.As<std::string>() += " - again!";
std::cout << "a2: " << a2.As<std::string>() << std::endl;
std::cout << "a3: " << a3.As<std::string>() << std::endl;
a3 = a;
a3.As<Any_Virtual>().As<std::string>() += " - and yet again!!";
std::cout << "a: " << a.As<std::string>() << std::endl;
std::cout << "a3->a: " << a3.As<Any_Virtual>().As<std::string>() << std::endl;
std::cin.get();
}
6 ответов
Все методы стирания типов в C++ выполняются с помощью указателей на функции (для поведения) и void* (для данных). "Разные" методы просто отличаются тем, как они добавляют семантический сахар. Виртуальные функции, например, просто семантический сахар для
struct Class {
struct vtable {
void (*dtor)(Class*);
void (*func)(Class*,double);
} * vtbl
};
iow: функциональные указатели.
Тем не менее, есть одна техника, которая мне особенно нравится: shared_ptr<void>просто потому, что это поражает воображение людей, которые не знают, что вы можете сделать это: вы можете хранить любые данные в shared_ptr<void>и до сих пор есть правильный деструктор, вызванный в конце, потому что shared_ptr Конструктор является шаблоном функции и по умолчанию будет использовать тип фактического объекта, переданного для создания средства удаления:
{
const shared_ptr<void> sp( new A );
} // calls A::~A() here
Конечно, это просто обычный void*/ Функция-указатель типа стирает, но очень удобно упакована.
По сути, это ваши варианты: виртуальные функции или указатели функций.
То, как вы храните данные и связываете их с функциями, может варьироваться. Например, вы можете хранить указатель на базу и иметь производный класс, содержащий данные и реализации виртуальных функций, или вы можете хранить данные в другом месте (например, в отдельно выделенном буфере) и просто иметь производный класс, предоставляющий реализации виртуальных функций, которые принимают void* это указывает на данные. Если вы храните данные в отдельном буфере, вы можете использовать указатели функций, а не виртуальные функции.
Хранение указателя на базу хорошо работает в этом контексте, даже если данные хранятся отдельно, если есть несколько операций, которые вы хотите применить к стертым данным. В противном случае вы получите несколько указателей на функции (по одному для каждой из стертых по типу функций) или функции с параметром, который задает выполняемую операцию.
Я также хотел бы рассмотреть (похоже на void*) использование "сырого хранилища": char buffer[N],
В C++0x у вас есть std::aligned_storage<Size,Align>::type за это.
Вы можете хранить там все, что захотите, при условии, что он достаточно мал и вы правильно справляетесь с выравниванием.
Страуструп, в языке программирования C++ (4-е издание) §25.3, утверждает:
Варианты использования единого представления времени выполнения для значений ряда типов и использования системы (статических) типов для гарантии того, что они используются только в соответствии с объявленным типом, называются стиранием типов.
В частности, не требуется использование виртуальных функций или указателей на функции для удаления типов, если мы используем шаблоны. Случай, уже упомянутый в других ответах, о правильном вызове деструктора в соответствии с типом, сохраненным в std::shared_ptr<void> пример тому.
Пример, приведенный в книге Страуструпа, столь же приятен.
Подумайте о реализации template<class T> class Vector контейнер вдоль линий std::vector, Когда вы будете использовать свой Vector с большим количеством разных типов указателей, как это часто бывает, компилятор предположительно будет генерировать различный код для каждого типа указателя.
Это раздувание кода можно предотвратить, определив специализацию Vector для void* указатели, а затем использовать эту специализацию в качестве общей базовой реализации Vector<T*> для всех остальных типов T:
template<typename T>
class Vector<T*> : private Vector<void*>{
// all the dirty work is done once in the base class only
public:
// ...
// static type system ensures that a reference of right type is returned
T*& operator[](size_t i) { return reinterpret_cast<T*&>(Vector<void*>::operator[](i)); }
};
Как видите, у нас есть строго типизированный контейнер, но Vector<Animal*>, Vector<Dog*>, Vector<Cat*>,..., будет использовать один и тот же (C++ и двоичный) код для реализации, а их тип указателя будет удален void*,
См. Эту серию постов для (довольно короткого) списка методов стирания типов и обсуждения компромиссов: Часть I, Часть II, Часть III, Часть IV.
Я еще не упомянул о Adobe.Poly и Boost.Variant, которые в некоторой степени можно считать стиранием типов.
Как утверждает Марк, можно использовать приведение std::shared_ptr<void>, Например, сохраните тип в указателе функции, приведите его и сохраните в функторе только одного типа:
#include <iostream>
#include <memory>
#include <functional>
using voidFun = void(*)(std::shared_ptr<void>);
template<typename T>
void fun(std::shared_ptr<T> t)
{
std::cout << *t << std::endl;
}
int main()
{
std::function<void(std::shared_ptr<void>)> call;
call = reinterpret_cast<voidFun>(fun<std::string>);
call(std::make_shared<std::string>("Hi there!"));
call = reinterpret_cast<voidFun>(fun<int>);
call(std::make_shared<int>(33));
call = reinterpret_cast<voidFun>(fun<char>);
call(std::make_shared<int>(33));
// Output:,
// Hi there!
// 33
// !
}