Function declaration

Como se menciona en Declarations , el declarador puede ir seguido de una requires clause , que declara las constraints asociadas para la función, las cuales deben satisfacerse para que la función sea seleccionada por overload resolution . (ejemplo: void f1 ( int a ) requires true ; ) Nótese que la constraint asociada es parte de la firma de la función, pero no forma parte del tipo de función.

Usar un tipo de objeto calificado como volatile como tipo de parámetro o tipo de retorno está obsoleto.

Al igual que con cualquier declaración, los atributos que aparecen antes de la declaración y los atributos que aparecen inmediatamente después del identificador dentro del declarador se aplican ambos a la entidad que se declara o define (en este caso, a la función):

[[noreturn]] void f [[noreturn]] (); // OK: both attributes apply to the function f

Sin embargo, los atributos que aparecen después del declarador (en la sintaxis anterior), se aplican al tipo de la función, no a la función misma:

void f() [[noreturn]]; // Error: this attribute has no effect on the function itself

Deducción del tipo de retorno

Si la secuencia-de-especificadores-de-declaración de la declaración de función contiene la palabra clave auto , el tipo de retorno posterior puede omitirse, y será deducido por el compilador del tipo del operando utilizado en la sentencia no-descartada return . Si el tipo de retorno no utiliza decltype ( auto ) , la deducción sigue las reglas de deducción de argumentos de plantilla :

int x = 1;
auto f() { return x; }        // tipo de retorno es int
const auto& f() { return x; } // tipo de retorno es const int&

Si el tipo de retorno es decltype ( auto ) , el tipo de retorno es el que se obtendría si el operando utilizado en la sentencia return estuviera envuelto en decltype :

int x = 1;
decltype(auto) f() { return x; }  // tipo de retorno es int, igual que decltype(x)
decltype(auto) f() { return(x); } // tipo de retorno es int&, igual que decltype((x))

(nota: “ const decltype ( auto ) & ” es un error, decltype ( auto ) debe usarse por sí solo)

Si hay múltiples sentencias return, todas deben deducir al mismo tipo:

auto f(bool val)
{
    if (val) return 123; // deduce el tipo de retorno int
    else return 3.14f;   // Error: deduce el tipo de retorno float
}

Si no hay una declaración de retorno o si el operando de la declaración de retorno es una expresión void (incluyendo declaraciones de retorno sin operando), el tipo de retorno declarado debe ser decltype ( auto ) , en cuyo caso el tipo de retorno deducido es void , o (posiblemente calificado cv) auto , en cuyo caso el tipo de retorno deducido es entonces (idénticamente calificado cv) void :

auto f() {}              // retorna void
auto g() { return f(); } // retorna void
auto* x() {}             // Error: no se puede deducir auto* desde void

Una vez que se ha visto una sentencia return en una función, el tipo de retorno deducido de esa sentencia puede usarse en el resto de la función, incluyendo en otras sentencias return:

auto sum(int i)
{
    if (i == 1)
        return i;              // el tipo de retorno de sum es int
    else
        return sum(i - 1) + i; // OK: el tipo de retorno de sum ya es conocido
}

Si la sentencia return utiliza una lista de inicialización entre llaves , la deducción no está permitida:

auto func() { return {1, 2, 3}; } // Error

Funciones virtuales y coroutines (desde C++20) no pueden usar deducción de tipo de retorno:

struct F
{
    virtual auto f() { return 2; } // Error
};

Plantillas de función distintas a las funciones de conversión definidas por el usuario pueden utilizar la deducción de tipo de retorno. La deducción ocurre en la instanciación incluso si la expresión en la sentencia return no es dependiente . Esta instanciación no está en un contexto inmediato para los propósitos de SFINAE .

template<class T>
auto f(T t) { return t; }
typedef decltype(f(1)) fint_t;    // instancia f<int> para deducir el tipo de retorno
template<class T>
auto f(T* t) { return *t; }
void g() { int (*p)(int*) = &f; } // instancia ambas f para determinar los tipos de retorno,
                                  // selecciona la segunda sobrecarga de plantilla

Las redeclaraciones o especializaciones de funciones o plantillas de función que utilizan deducción del tipo de retorno deben usar los mismos marcadores de posición de tipo de retorno:

auto f(int num) { return num; }
// int f(int num);            // Error: no tipo de retorno de marcador de posición
// decltype(auto) f(int num); // Error: marcador de posición diferente
template<typename T>
auto g(T t) { return t; }
template auto g(int);     // OK: el tipo de retorno es int
// template char g(char); // Error: no es una especialización de la plantilla principal g

De manera similar, las redeclaraciones o especializaciones de funciones o plantillas de funciones que no utilizan deducción del tipo de retorno no deben usar un marcador de posición:

int f(int num);
// auto f(int num) { return num; } // Error: no es una redeclaración de f
template<typename T>
T g(T t) { return t; }
template int g(int);      // OK: especializa T como int
// template auto g(char); // Error: no es una especialización de la plantilla principal g

Declaraciones de instanciación explícita no instancian por sí mismas plantillas de función que utilizan deducción de tipo de retorno:

template<typename T>
auto f(T t) { return t; }
extern template auto f(int); // no instancia f<int>
int (*p)(int) = f; // instancia f<int> para determinar su tipo de retorno,
                   // pero aún se requiere una definición de instanciación explícita
                   // en algún lugar del programa

Si alguno de los parámetros de la función utiliza un marcador de posición (ya sea auto o un tipo concepto ), la declaración de función es en cambio una declaración de plantilla de función abreviada :

void f1(auto);    // same as template<class T> void f1(T)
void f2(C1 auto); // same as template<C1 T> void f2(T), if C1 is a concept

Una declaración de parámetro con el especificador this (sintaxis ( 2 ) / ( 5 ) ) declara un parámetro de objeto explícito .

Un parámetro de objeto explícito no puede ser un paquete de parámetros de función , y solo puede aparecer como el primer parámetro de la lista de parámetros en las siguientes declaraciones:

• una declaración de una función miembro o plantilla de función miembro
• una instanciación explícita o especialización explícita de una función miembro plantillada
• una declaración de lambda

Una función miembro con un parámetro de objeto explícito tiene las siguientes restricciones:

• La función no es static .
• La función no es virtual .
• El declarador de la función no contiene cv ni ref .

struct C
{
    void f(this C& self);     // OK
    template<typename Self>
    void g(this Self&& self); // also OK for templates
    void p(this C) const;     // Error: “const” not allowed here
    static void q(this C);    // Error: “static” not allowed here
    void r(int, this C);      // Error: an explicit object parameter
                              //        can only be the first parameter
};
// void func(this C& self);   // Error: non-member functions cannot have
                              //        an explicit object parameter

• Si la especificación de excepción es no-lanzadora , el tipo de la función declarada es
  “lista-de-tipos-de-declarador-derivado noexcept función de
  lista-de-tipos-de-parámetro cv  (opcional) ref   (opcional) retornando T ”.

En la sintaxis (2) , asumiendo noptr-declarator como una declaración independiente, dado el tipo del qualified-id o unqualified-id en noptr-declarator como "derived-declarator-type-list T " ( T debe ser auto en este caso):

• Si la especificación de excepción es no-lanzadora , el tipo de la función declarada es
  "derived-declarator-type-list noexcept función de
  parameter-type-list cv  (opcional) ref   (opcional) retornando trailing ".

• El (hasta C++17) De lo contrario, el (desde C++17) tipo de la función declarada es
  "derived-declarator-type-list función de
  parameter-type-list cv  (opcional) ref   (opcional) retornando trailing ".

attr , si está presente, se aplica al tipo de función.

• ref

• cláusula requires final

• Si la función es una función friend no plantilla con una cláusula requires final, su firma contiene la clase envolvente en lugar del espacio de nombres envolvente. La firma también contiene la cláusula requires final.

Si una definición de función contiene un virt-specs , debe definir una función miembro .

Si una definición de función contiene una requires-clause , debe definir una función plantilla .

Funciones por defecto

Si la definición de la función es de sintaxis ( 3 ) , la función se define como explícitamente predeterminada .

Una función que está explícitamente predeterminada debe ser una función miembro especial o función de operador de comparación (desde C++20) , y no debe tener argumentos predeterminados .

Una función miembro especial explícitamente definida por defecto F1 puede diferir de la función miembro especial correspondiente F2 que habría sido declarada implícitamente, de la siguiente manera:

• F1 y F2 pueden tener diferentes ref y/o except .
• Si F2 tiene un parámetro no-objeto de tipo const C & , el parámetro no-objeto correspondiente de F1 puede ser de tipo C& .

Si el tipo de F1 difiere del tipo de F2 de una manera distinta a la permitida por las reglas anteriores, entonces:

• Si F1 es un operador de asignación, y el tipo de retorno de F1 difiere del tipo de retorno de F2 o el tipo de parámetro no-objeto de F1 no es una referencia, el programa está mal formado.
• De lo contrario, si F1 está explícitamente definido por defecto en su primera declaración, se define como eliminado.
• De lo contrario, el programa está mal formado.

Una función explícitamente definida por defecto en su primera declaración es implícitamente inline , y es implícitamente constexpr si puede ser una constexpr function .

struct S
{
    S(int a = 0) = default;             // error: argumento por defecto
    void operator=(const S&) = default; // error: tipo de retorno no coincide
    ~S() noexcept(false) = default;     // OK, especificación de excepción diferente
private:
    int i;
    S(S&);          // OK, constructor de copia privado
};
S::S(S&) = default; // OK, define el constructor de copia

Las funciones explícitamente predeterminadas y las funciones implícitamente declaradas se denominan colectivamente funciones predeterminadas . Sus definiciones reales serán proporcionadas implícitamente, consulte sus páginas correspondientes para más detalles.

Funciones eliminadas

Si la definición de la función es de sintaxis ( 4 ) o ( 5 ) (since C++26) , la función se define como explícitamente eliminada .

Cualquier uso de una función eliminada está mal formado (el programa no compilará). Esto incluye llamadas, tanto explícitas (con un operador de llamada a función) como implícitas (una llamada a un operador sobrecargado eliminado, función miembro especial, función de asignación, etc.), construir un puntero o puntero-a-miembro hacia una función eliminada, e incluso el uso de una función eliminada en una expresión que no es potencialmente evaluada .

Una función miembro virtual no pura puede definirse como eliminada, aunque esté implícitamente odr-used . Una función eliminada solo puede ser reemplazada por funciones eliminadas, y una función no eliminada solo puede ser reemplazada por funciones no eliminadas.

Si la función está sobrecargada, overload resolution ocurre primero, y el programa solo está mal formado si la función eliminada fue seleccionada:

struct T
{
    void* operator new(std::size_t) = delete;
    void* operator new[](std::size_t) = delete("new[] is deleted"); // desde C++26
};
T* p = new T;    // Error: intenta llamar a T::operator new eliminado
T* p = new T[5]; // Error: intenta llamar a T::operator new[] eliminado,
                 //        emite un mensaje de diagnóstico “new[] is deleted”

La definición eliminada de una función debe ser la primera declaración en una unidad de traducción: una función previamente declarada no puede ser redeclarada como eliminada:

struct T { T(); };
T::T() = delete; // Error: debe ser eliminado en la primera declaración

Funciones proporcionadas por el usuario

Una función es proporcionada por el usuario si es declarada por el usuario y no está explícitamente definida por defecto o eliminada en su primera declaración. Una función explícitamente definida por defecto proporcionada por el usuario (es decir, explícitamente definida por defecto después de su primera declaración) se define en el punto donde se define explícitamente por defecto; si dicha función se define implícitamente como eliminada, el programa está mal formado. Declarar una función como definida por defecto después de su primera declaración puede proporcionar ejecución eficiente y definición concisa mientras permite una interfaz binaria estable para una base de código en evolución.

// Todas las funciones miembro especiales de “trivial” son
// definidas por defecto en sus primeras declaraciones respectivamente,
// no son proporcionadas por el usuario
struct trivial
{
    trivial() = default;
    trivial(const trivial&) = default;
    trivial(trivial&&) = default;
    trivial& operator=(const trivial&) = default;
    trivial& operator=(trivial&&) = default;
    ~trivial() = default;
};
struct nontrivial
{
    nontrivial(); // primera declaración
};
// no definida por defecto en la primera declaración,
// es proporcionada por el usuario y está definida aquí
nontrivial::nontrivial() = default;

Resolución de Ambigüedad

En caso de ambigüedad entre un cuerpo de función y un inicializador que comienza con { o = (desde C++26) , la ambigüedad se resuelve comprobando el tipo del identificador declarador de noptr-declarator :

• Si el tipo es un tipo de función, la secuencia de tokens ambigua se trata como un cuerpo de función.
• De lo contrario, la secuencia de tokens ambigua se trata como un inicializador.

using T = void(); // tipo de función
using U = int;    // tipo no-función
T a{}; // define una función que no hace nada
U b{}; // inicializa por valor un objeto int
T c = delete("hello"); // define una función como eliminada
U d = delete("hello"); // inicializa por copia un objeto int con
                       // el resultado de una expresión delete (mal formado)

__func__

Dentro del cuerpo de la función, la variable predefinida local de la función __func__ se define como si fuera por

static const char __func__[] = "nombre-de-función";

Esta variable tiene ámbito de bloque y duración de almacenamiento estático:

struct S
{
    S(): s(__func__) {} // OK: la lista de inicializadores es parte del cuerpo de la función
    const char* s;
};
void f(const char* s = __func__); // Error: la lista de parámetros es parte del declarador

#include <iostream>
void Foo() { std::cout << __func__ << ' '; }
struct Bar
{
    Bar() { std::cout << __func__ << ' '; }
    ~Bar() { std::cout << __func__ << ' '; }
    struct Pub { Pub() { std::cout << __func__ << ' '; } };
};
int main()
{
    Foo();
    Bar bar;
    Bar::Pub pub;
}

Foo Bar Pub ~Bar

Especificadores de contrato de función

Las declaraciones de funciones y las expresiones lambda pueden contener una secuencia de especificadores de contrato de función  , cada especificador tiene la siguiente sintaxis:

La aserción de precondición y la aserción de postcondición se denominan colectivamente aserción de contrato de función  .

Una aserción de contrato de función es una aserción de contrato asociada con una función. El predicado de una aserción de contrato de función es su predicado convertido contextualmente a bool .

Las siguientes funciones no pueden declararse con especificadores de contrato de función:

• funciones virtuales
• funciones eliminadas
• función predeterminada en sus primeras declaraciones

Aserciones de precondición

Una aserción de precondición está asociada con la entrada a una función:

int divide(int dividend, int divisor) pre(divisor != 0)
{
    return dividend / divisor;
}
double square_root(double num) pre(num >= 0)
{
    return std::sqrt(num);
}

Aserciones de postcondición

Una aserción de postcondición está asociada con la salida normal de una función.

Si una aserción de postcondición tiene un identifier , el especificador de contrato de función introduce identifier como el nombre de un result binding de la función asociada. Un result binding denota el objeto o referencia devuelto por la invocación de esa función. El tipo de un result binding es el tipo de retorno de su función asociada.

int absolute_value(int num) post(r : r >= 0)
{
    return std::abs(num);
}
double sine(double num) post(r : r >= -1.0 && r <= 1.0)
{
    if (std::isnan(num) || std::isinf(num))
        // salir mediante una excepción nunca causa violación de contrato
        throw std::invalid_argument("Argumento inválido");
    return std::sin(num);
}

Si una aserción de postcondición tiene un identificador , y el tipo de retorno de la función asociada es (posiblemente calificado-cv) void , el programa está mal formado:

void f() post(r : r > 0); // Error: ningún valor puede ser asignado a "r"

Cuando el tipo de retorno declarado de una función no parametrizada contiene un tipo de marcador de posición , una aserción de poscondición con un identificador  solo puede aparecer en una definición de función:

auto g(auto&) post(r : r >= 0); // OK, "g" es una plantilla
auto h() post(r : r >= 0);      // Error: no se puede nombrar el valor de retorno
auto k() post(r : r >= 0)       // OK, "k" es una definición
{
    return 0;
}

Consistencia de contrato

Una redeclaración D de una función o plantilla de función func debe tener ya sea ninguna contract-specs o las mismas contract-specs que cualquier primera declaración F accesible desde D . Si D y F están en diferentes unidades de traducción, se requiere un diagnóstico solo si D está adjunta a un módulo con nombre.

Si una declaración F1 es la primera declaración de func en una unidad de traducción y una declaración F2 es la primera declaración de func en otra unidad de traducción, F1 y F2 deben especificar los mismos contract-specs , no se requiere diagnóstico.

Dos contract-specs son iguales si consisten en los mismos especificadores de contrato de función en el mismo orden.

Un especificador de contrato de función C1 en una declaración de función D1 es el mismo que un especificador de contrato de función C2 en una declaración de función D2 si se satisfacen todas las siguientes condiciones:

• Los predicados de C1 y C2 satisfarían la regla de una definición si se colocaran en definiciones de función en las declaraciones D1 y D2 (si D1 y D2 están en diferentes unidades de traducción, las entidades correspondientes definidas dentro de cada predicado se comportan como si hubiera una única entidad con una sola definición), respectivamente, excepto por los siguientes renombramientos:
  • El renombramiento de los parámetros de la función declarada.
  • El renombramiento de los parámetros de plantilla de una plantilla que envuelve la función declarada.
  • El renombramiento del enlace de resultado (si existe).
• Tanto C1 como C2 tienen un identificador o ninguno lo tiene.

Si esta condición no se cumple únicamente debido a la comparación de dos expresiones lambda que están contenidas dentro de los predicate s, no se requiere ningún diagnóstico.

bool b1, b2;
void f() pre (b1) pre([]{ return b2; }());
void f(); // OK, especificadores de contrato de función omitidos
void f() pre (b1) pre([]{ return b2; }()); // Error: los closures tienen tipos diferentes
void f() pre (b1); // Error: los especificadores de contrato de función son diferentes
int g() post(r : b1);
int g() post(b1); // Error: no hay vinculación de resultado
namespace N
{
    void h() pre (b1);
    bool b1;
    void h() pre (b1); // Error: los especificadores de contrato de función difieren
                       //        según la regla de una definición
}