Наличие функции принимает только неконстантные значения lvalue

Ответ таков: ваш компилятор неверен.

Проверьте gcc или clang или что-то подобное, и вы получите что-то вроде этого:

prog.cpp: в функции 'int main()': prog.cpp:9:45: ошибка: неверная инициализация неконстантной ссылки типа 'std::vector&' из rvalue типа сортировки 'std::vector' (вектор{2,1,3}, вектор{3,1,2}); ^ prog.cpp: 6: 6: примечание: инициализация аргумента 1 'void sort (A &, B &) [с A = std::vector; B = std::vector]' void sort(A&X, B&Y) { }

Вы можете использовать параметр компилятора /Za, чтобы превратить это в ошибку:

error C2664: 'void sort<std::vector<int,std::allocator<_Ty>>,std::vector<_Ty,std::allocator<_Ty>>>(A &,B &)' : cannot convert argument 1
from 'std::vector<int,std::allocator<_Ty>>' to 'std::vector<int,std::allocator<_Ty>> &'
        with
        [
            _Ty=int
,            A=std::vector<int,std::allocator<int>>
,            B=std::vector<int,std::allocator<int>>
        ]
        and
        [
            _Ty=int
        ]
        and
        [
            _Ty=int
        ]
        A non-const reference may only be bound to an lvalue

Обратите внимание, что у /Za в прошлом были некоторые проблемы, и даже сейчас он все еще ломает <windows.h>, поэтому вы все равно не можете использовать его для всех единиц компиляции. В публикации 2012 года под названием "MSVC /Za считается вредным ", старший инженер Microsoft Стефан Т. Лававей даже рекомендует не использовать этот флаг, но вам также следует ознакомиться с комментариями по адресу Исправления STL в VS 2015, часть 2, где он говорит:

У нас определенно были встречи по поводу вариантов соответствия /Za и /Zc. В конечном итоге мы хотим достичь точки, в которой VC будет соответствовать стандарту по умолчанию, без необходимости запрашивать дополнительные параметры, чтобы этот путь стал наиболее часто используемым и проверенным путем. Как вы можете видеть в посте, я работал над этим в STL, удаляя нестандартные механизмы, когда это было возможно.

Так что, скорее всего, это будет ошибка компиляции по умолчанию в какой-то будущей версии MSVC.

Еще одна вещь: стандарт С++ не различает ошибки и предупреждения, он говорит только о «диагностических сообщениях». Это означает, что MSVC фактически соответствует требованиям, как только выдает предупреждение.

Как отмечается в других ответах, компилятор ошибается.

Без необходимости менять компилятор параметров компилятора:

struct sfinae_helper {};
template<bool b>
using sfinae = typename std::enable_if<b, sfinae_helper>::type*;
// sfinae_helper, because standard is dumb: void*s are illegal here

template<class A, class B,
  sfinae<!std::is_const<A>::value&&!std::is_const<B>::value> = nullptr
>
void sort(A& X, B& Y) ... // (*)

sort(vector<int>{2,1,3}, vector<int>{3,1,2});

также не сможет скомпилироваться в MSVC2013 и должен быть совместим с совместимыми компиляторами.

Обратите внимание, что выведение A и B как const X недопустимо по стандарту, но явная передача const X как A или B допустима.

Окончательный подход:

template<typename A, typename B>
void sort(A& X, B& Y) ... // (*)
template<typename A, typename B>
void sort(A&& X, B&& Y) = delete;

где мы генерируем явно удаленный файл, который следует предпочесть A&, B&. Я не знаю, правильно ли MSVC выбирает в этом случае идеально перенаправленный, но я надеюсь на это.

В качестве ответа на проблему X, которую вы пытаетесь решить, а не на проблему Y, которую вы задали... правильный ответ заключается в том, что вы не должны делать то, что пытаетесь сделать. Неспособность представить, как что-то может быть полезным, не является достаточной причиной, чтобы изо всех сил пытаться помешать людям сделать это.

И, на самом деле, мне даже не нужно предлагать это абстрактно: вот два конкретных примера, где было бы полезно принять временный объект.

Вы можете заботиться только об одном из двух объектов:

interesting_container A;
// fill A
sort(an_ordering_criterion(), A);

Контейнеры не являются «автономными»; например контейнер, который обеспечивает представление другого:

vector<int> A, B;
// fill A and B
sort(make_subsequence(A, 1, 10), make_subsequence(B, 5, 14));

Вы можете явно delete нежелательно перегружать sort функцию:

#include <iostream>
#include <vector>

#include <cstdlib>

template< typename X, typename Y >
void
sort(X &, Y &)
{
    static_assert(!std::is_const< X >{});
    static_assert(!std::is_const< Y >{});
}

template< typename X, typename Y >
int
sort(X const &, Y &) = delete;

template< typename X, typename Y >
int
sort(X &, Y const &) = delete;

template< typename X, typename Y >
int
sort(X const &, Y const &) = delete;

int
main()
{
    std::vector< int > v{1, 3, 5};
    std::vector< int > const c{2, 4, 6};
    ::sort(v, v); // valid
    { // has been explicitly deleted
        //::sort(v, c); 
        //::sort(c, v);
        //::sort(c, c);
    }
    { // not viable: expects an l-value for 1st argument
        //::sort(std::move(v), v); 
        //::sort(std::move(v), c);
        //::sort(std::move(c), v);
        //::sort(std::move(c), c);
    }
    { // not viable: expects an l-value for 2nd argument
        //::sort(v, std::move(v));
        //::sort(v, std::move(c));
        //::sort(c, std::move(v));
        //::sort(c, std::move(c));
    }
    { // not viable: expects an l-value for 1st or 2nd argument
        //::sort(std::move(v), std::move(v));
        //::sort(std::move(v), std::move(c));
        //::sort(std::move(c), std::move(v));
        //::sort(std::move(c), std::move(c));
    }
    return EXIT_SUCCESS;
}