What is a trivial function?

Question

[basic.def.odr]/3 makes a reference to the term "nontrivial function", whose definition I couldn't find in the Standard (N4140).

[basic.def.odr]/3

A variable x whose name appears as a potentially-evaluated expression ex is odr-used by ex unless applying the lvalue-to-rvalue conversion (4.1) to x yields a constant expression (5.19) that does not invoke any nontrivial functions and, if x is an object, ex is an element of the set of potential results of an expression e, where either the lvalue-to-rvalue conversion (4.1) is applied to e, or e is a discarded-value expression (Clause 5).

Answer 1

"non-trivial function" is the complement of "trivial special member function". There are definitions for what a trivial and non-trivial default/copy/move constructor, copy/move assignment operator or destructor is - traits that only appertain to special member functions, and decide whether e.g. these need to be called under certain circumstances.

The definitions for these can be found in chapter §12.

Default constructor, §12.1/4:

A default constructor is trivial if it is not user-provided and if:

• its class has no virtual functions (10.3) and no virtual base classes (10.1), and
• no non-static data member of its class has a brace-or-equal-initializer, and
• all the direct base classes of its class have trivial default constructors, and
• for all the non-static data members of its class that are of class type (or array thereof), each such class has a trivial default constructor.

Otherwise, the default constructor is non-trivial.

Copy/move constructors, §12.8/12:

A copy/move constructor for class X is trivial if it is not user-provided, its parameter-type-list is equivalent to the parameter-type-list of an implicit declaration, and if

• class X has no virtual functions (10.3) and no virtual base classes (10.1), and
• class X has no non-static data members of volatile-qualified type, and
• the constructor selected to copy/move each direct base class subobject is trivial, and
• for each non-static data member of X that is of class type (or array thereof), the constructor selected to copy/move that member is trivial;

otherwise the copy/move constructor is non-trivial.

Copy/move assignment operator, §12.8/26:

A copy/move assignment operator for class X is trivial if it is not user-provided, its parameter-type-list is equivalent to the parameter-type-list of an implicit declaration, and if

• class X has no virtual functions (10.3) and no virtual base classes (10.1), and
• class X has no non-static data members of volatile-qualified type, and
• the assignment operator selected to copy/move each direct base class
• for each non-static data member of X that is of class type (or array thereof), the assignment operator selected to copy/move that member is trivial;

otherwise the copy/move assignment operator is non-trivial.

Destructor, §12.4/5:

A destructor is trivial if it is not user-provided and if:

• the destructor is not virtual,
• all of the direct base classes of its class have trivial destructors, and
• for all of the non-static data members of its class that are of class type (or array thereof), each such class has a trivial destructor.

Otherwise, the destructor is non-trivial

Answer 2

May be This small example will help you understand nontrivial function in the context of [basic.def.odr]/3

struct C { 
        int l; 
        constexpr C(int _l) : l(_l) { } 
        constexpr C(const C&c) : q(c.l* 2) { } 
      }; 

      int main(void) { 
        constexpr C c(42); 
        constexpr int m= c.l; 
        struct K{ 
         int foo() { return c.l; } 
        } l; 
        return l.foo(); 
      } 

If You look at the follwowing line in standard

applying the lvalue-to-rvalue conversion (4.1) to x yields a constant expression (5.19) that does not invoke any nontrivial functions

Here c satisfies the requirements for appearing in a constant expression, but applying the lvalue-to-rvalue conversion to a invokes a non-trivial function.

Why It invokes a non-trivial function?

When an lvalue-to-rvalue conversion occurs in an unevaluated operand or a subexpression thereof the value contained in the referenced object is not accessed. Otherwise, if the glvalue has a class type, the conversion copy-initializes a temporary of type T from the glvalue and the result of the conversion is a prvalue for the temporary

So a prvalue is created using the copy constructor of class C and since Copy constructor is user Declared, It is non-Trivial and Hence c is not ODR-used here

A copy/move assignment operator for class X is trivial if it is not user-provided, its parameter-type-list is equivalent to the parameter-type-list of an implicit declaration

I hope this example clarifies your doubt