Traditional C textbooks define lvalues and rvalues by where they sit around an assignment operator. In modern C++, that rule collapses immediately: a const int cannot sit on the left of =, yet it is an lvalue; meanwhile, a class rvalue like std::string{} = "ok" is allowed on the left of =, yet it is a prvalue. Every expression in C++—never a variable declaration—belongs to a value category governed by two independent properties.
Expressions have value categories, not variables
A variable has a declared type, such as int, const Widget&, or Widget&&. An expression appearing in code has both a non-reference type (references are stripped during expression analysis) and a value category ([basic.lval]). Keeping those two dimensions separate resolves the single biggest source of confusion around move semantics:
#include <utility>
struct Widget {};
void consume(Widget& w);
void consume(Widget&& w);
void relay(Widget&& param) {
// param's declared type is Widget&&, yet the expression `param` is an lvalue
consume(param); // calls consume(Widget&)
consume(std::move(param)); // std::move returns unnamed Widget&& -> xvalue
}Inside relay, param has a name and an addressable stack location, so the expression param is an lvalue, selecting consume(Widget&). Calling std::move(param) produces an unnamed Widget&&, which is an xvalue, selecting consume(Widget&&).