Ограничения на параметр шаблона

В C++11 можно сделать static_assert с std::is_base_of. Придется сделать базовый класс с методом ComareTo(_Ty& other); и проверять, является ли этот класс базовым классом для текущей спецификации шаблона.

В определении шаблона - пока никак. В настоящий момент такой функциональности просто не существует. Она прорабатывается на уровне комитета, но не вошла в стандарт, пока.

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

Установить ограничение на параметр шаблона просто так (из вредности) нельзя. Но зато можно проверить наличие у параметра шаблона определённой функции и в случае отсутствия таковой переключиться на отдельную специализацию шаблона.

#include <iostream>
using namespace std;

template <typename T>
class ensure_CompareTo {
    // используем SFINAE, чтобы определить наличие функции
    // когда функция есть, выбирается первый шаблон, когда нет - второй
    template <typename U> static T test(char (*)[sizeof(&U::CompareTo)]);
    template <typename U> static void test(...);
public:
    // этот алиас зависит от того, какой шаблон был выбран с помощью SFINAE
    // он равен либо исходному типу, либо void
    using type = decltype(test<T>(0));
};

// базовый шаблон массива
// второй параметр выводится автоматически из первого
// он либо совпадает с ним, когда требуемая функция есть, либо равен void
template <typename T, typename TT = typename ensure_CompareTo<T>::type>
class Array {
public:
    static const char* desc() { return "отсортированный массив"; }
};

// специализация шаблона массива для случая, когда второй параметр, выводимый
// автоматически из первого, оказался равным void, т.е. когда требуемой
// функции в параметре шаблона не оказалось
template <typename T>
class Array<T, void> {
public:
    static const char* desc() { return "просто массив"; }
};

class A {
public:
    int CompareTo(A& other);
};

class B { };

int main()
{
    cout << Array<A>::desc() << endl;
    cout << Array<B>::desc() << endl;

    return 0;
}

Не уверен, что это возможно. Но почему обязательно привязывать интерфейс сравнения к шаблону класса? Почему бы не сделать это как в Java или C#? Там есть параметризованный интерфейс Comparable (IComparable для C#), который реализуют классы, которые должны иметь возможность сравнения с экземплярами других классов. Таким образом вы получите даже большую гибкость, обеспечив возможность сравнения одновременно с несколькими типами данных:

template <class T> class Comparable {
public:
    virtual bool CompareTo(T* other) = 0;
};

template <class T> class Array : Comparable<Array<T> >, Comparable<int> {
public:
    Array() {}

    bool CompareTo(Array<T>* other) {
        return false;
    }

    bool CompareTo(int* other) {
        return false;
    }
};

int main() {
    Array<int> a;
    Array<int> b;
    int c = 123;
    a.CompareTo(&b);
    a.CompareTo(&c);
    return 0;
}

Если мы хотим просто проверить наличие члена - достаточно его вызвать.

Мы не хотим выполнять этот код, соответственно мы будем вызывать его в контексте который не приводит к выполнению кода, а именно sizeof, decltype или noexcept.

Код, который будет выполняться, во всех случаях выглядит одинаково - создание объекта с помощью std::declval<T>() и вызов метода:

std::declval<T>().CompareTo(std::declval<T&>())

Если надо проверить несколько свойств, можно использовать оператор "запятая":

std::declval<T>().f(), std::declval<T>().g()

При использовании decltype мы получаем тип, и его можно использовать как дополнительный параметр шаблона:

template<class T,
         class=decltype(std::declval<T>().CompareTo(std::declval<T&>()))>
struct Array {};

Этому decltype можно сделать псевдоним (alias)

template<class T> using has_CompareTo = decltype(std::declval<T>().CompareTo(std::declval<T&>()));
template<class T, class=has_CompareTo<T>> struct Array {};

Для sizeof и noexcept мы тоже можем использовать параметр шаблона:

template<class T, int=sizeof(std::declval<T>().CompareTo(std::declval<T&>()), 0)>
struct Array {};

, 0 на конце выражения нужно на случай если результат CompareTo имеет тип void.

Также мы можем написать это как член класса:

template<class T>
struct Array {
    enum { has_CompareTo = noexcept(std::declval<T>().CompareTo(std::declval<T&>()), 0) };
    // или
    using has_CompareTo = decltype(std::declval<T>().CompareTo(std::declval<T&>()));
};

Вариант с параметром шаблона интересен тем что он включает SFINAE, но в данном случае оно не нужно.