What are unevaluated contexts in C++?

by

Fortunately, the standard has a handy list of those (§ 5 [expr] ¶ 8):

In some contexts, unevaluated operands appear (5.2.8, 5.3.3, 5.3.7, 7.1.6.2). An unevaluated operand is not evaluated. An unevaluated operand is considered a full-expression.

Let’s look at these in detail.

I will use the following declarations in my examples. The declared functions are never defined anywhere so if a call to them appears in an evaluated context, the program is ill-formed and we will get a link-time error. Calling them in an unevaluated context is fine, however.

int foo();  // never defined anywhere

struct widget
{
  virtual ~widget();
  static widget& get_instance();  // never defined anywhere
};

typeid

§ 5.2.8 [expr.typeid] ¶ 3:

When typeid is applied to an expression other than a glvalue of a polymorphic class type, the result refers to a std::type_info object representing the static type of the expression. Lvalue-to-rvalue (4.1), array-to-pointer (4.2), and function-to-pointer (4.3) conversions are not applied to the expression. If the type of the expression is a class type, the class shall be completely-defined. The expression is an unevaluated operand
(Clause 5).

Note the emphasized exception for polymorphic classes (a class with at least one virtual member).

Therefore, this is okay

typeid( foo() )

and yields a std::type_info object for int while this

typeid( widget::get_instance() )

is not and will probably produce a link-time error. It has to evaluate the operand because the dynamic type is determined by looking up the vptr at run-time.

<rant>I find it quite confusing that the fact whether or not the static type of the operand is polymorphic changes the semantics of the operator in such dramatic, yet subtle, ways.</rant>

sizeof

§ 5.3.3 [expr.sizeof] ¶ 1:

The sizeof operator yields the number of bytes in the object representation of its operand. The operand is either an expression, which is an unevaluated operand (Clause 5), or a parenthesized type-id. The sizeof operator shall not be applied to an expression that has function or incomplete type, to an enumeration type whose underlying type is not fixed before all its enumerators have been declared, to the parenthesized name of such types, or to a glvalue that designates a bit-field.

The following

sizeof( foo() )

is perfectly fine and equivalent to sizeof(int).

sizeof( widget::get_instance() )

is allowed too. Note, however, that it is equivalent to sizeof(widget) and therefore probably not very useful on a polymorphic return type.

noexcept

§ 5.3.7 [expr.unary.noexcept] ¶ 1:

The noexcept operator determines whether the evaluation of its operand, which is an unevaluated operand (Clause 5), can throw an exception (15.1).

The expression

noexcept( foo() )

is valid and evaluates to false.

Here is a more realistic example that is also valid.

void bar() noexcept(noexcept( widget::get_instance() ));

Note that only the inner noexcept is the operator while the outer is the specifier.

decltype

§ 7.1.6.2 [dcl.type.simple] ¶ 4.4:

The operand of the decltype specifier is an unevaluated operand (Clause 5).

The statement

decltype( foo() ) n = 42;

declares a variable n of type int and initializes it with the value 42.

auto baz() -> decltype( widget::get_instance() );

declares a function baz that takes no arguments and returns a widget&.

And that’s all there are (as of C++14).

More Related Contents:

  1. Is it possible to print a variable’s type in standard C++?
  2. What is std::move(), and when should it be used?
  3. Variadic template pack expansion
  4. How does #include work in C++? [duplicate]
  5. std::function vs template
  6. Why is the destructor of a future returned from `std::async` blocking?
  7. How to return a std::string.c_str()
  8. When is a private constructor not a private constructor?
  9. C++11 “auto” semantics
  10. Reading from ifstream won’t read whitespace
  11. Is there a non-atomic equivalent of std::shared_ptr? And why isn’t there one in ?
  12. When is overloading pass by reference (l-value and r-value) preferred to pass-by-value?
  13. Does the GotW #101 “solution” actually solve anything?
  14. Lambda capture and parameter with same name – who shadows the other? (clang vs gcc)
  15. Is there any compiler barrier which is equal to asm(“” ::: “memory”) in C++11?
  16. C++11 “overloaded lambda” with variadic template and variable capture
  17. Is it valid to bind non-const lvalue-references to rvalues in C++ 11?(modified)
  18. What’s the difference between parentheses and braces in c++ when constructing objects
  19. cc1plus: error: unrecognized command line option “-std=c++11” with g++
  20. How do I pass multiple ints into a vector at once?
  21. Is it wise to ignore gcc/clang’s “-Wmissing-braces” warning?
  22. Why does pointer to int convert to void* but pointer to function convert to bool?
  23. Can std::vector emplace_back copy construct from an element of the vector itself?
  24. boost::asio + std::future – Access violation after closing socket
  25. Which greedy initializer-list examples are lurking in the Standard Library?
  26. How does std::forward receive the correct argument?
  27. Is substitution performed on a variadic parameter pack type if the pack is empty?
  28. Undefined reference to process(std::__cxx11::basic_string … ) when compiling affdex linux sample applications
  29. C++ view types: pass by const& or by value?
  30. Overload resolution with ref-qualifiers

Leave a Comment