This topic is currently under construction and will soon be filled with information :)

This topic is currently under construction and will soon be filled with information :)

_Skeleton descriptions are typeset in italic text,_

_so please don't remove these descriptions when editing the topic._

Level Objectives

Requires-expressions allow a developer to perform compile-time evaluation

on the validity of other expressions. These are fundamental to the ability

to write concepts. [[Compile-time programming: concepts]][1]

Requires-expressions are compile-time predicates which evaluate to true

when their specified set of expressions are all valid for a given set of

inputs.

A student should be able to:

1. Write a simple-requirement to assert the validity of an expression

To require that expressions, which evaluate to a boolean value

like `sizeof(t) == 4`, evaluate to `true` a nested-requirement is needed

(e.g., `requires sizeof(t) == 4;`). Omitting the `requires` results in a

* All requires-expression requirements terminate with a semicolon.

* simple-requirements are used to check that an expression is well-formed.

* nested-requirements are introduced with `requires` and primarily used to check the result of an expression computable by the compiler, including concepts or other requires-expressions.

* All of the above.

* Knowledge of `noexcept`

A student should be able to:

1. Write compound-requirements which test the `noexcept`ness of an expression.

2. Use a concept as the target of a compound-requirement.

* Compound-requirements allow the optional ability to test whether an expression is marked as `noexcept`, by using a trailing `noexcept` keyword.

_Skeleton descriptions are typeset in italic text,_

_so please don't remove these descriptions when editing the topic._

Functions in C++ may be overloaded with different numbers and types of

parameters. It may be of value to specify default arguments for some number

of parameters, to allow a caller to avoid specifying arguments that

Default arguments allow the omission of arguments with obvious or common

values. Also may be utilized to extend an existing function signature

without forcing changes to existing calling code.

Explain how default arguments work and how to define them.

A student should be able to:

1. Call to a function with a default argument with or without that argument specified

* When no forward-declaration exists, the definition serves as the declaration

* When multiple declarations exist, only one may specify the default for any particular parameter, but multiple declarations may specify the defaults for different parameters.

* Additional default values may be specified for other parameters in repeat declarations

* Calling an overloaded function with fewer arguments may be ambiguous with regard to an overload with default arguments

* Default value may only be specified once for each parameter among all declarations

* Default values must start from the rightmost parameter and continue leftward without gaps

* Considerations of when to use default arguments vs overload set

* All of the above.

A student should be able to:

Subsequent redeclarations of the same function may add default argument

values, which are then usable by callers.

Though a single parameter cannot be given a default argument twice in the same

_Skeleton descriptions are typeset in italic text,_

_so please don't remove these descriptions when editing the topic._