Встраивание функциональных объектов, функций и лямбд через шаблоны и унификация при помощи virtual на C++

Допустим, у нас есть:

#include <cstdio>
#include <utility>

struct UserType
{
};

// (1)
void Concrete(UserType&&)
{
    std::puts("Concrete(UserType&&)");
}

// (2)
void Concrete(UserType&)
{
    std::puts("Concrete(UserType&)");
}

template<typename T>
void DoForward(T&& parameter)
{
    Concrete(std::forward<T>(parameter));
}

int main()
{
    UserType value;
    // 1: аргумент (@value) у нас T& (UserType&, lvalue),
    // а параметр (@parameter) - T&& - происходит наложение
    // & + && -> получаем UserType&.
    // Вызывается (2)я версия Concrete()
    DoForward(value);

    // 2: Передаём временный обьект - 
    // аргумент (@value) у нас T&& (UserType&&, грубо говоря, rvalue),
    // а параметр (@parameter), всё тот же, T&& - происходит наложение
    // && + && -> получаем UserType&&.
    // Вызывается (1)я версия Concrete()
    DoForward(UserType{});
}

parameter в DoForward(), поскольку это шаблонная функция, попадает в (не знаю как перевести) "deduced context" — и всё что в main-е я написал, это, как раз таки, "вывод типа" параметра, который учитывает "шаблонный" тип параметра и тип аргумента функции. Из-за того, что это шаблон, как видно, мы можем получить либо rvalue либо lvalue. Всё просто: "deduced context" — юзаем forward().

Как работает forward(): для первого вызова в main-е, как я уже написал, тип parameter вывелся в UserType&, т.е., T — это UserType&. forward() принимает аргументом (всегда!) — именованную переменную — т.е., это всегда lvalue. Получаем, что forward() имеет на вход шаблонный аргумент типа UserType& и тип параметра, так же, UserType& — всё это означает, что переданный на вход аргумент — это lvalue! forward() ничего не делает.
Аналогично, для второго вызова в main-е, тип parameter вывелся в UserType&&, т.е., T — это UserType&&. Получаем, что forward() имеет на вход шаблонный аргумент типа UserType&& и параметр UserType& — переданный на вход аргумент — это rvalue! forward() делает move().

Во всех остальных случаях — у нас нет "deduced context-а" и всё, каким мы его видим, таким и есть — т.е. T&& — это rvalue — нужно делать move(). T& — это ссылка — делаем что хотим, а T — хм, переменная, которая, больше не используется, поэтому можно сделать move().

Т.е., в случае:

template<typename T>
struct NonDeducedContext
{

    static void call(T parameter)
    {
        DoForward(std::move(parameter));
    }
}

для параметра функции call() нет вывода типа, потому что он уже выведен для класса в целом (мы его указываем при инстанциировании шаблона: NonDeducedContext<UserType>). Т.е., parameter — это value type — это копия аргумента функции call(). Ниже, по коду, он нигде не используется, поэтому я спокойно его муваю, тем самым говоря, что я его больше не использую и "делайте со мной что хотите".

А лучше всего не ограничиваться ассемблером, а ещё и замерить реальное время работы.