Glossary

F

forwarding reference

The term that the C++ standard uses for universal references.

full specialization

An alternative definition for a (primary) template that no longer depends on any template parameter.

function object (functor)

An object that can be used as a function. For this, operator() is defined in the class. All lambdas are function objects.

G

glvalue

A value category of expressions that produce a location for a stored value (generalized localizable value). A glvalue can be an lvalue or an xvalue.

I

incomplete type

A class, struct, or unscoped enumeration type that is declared but not defined, an array of unknown size, void (optionally with const and/or volatile), or an array of an incomplete element type.

L

lvalue

A value category of expressions that produce a location for a stored value that is not assumed to be movable (i.e., glvalues that are not xvalues). Examples are:

–Named objects (variables)

–String literals

–Returned lvalue references

–Functions and all references to functions

–Data members of lvalues

rvalue

A value category of expressions that are not lvalues. An rvalue can be a prvalue (such as a temporary object without a name) or an xvalue (e.g., an lvalue marked with std::move()). What was called an rvalue before C++11 is called a prvalue since C++11.

S

semiregular type

A type that is regular but does not provide comparison operators:

–If one object is a copy of the other, the objects are equal.

–A copy of an object is equal to an object created with the default constructor to which the source value was assigned.

–Objects have value semantics. If two objects are equal and we modify one of them, they are no longer equal.

substitution failure is not an error (SFINAE)

A mechanism that silently discards templates instead of triggering compilation errors when arguments to template parameters make their declarations ill-formed. You can use the mechanism to disable templates for certain arguments by forcing ill-formed declarations then.

small string optimization (SSO)

An approach to save allocating memory for short strings by always reserving memory for a certain number of characters. A typical value in standard library implementations is to always reserve 16 or 24 bytes of memory so that the string can have 15 or 23 characters (plus 1 byte for the null terminator) without allocating memory. This makes all string objects larger but usually saves a lot of running time because in practice, strings are often shorter than 16 or 24 characters and allocating memory on the heap is quite an expensive operation.

stateless

A function or operation is stateless if it does not change its state due to a call. This has the effect that it does not change its behavior over time and always yields the same result for the same arguments.

standard template library (STL)

The STL is the part of the C++ standard library that deals with containers (data structures), algorithms, and as glue, the iterators. This approach was adopted for the first C++ standard with the goal that programmers can benefit from various standard data structures and algorithms without having to implement them. As generic code, you still get compile-time error messages when you try to combine things that are not supported.

U

universal reference

A reference that can universally refer to any object while not making it const. It can also extend the lifetime of return values. It is declared as an rvalue reference of a template parameter (T&&) or with auto&&. Universal references are useful for perfectly forwarding arguments with std::forward<>() (for that reason, the C++ standard names them forwarding references).

However, they also are the only kind of references that can refer to any expression (both lvalues and rvalues) without making the value const. For this reason, they are necessary to declare parameters of generic functions that take views.

V

value category

A classification of expressions. The traditional value categories lvalues and rvalues were inherited from the programming language C. C++11 introduced additional categories, meaning that C++ now has the following primary value categories:

–prvalues (pure rvalues), which are values used to initialize objects (including parameters)

–lvalues (localizable values), which are objects you can ask for the address

–xvalues (eXpiring values), which are objects where we no longer need the value (usually, objects marked with std::move())

In addition, C++ has the following combined value categories:

–glvalues (generalized lvalues), which means “either lvalue or xvalue”

–rvalues (readable values), which means “either rvalue or xvalue”

variable template

A generic variable. It allows us to define variables or static members by substituting the template parameters with specific types or values.

variadic template

A template with a template parameter that represents an arbitrary number of types or values.

X

xvalue

A value category of expressions that produce a location for a stored object that can be assumed to be no longer needed. Examples are:

–Values marked with std::move()

–Returned rvalue references

–Casts of objects (not of functions) to an rvalue reference

–Value members of rvalues