В C++ какие категории (lvalue, rvalue, xvalue и т. д.) могут ли попасть выражения, которые производят временные типы класса?

выражение одно и только одно из:

• lvalue
• xvalue
• prvalue

объединение выражений, которые являются lvalues и xvalues известны как glvalues.

объединение выражений, которые являются xvalues и prvalues известны как правосторонние значения.

таким образом, выражения xvalue известны как glvalues и значений rvalue.

удобная диаграмма, найденная в Альф's ответ правильно иллюстрирует отношения, которые я описал словами выше, а также находится в разделе 3.10 стандартов C++, версии C++11 и выше.

все, что я сказал выше, я подозреваю, что ОП уже знал, только из формулировки названия этого вопроса.

Общая информация:

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

то, что я добавляю, - это способ выяснить для себя, в какую из трех нижних категорий классификации попадает любое выражение: lvalue, xvalue или prvalue.

#include <type_traits>
#include <typeinfo>
#include <iostream>
#ifndef _MSC_VER
#   include <cxxabi.h>
#endif
#include <memory>
#include <string>
#include <cstdlib>

template <typename T>
std::string
expression_name()
{
    typedef typename std::remove_reference<T>::type TR;
    std::unique_ptr<char, void(*)(void*)> own
           (
#ifndef _MSC_VER
                __cxxabiv1::__cxa_demangle(typeid(TR).name(), nullptr,
                                           nullptr, nullptr),
#else
                nullptr,
#endif
                std::free
           );
    std::string r = own != nullptr ? own.get() : typeid(TR).name();
    if (std::is_const<TR>::value)
        r += "const ";
    if (std::is_volatile<TR>::value)
        r += "volatile ";
    if (std::is_lvalue_reference<T>::value)
        r = "lvalue expression of type " + r;
    else if (std::is_rvalue_reference<T>::value)
        r = "xvalue expression of type " + r;
    else
        r = "prvalue expression of type " + r;
    return r;
}

вышеуказанную функцию можно использовать как:

std::cout << "some_expression is a " << expression_name<decltype(some_expression)>() << '\n';

и это ответит на вопрос этой операции. Для пример:

int main()
{
    std::cout << "Foo(5) is a " << expression_name<decltype(Foo(5))>() << '\n';
    std::cout << "Foo(5).get_addr() is a " << expression_name<decltype(Foo(5).get_addr())>() << '\n';
    std::cout << "Foo(78) = Foo(86) is a " << expression_name<decltype(Foo(78) = Foo(86))>() << '\n';
    std::cout << "++Foo(5) is a " << expression_name<decltype(++Foo(5))>() << '\n';
    std::cout << "++(Foo(78) + Foo(86)) is a " << expression_name<decltype(++(Foo(78) + Foo(86)))>() << '\n';
    std::cout << "Foo(78) + Foo(86) is a " << expression_name<decltype(Foo(78) + Foo(86))>() << '\n';
    std::cout << "std::move(Foo(5)) is a " << expression_name<decltype(std::move(Foo(5)))>() << '\n';
    std::cout << "std::move(++Foo(5)) is a " << expression_name<decltype(std::move(++Foo(5)))>() << '\n';
}

для меня выводит:

Foo(5) is a prvalue expression of type Foo
Foo(5).get_addr() is a prvalue expression of type void*
Foo(78) = Foo(86) is a lvalue expression of type Foo
++Foo(5) is a lvalue expression of type Foo
++(Foo(78) + Foo(86)) is a lvalue expression of type Foo
Foo(78) + Foo(86) is a prvalue expression of type Foo
std::move(Foo(5)) is a xvalue expression of type Foo
std::move(++Foo(5)) is a xvalue expression of type Foo

одной области, чтобы быть осторожным в использовании этой функции:

decltype(variable_name) даст объявленный тип переменной имя. Если вы хотите открыть категорию значений выражение, когда variable_name используется (в отличие от объявленного типа), то нужно добавить дополнительные скобки (variable_name) при использовании decltype. То есть:

decltype((variable_name))

тип выражение variable_name, а не объявленный тип variable_name.

например дано:

    Foo&& foo = Foo(5);
    std::cout << "foo is a " << expression_name<decltype(foo)>() << '\n';

это ошибочное вывод:

foo is a xvalue expression of type Foo

добавьте дополнительные скобки в decltype:

    std::cout << "foo is a " << expression_name<decltype((foo))>() << '\n';

преобразование foo от имени типа в выражение. Теперь вывод:

foo is a lvalue expression of type Foo

если вы не уверены, нужно ли добавлять круглые скобки или нет, чтобы получить правильный ответ, просто добавьте их. Добавление их не сделает правильный ответ неправильным-если вы не хотите получить объявленный тип переменной, а не тип выражения. И в этом последнем случае вам нужна тесно связанная функция:type_name<T>().