Матричный шаблон C ++, неоднозначность между умножением матрицы на матрицу и числом матриц

Я собираюсь описать решение с помощью С++ 11, а затем объясню, как реализовать его в С++ 98.

В С++ 11 заголовок <type_traits> включает функции типа и предикаты типа. Это делает принудительные ограничения более удобными.

std::is_same<T1, T2>::value true, если T1 - тот же тип, что и T2 и false в противном случае.

typename std::enable_if< bool, T >::type - это четко определенный тип T если bool истинно и не определено иначе.

Когда компилятор ищет функции и методы кандидата-кандидата, он не выдает ошибку, если попытка попытки специализации терпит неудачу. Он просто выбрасывает этого кандидата. Это означает, что следующий код устранит двусмысленность:

template <typename TNum, typename T2>
typename std::enable_if< (!std::is_same<Matrix<TNum>, T2>::value),
Matrix<TNum> >::type operator*(const T2& lhs, Matrix<TNum> rhs);

При принятии этого решения учитываются только декларации. Вышеприведенная логика семантически разумна, но наглазник, чтобы читать. Таким образом, С++ 11 поддерживает псевдонимы шаблонов и функции constexpr.

template<bool B, typename T = void>
using Enable_if = typename std::enable_if<B, T>::type;

template<typename T1, typename T2>
constexpr bool Is_same(){
  return std::is_same<T1, T2>::value;
}

Вышесказанное становится следующим:

template <typename TNum, typename T2>
Enable_if<( !Is_same<Matrix<TNum>, T2>() ),
Matrix<TNum> > operator*(const T2& lhs, Matrix<TNum> rhs);

концепции предоставят инструменты, которые сделают это более удобным.

Теперь, если у вас нет С++ 11, вы не получите глазной конфеты. Но Boost обеспечивает те же функции. Предположим, что у вас их нет, их реализация не ужасна.

Функции времени компиляции зависят от нескольких языковых правил, что затрудняет их понимание. Сначала рассмотрим enable_if. Мы хотим, чтобы typename enable_if<true, T>::type был корректно определен, но typename enable_if<false, T>::type - глупость. Мы используем специализацию:

template<bool B, typename T = void>
struct enable_if {
  typedef T type;
};

template<typename T>
struct enable_if<false, T> {};

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

Чтобы реализовать is_same, нам нужно понятие true или false во время компиляции. Мы можем гарантировать это с помощью статических константных переменных. Мы хотим, чтобы is_same имело истинное значение времени компиляции, когда его аргументы шаблона одинаковы. Правила системы специализации обрабатывают это напрямую.

template<typename, typename>
struct is_same{
  static const bool value = false;
};

template<typename T>
struct is_same<T, T>{
  static const bool value = true;
};

Это должно делать то, что вы хотите. Обратите внимание, что вы можете абстрагироваться еще на один шаг и создать еще одну пару структур.

struct false_type {
  static const bool value = false;
};

struct true_type {
  static const bool value = true;
};

то is_same становится:

template<typename, typename>
struct is_same : false_type {};

template<typename T>
struct is_same<T, T> : true_type {};

что делает его больше похожим на функцию.

Я предпочитаю это для решения категории, потому что проще отделить метапрограмму в файл заголовка. Затем вы можете повторно использовать логику в другом месте. Тем не менее, если вы не используете С++ 11 или даже повышаете, создание необходимых функций времени компиляции может быть головной болью.

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