Идиомы С++. Type erasure

в 5:33, , рубрики: c++, идиомы, С++, метки: ,

Хотите получить представление о том, как устроен boost::function, boost::any “под капотом”? Узнать или освежить в памяти, что скрывается за непонятной фразой “стирание типа”? В этой статье я постараюсь кратко изложить мотивацию, стоящую за этой идиомой и ключевые элементы реализации.

Мотивация

Как положить в один контейнер объекты никак не связанных друг с другом типов? Например, прочитанные из командной строки опции сразу “разложить” по разным типам и положить в единый контейнер. Или хранить внутри одного объекта “нечто” произвольного типа с единственным ограничением — наличием оператора “()” у хранимого “нечто”? Как, в общем случае, “стереть” тип любого объекта, скрыв его за объектом другого, некоего общего типа?

void*

На самом деле в С++ есть встроенный механизм, позволяющий скрыть тип любого объекта за общим типом. Это — доставшийся в наследство от С, указатель void*.

Его можно использовать, например, так:

struct A{  void foo(); };
struct B{  int bar(double); };
A a;
B b;
std::vector<void*> v;
v.push_back(&a);
v.push_back(&b);

static_cast<A*>(v[0])->foo();
static_cast<B*>(v[1])->bar(3.5);

Или так:

class void_any
{
public:
	void_any(const void* h, size_t size) : size_(size)
	{
		h_ = std::malloc(size);
		std::memcpy(h_, h, size);
	}
	void get(void*& h)
	{
		h = std::malloc(size_);
		std::memcpy(h, h_, size_);
	}
	~void_any(){ std::free(h_); }
private:
	size_t size_;
	void* h_;
};

int some_int=675321;
void_any va(&some_int, sizeof(int));
void* pi;
va.get(pi);
std::cout << *(int*)pi << std::endl;

Такая схема будет работать, но, думаю, её недостатки очевидны. Можно ошибиться при касте, передать неверный размер в конструктор, нельзя использовать с rvalue выражениями. Мы заставляем пользователя помнить о том, объект какого именно типа хранится в указателе и “вручную” приводить к этому типу. Ну а самое главный недостаток, пожалуй, в том, что мы никак не используем систему типов языка на котором пишем. Все равно что забивать гвоздь шуруповертом. Можно, но неудобно. Так как же быть?

Шаблоны и наследование

Вы уже наверное догадались, что без шаблонов здесь не обойдется. Да, действительно, в конструктор шаблонного класса (шаблонную функцию) можно передать объект любого типа и, тем самым, скрыть его тип, но этим мы не решим второй проблемы, а именно, скрыть объект любого типа за объектом одного общего типа.

template <typename T>
struct some_t{};
some_t<int> s1;
some_t<double> s2;

Во фрагменте выше s1 и s2 после инстанциирования являются объектами абсолютно разных, несвязанных типов.
К счастью, С++ не ограничивается одними шаблонами. И нам на помощь придет наследование и динамический полиморфизм. Читайте следующий раздел, чтобы понять как именно.

Реализация

Итак, от слов к делу. Нам уже ясно, что наша “обертка” не должна быть шаблоном, но при этом должна быть способна в конструкторе принять объект любого типа. Как это возможно? Правильно, с помощью шаблонного конструктора.

class any
{
public:
	template<typename T>
	any(const T& t);
//…
};

Но как теперь сохранить то, что нам передали в конструкторе? Наш класс ничего не знает о типе Т, параметризующем конструктор, поэтому так написать мы не можем:

class any
{
//...
private:
	T t_;
};

Для решения этой проблемы мы будем хранить указатель на абстрактную вспомогательную структуру, а переданное нам в конструкторе t, отдадим в структуру-шаблон, наследующую от абстрактной вспомогательной базы.

class any
{
public:

any(const T& t) : held_(new holder<T>(t)){}
//…
private:
	struct base_holder
	{
		virtual ~base_holder(){}
	};
	
	template<typename T> struct holder : base_holder
	{
		holder(const T& t) : t_(t){}
		T t_;
	};
private:
	base_holder* held_;
};

Отлично! Теперь мы можем сохранить объект любого типа в классе “any”. Дело за малым, теперь сохраненный объект надо при необходимости каким-то образом “достать” из недр нашей обертки. Для этого, к сожалению, нам придется воспользоваться RTTI. Добавим функцию, возвращающую информацию о типе хранимого значения в наши вспомогательные структуры.

struct base_holder
{	//...
	virtual const std::type_info& type_info() const = 0;
};

template<typename T> struct holder : base_holder
{	//...
	const std::type_info& type_info() const
	{
		return typeid(t_);
	}
};

Теперь написать функцию возвращения исходного объекта не составит большого труда.

template<typename U>
U cast() const
{
	if(typeid(U) != held_->type_info())
		throw std::runtime_error("Bad any cast");
	return static_cast<holder<U>* >(held_)->t_;
}

Почему RTTI нужно использовать к сожалению? Потому что, хотелось бы написать что-то вроде такого, чтобы перенести проверку типа в compile time:

U cast(typename std::enable_if<std::is_same<U, decltype(
        static_cast<holder<U>* >(held_)->t_)>::value>::type* = 0) const
	{
		return static_cast<holder<U>* >(held_)->t_;
	}

Почему такое решение не подходит? Дело в том, что

std::is_same<U, decltype(static_cast<holder<U>* >(held_)->t_)>::value

всегда будет true, независимо от того какой на самом деле тип объекта, хранящегося в holder. Такой код будет компилироваться и даже выполняться без падений (если повезет)

any a(2);
a.cast<std::string>();

Но результаты будут совсем не те, что ожидает программист.

В классе boost::function используется тот же принцип стирания типа. Косметические отличия заключаются в том, что function — шаблон, параметризуемый типами возвращаемого значения и аргументов, а во вспомогательных структурах появляется функция

virtual return_type operator()(arg_type1, .., arg_typeN);

Листинг

class any
{
public:
	template<typename T>
	any(const T& t) : held_(new holder<T>(t)){}
	~any(){ delete held_; }
	template<typename U>
	U cast() const
	{
		if(typeid(U) != held_->type_info())
			throw std::runtime_error("Bad any cast");
		return static_cast<holder<U>* >(held_)->t_;
	}
private:
	struct base_holder
	{
		virtual ~base_holder(){}
		virtual const std::type_info& type_info() const = 0;
	};
	
	template<typename T> struct holder : base_holder
	{
		holder(const T& t) : t_(t){}
		const std::type_info& type_info() const
		{
			return typeid(t_);
		}
		T t_;
	};
private:
	base_holder* held_;
};

int main() 
{
	any a(2);
	std::cout << a.cast<int>() << std::endl;
	any b(std::string("abcd"));
	try
	{
		std::cout << b.cast<double>() << std::endl;
	}
	catch(const std::exception& e)
	{
		std::cout << e.what() << std::endl;
	}
	return 0;
}

Автор: rpz

Источник

* - обязательные к заполнению поля