Как разрешить неоднозначность в перегруженных функциях с помощью SFINAE

Если вы хотите отдать приоритет случаю с общедоступными x/y, вы можете сделать это:

template<class T>
auto translate_point_impl(int, T &p, int x, int y) -> decltype(p.x, p.y, void())
{
    p.x += x;
    p.y += y;
}

template<class T>
auto translate_point_impl(char, T &p, int x, int y) -> decltype(p[0], void())
{
    p[0] += x;
    p[1] += y;
}

template<class T>
void translate_point(T &p, int x, int y) {
    translate_point_impl(0, p, x, y);
}

Само собой разумеется, что противоположная конфигурация задается переключением типов первого параметра.

Если у вас есть три или более вариантов (говорит N), вы можете использовать трюк, основанный на шаблонах.
Вот пример выше после перехода на такую ​​структуру:

template<std::size_t N>
struct choice: choice<N-1> {};

template<>
struct choice<0> {};

template<class T>
auto translate_point_impl(choice<1>, T &p, int x, int y) -> decltype(p.x, p.y, void()) {
    p.x += x; p.y += y;
}

template<class T>
auto translate_point_impl(choice<0>, T &p, int x, int y) -> decltype(p[0], void()) {
    p[0] += x;
    p[1] += y;
}

template<class T>
void translate_point(T &p, int x, int y) {
    // use choice<N> as first argument
    translate_point_impl(choice<1>{}, p, x, y);
}

Как видите, теперь N может принимать любое значение.

Вы можете предоставить перегрузку для StupidPoint:

auto translate_point(StupidPoint &p, int x, int y)
{
    p.x += x;
    p.y += y;
}

живой пример

Другое решение:

Поскольку operator[] является константой для StupidPoint, вы можете проверить это в своем условии SFINAE:

template<class T>
auto translate_point(T &p, int x, int y) -> decltype(p[0] += 0, void())
{
    p[0] += x;
    p[1] += y;
}

живой пример

Вы также можете использовать другой подход, основанный на признаках типа, для выбора соответствующей функции translate_point:

template<typename T, typename = void>
struct has_x_y : std::false_type { };

template<typename T>
struct has_x_y<T, decltype(std::declval<T>().x, std::declval<T>().y, void())> : std::true_type { };

template<typename T, typename = void>
struct has_index : std::false_type { };

template<typename T>
struct has_index<T, decltype(std::declval<T>().operator[](0), void())> : std::true_type { };

template<class T>
std::enable_if_t<has_x_y<T>::value> translate_point(T &p, int x, int y)
{
    p.x += x;
    p.y += y;
}

template<class T>
std::enable_if_t<!has_x_y<T>::value && has_index<T>::value> translate_point(T &p, int x, int y)
{
    p[0] += x;
    p[1] += y;
}

живой пример

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

template<class T>
auto translate_point(T &p, int x, int y) -> decltype(p.x += x, p.y += y, void()) { ... };

template<class T>
auto translate_point(T &p, int x, int y) -> decltype(p[1] += y, void()) { ... } // prefer checking 1, so you don't allow an operator[] that takes a pointer

Теперь, если бы operator[] вместо этого вернул int&, это все равно было бы неоднозначно. В этом случае вам понадобится способ упорядочить две перегрузки (может быть, с дополнительным аргументом int или ...?) или просто запретить этот случай. Это отдельное конструкторское решение.

С SFINAE я бы сделал что-то вроде этого:

template<class T, bool>
auto translate_point(T &p, int x, int y) -> decltype(p[0], void())
{
    p[0] += x;
    p[1] += y;
}

template<class T, bool = std::is_base_of<StupidPoint, T>::value>
auto translate_point(T &p, int x, int y) -> decltype(p.x, p.y, void())
{
    p.x += x;
    p.y += y;
}

При этом, когда T = (класс с StupidPoint в качестве базового класса), будет вызвана вторая перегрузка.

Но проще с простой перегрузкой, как указал м.с.