Отправка на основе типа времени компиляции

Следуя методам "Современного C++ Design", я реализую постоянную библиотеку с различными оптимизациями во время компиляции. Мне бы хотелось иметь возможность отправлять функцию в шаблонную переменную-член, если эта переменная происходит от заданного класса:

template<class T, template <class> class Manager = DefaultManager> class Data
{
private:
   T *data_;

public:
   void Dispatch()
   {
      if(SUPERSUBCLASS(Container, T))
      {
         data_->IKnowThisIsHere();
      }
      else
      {
         Manager<T>::SomeGenericFunction(data_);
      }
   }
}

Где SUPERSUBCLASS - это макрос времени компиляции для определения наследования объектов. Конечно, это терпит неудачу во всех случаях, когда T наследует от Container (или T является внутренним типом и т. Д. И т. Д.), Потому что компилятор справедливо жалуется, что IKnowThisIsHere() не является членом данных, даже если этот путь кода никогда не будет следовать, как показано здесь после предварительной обработки с T = int:

private:
   int *data_;

public:
   void Dispatch()
   {
      if(false)
      {
         data_->IKnowThisIsHere();

Компилятор явно жалуется на этот код, хотя он никогда не будет выполнен. Предложение использовать dynamic_cast также не работает, так как снова попытка преобразования типа выполняется во время компиляции, что невозможно (например, с T=double, std::string):

void Dispatch()
   {
      if(false)
      {
         dynamic_cast<Container*>(data_)->IKnowThisIsHere();

error: cannot dynamic_cast '((const Data<double, DefaultManager>*)this)->Data<double, DefaultManager>::data_' (of type 'double* const') to type 'class Container*' (source is not a pointer to class)
error: cannot dynamic_cast '((const Data<std::string, DefaultManager>*)this)->Da<sttad::string, DefaultManager>::data_' (of type 'struct std::string* const') to type 'class Container*' (source type is not polymorphic)

Мне действительно нужно эмулировать (или даже убедить!), Чтобы компилятор выдавал один набор кода, если T наследовал от Container, и другой, если это не так.

Какие-либо предложения?

Источник

6 ответов

Решение

Перегрузка может быть полезна для реализации диспетчеризации во время компиляции, как это было предложено Александреску в его книге "Современный дизайн C++".

Вы можете использовать такой класс для преобразования во время компиляции логического или целого числа в тип:

template <bool n>
struct int2type
{ enum { value = n}; };

Следующий исходный код показывает возможное приложение:

#include <iostream>

#define MACRO()   true  // <- macro used to dispatch 

template <bool n>
struct int2type
{ enum { value = n }; };

void method(int2type<false>)
{ std::cout << __PRETTY_FUNCTION__  << std::endl; }

void method(int2type<true>)
{ std::cout << __PRETTY_FUNCTION__  << std::endl; }

int
main(int argc, char *argv[])
{
    // MACRO() determines which function to call
    //

    method( int2type<MACRO()>()); 

    return 0;
}

Конечно, что действительно делает работу, так это MACRO() или лучшая реализация в качестве мета-функции

Источник

Вам требуется своего рода время компиляции if, Затем вызывается функция в зависимости от того, какой случай true, Таким образом, компилятор не наткнется на код, который он не может скомпилировать (потому что он безопасно хранится в другом шаблоне функции, который никогда не создается).

Есть несколько способов реализации такой компиляции if, Наиболее распространенным является использование идиомы SFINAE: ошибка замены не является ошибкой. Повышение-х is_base_of это на самом деле экземпляр этой идиомы. Чтобы использовать его правильно, вы не написали бы это в if выражение, а лучше использовать его в качестве типа возврата вашей функции.

Непроверенный код:

void Dispatch()
{
    myfunc(data_);
}

private:

// EDIT: disabled the default case where the specialisation matched
template <typename U>
typename enable_if_c<is_base_of<Container, U>::value, U>::type myfunc(U& data_) {
    data_->IKnowThisIsHere();
}

template <typename U>
typename disable_if_c<is_base_of<Container, U>::value, U>::type myfunc(U& data_) { // default case
    Manager<U>::SomeGenericFunction(data_);
}
Источник

У черт повышения есть кое-что для этого: is_base_of

Источник

К сожалению, я тоже через это прошел (и это также вызов времени выполнения;)) Компилятор жалуется, если вы передаете не полиморфные или классовые типы, аналогично предыдущему:

error: cannot dynamic_cast '((const Data<double, DefaultManager>*)this)->Data<double, RawManager>::data_' (of type 'double* const') to type 'class Container*' (source is not a pointer to class)

или же

error: cannot dynamic_cast '((const Data<std::string, DefaultRawManager>*)this)->Data<std::string, DefaultManager>::data_' (of type 'struct std::string* const') to type 'class Container*' (source type is not polymorphic)
Источник

Загляните в библиотеку метапрограмм Boost Template. Кроме того, в зависимости от того, что вы пытаетесь выполнить, посмотрите на библиотеку boost serialization, поскольку она может уже иметь то, что вам нужно.

Источник

Я заинтересован в том, чтобы сделать это "из первых принципов" как образовательное любопытство. Однако я посмотрю на библиотеки Boost.

В любом случае, я не думаю, что is_base_of - это какая-то помощь - она ​​делает то же самое, что и макрос SUPERSUBCLASS...

Источник
Другие вопросы по тегам