Function declaration

Как упоминалось в разделе Declarations , за декларатором может следовать requires clause , который объявляет связанные constraints для функции, которые должны быть удовлетворены для того, чтобы функция была выбрана в процессе overload resolution . (пример: void f1 ( int a ) requires true ; ) Обратите внимание, что связанное ограничение является частью сигнатуры функции, но не частью типа функции.

Использование типа объекта с квалификатором volatile в качестве типа параметра или возвращаемого типа устарело.

Как и в любом объявлении, атрибуты, появляющиеся перед объявлением, и атрибуты, появляющиеся непосредственно после идентификатора внутри декларатора, применяются к объявляемой или определяемой сущности (в данном случае, к функции):

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

Однако атрибуты, появляющиеся после декларатора (в приведённом выше синтаксисе), применяются к типу функции, а не к самой функции:

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

Вывод типа возвращаемого значения

Если decl-specifier-seq объявления функции содержит ключевое слово auto , завершающий возвращаемый тип может быть опущен и будет выведен компилятором из типа операнда, используемого в неотброшенном return выражении. Если возвращаемый тип не использует decltype ( auto ) , вывод следует правилам template argument deduction :

int x = 1;
auto f() { return x; }        // тип возвращаемого значения - int
const auto& f() { return x; } // тип возвращаемого значения - const int&

Если возвращаемый тип - decltype ( auto ) , то возвращаемый тип определяется так, как если бы операнд, используемый в операторе return, был обёрнут в decltype :

int x = 1;
decltype(auto) f() { return x; }  // тип возвращаемого значения - int, такой же как decltype(x)
decltype(auto) f() { return(x); } // тип возвращаемого значения - int&, такой же как decltype((x))

(примечание: " const decltype ( auto ) & " является ошибкой, decltype ( auto ) должен использоваться самостоятельно)

Если присутствует несколько операторов return, все они должны выводить один и тот же тип:

auto f(bool val)
{
    if (val) return 123; // выводит тип возвращаемого значения int
    else return 3.14f;   // Ошибка: выводит тип возвращаемого значения float
}

Если отсутствует оператор return или если операнд оператора return является void-выражением (включая операторы return без операнда), объявленный возвращаемый тип должен быть либо decltype ( auto ) , в этом случае выведенный возвращаемый тип будет void , либо (возможно cv-квалифицированный) auto , в этом случае выведенный возвращаемый тип будет (идентично cv-квалифицированным) void :

auto f() {}              // возвращает void
auto g() { return f(); } // возвращает void
auto* x() {}             // Ошибка: невозможно вывести auto* из void

Как только оператор return был обнаружен в функции, тип возвращаемого значения, выведенный из этого оператора, может использоваться в остальной части функции, включая другие операторы return:

auto sum(int i)
{
    if (i == 1)
        return i;              // возвращаемый тип sum - int
    else
        return sum(i - 1) + i; // OK: возвращаемый тип sum уже известен
}

Если оператор return использует список инициализации в фигурных скобках , вывод типа не допускается:

auto func() { return {1, 2, 3}; } // Ошибка

Виртуальные функции и корутины (since C++20) не могут использовать вывод типа возвращаемого значения:

struct F
{
    virtual auto f() { return 2; } // Ошибка
};

Шаблоны функций , за исключением пользовательских функций преобразования , могут использовать вывод типа возвращаемого значения. Вывод происходит при инстанциации, даже если выражение в return statement не является зависимым . Данное инстанцирование не находится в непосредственном контексте для целей SFINAE .

template<class T>
auto f(T t) { return t; }
typedef decltype(f(1)) fint_t;    // инстанцирует f<int> для определения возвращаемого типа
template<class T>
auto f(T* t) { return *t; }
void g() { int (*p)(int*) = &f; } // инстанцирует обе версии f для определения возвращаемых типов,
                                  // выбирает вторую перегрузку шаблона

Переобъявления или специализации функций или шаблонов функций, использующие вывод типа возвращаемого значения, должны использовать те же заполнители для типа возвращаемого значения:

auto f(int num) { return num; }
// int f(int num);            // Ошибка: нет типа-заполнителя возвращаемого значения
// decltype(auto) f(int num); // Ошибка: другой заполнитель
template<typename T>
auto g(T t) { return t; }
template auto g(int);     // OK: тип возвращаемого значения - int
// template char g(char); // Ошибка: не является специализацией основного шаблона g

Аналогично, переобъявления или специализации функций или шаблонов функций, которые не используют вывод возвращаемого типа, не должны использовать заполнитель:

int f(int num);
// auto f(int num) { return num; } // Ошибка: не является переобъявлением f
template<typename T>
T g(T t) { return t; }
template int g(int);      // OK: специализация T как int
// template auto g(char); // Ошибка: не является специализацией основного шаблона g

Явные объявления инстанцирования сами по себе не инстанцируют шаблоны функций, использующие вывод типа возвращаемого значения:

template<typename T>
auto f(T t) { return t; }
extern template auto f(int); // не инстанцирует f<int>
int (*p)(int) = f; // инстанцирует f<int> для определения возвращаемого типа,
                   // но явное определение инстанцирования
                   // всё равно требуется где-то в программе

Если любой из параметров функции использует заполнитель (либо auto , либо тип концепта ), то объявление функции является объявлением сокращенного шаблона функции :

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

Объявление параметра со спецификатором this (синтаксис ( 2 ) / ( 5 ) ) объявляет явный объектный параметр .

Явный объектный параметр не может быть пачкой параметров функции и может появляться только в качестве первого параметра в списке параметров в следующих объявлениях:

• объявление функции-члена или шаблона функции-члена
• явное инстанцирование или явная специализация шаблонной функции-члена
• объявление лямбды

Функция-член с явным объектным параметром имеет следующие ограничения:

• Функция не может быть static .
• Функция не может быть virtual .
• Декларатор функции не содержит cv и 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

• Если спецификация исключений является не выбрасывающей , тип объявленной функции -
  "derived-declarator-type-list noexcept function of
  parameter-type-list cv  (optional) ref   (optional) returning T ".

В синтаксисе (2) , предполагая noptr-declarator как самостоятельное объявление, при условии, что тип qualified-id или unqualified-id в noptr-declarator равен "derived-declarator-type-list T " ( T должен быть auto в этом случае):

• Если спецификация исключений является non-throwing , тип объявленной функции:
  "derived-declarator-type-list noexcept function of
  parameter-type-list cv  (optional) ref   (optional) returning trailing ".

• The (until C++17) Otherwise, the (since C++17) тип объявленной функции:
  "derived-declarator-type-list function of
  parameter-type-list cv  (optional) ref   (optional) returning trailing ".

attr , если присутствует, применяется к типу функции.

• ref

• завершающая requires клауза

• Если функция является нетemplate friend функцией с завершающей requires клаузой, её сигнатура содержит включающий класс вместо включающего пространства имён. Сигнатура также содержит завершающую requires клаузу.

Если определение функции содержит virt-specs , оно должно определять функцию-член .

Если определение функции содержит requires-clause , оно должно определять шаблонную функцию .

Функции по умолчанию

Если определение функции имеет синтаксис ( 3 ) , функция определяется как явно стандартная .

Функция, которая явно объявлена как default, должна быть специальной функцией-членом или функцией оператора сравнения (начиная с C++20) , и она не должна иметь аргументов по умолчанию .

Явно определенная по умолчанию специальная функция-член F1 может отличаться от соответствующей специальной функции-члена F2 , которая была бы неявно объявлена, следующим образом:

• F1 и F2 могут иметь различные ref и/или except .
• Если F2 имеет необъектный параметр типа const C & , соответствующий необъектный параметр F1 может иметь тип C& .

Если тип F1 отличается от типа F2 способом, отличным от разрешенного предыдущими правилами, тогда:

• Если F1 является оператором присваивания, и возвращаемый тип F1 отличается от возвращаемого типа F2 или тип необъектного параметра F1 не является ссылкой, программа является некорректной.
• Иначе, если F1 явно объявлен как default при первом объявлении, он определяется как deleted.
• Иначе программа является некорректной.

Функция, явно заданная по умолчанию при первом объявлении, неявно является inline и неявно constexpr, если она может быть constexpr function .

struct S
{
    S(int a = 0) = default;             // ошибка: аргумент по умолчанию
    void operator=(const S&) = default; // ошибка: несоответствующий тип возвращаемого значения
    ~S() noexcept(false) = default;     // OK, другая спецификация исключений
private:
    int i;
    S(S&);          // OK, приватный конструктор копирования
};
S::S(S&) = default; // OK, определяет конструктор копирования

Явно-определенные по умолчанию функции и неявно объявленные функции вместе называются defaulted функциями. Их фактические определения будут предоставлены неявно, подробности смотрите на соответствующих страницах.

Удалённые функции

Если определение функции имеет синтаксис ( 4 ) или ( 5 ) (начиная с C++26) , функция определяется как явно удалённая .

Любое использование удалённой функции является некорректным (программа не скомпилируется). Это включает вызовы — как явные (с оператором вызова функции), так и неявные (вызов удалённого перегруженного оператора, специальной функции-члена, функции выделения памяти и т.д.), создание указателя или указателя на член на удалённую функцию, и даже использование удалённой функции в выражении, которое не является потенциально вычисляемым .

Нечистая виртуальная функция-член может быть определена как удалённая (deleted), даже если она неявно odr-used . Удалённая функция может быть переопределена только удалёнными функциями, а неудалённая функция может быть переопределена только неудалёнными функциями.

Если функция перегружена, разрешение перегрузки происходит сначала, и программа является некорректной только если удалённая функция была выбрана:

struct T
{
    void* operator new(std::size_t) = delete;
    void* operator new[](std::size_t) = delete("new[] is deleted"); // since C++26
};
T* p = new T;    // Ошибка: попытка вызова удалённого T::operator new
T* p = new T[5]; // Ошибка: попытка вызова удалённого T::operator new[],
                 //        выводит диагностическое сообщение "new[] is deleted"

Удалённое определение функции должно быть первым объявлением в единице трансляции: ранее объявленная функция не может быть переобъявлена как удалённая:

struct T { T(); };
T::T() = delete; // Ошибка: должно быть удалено при первом объявлении

Пользовательские функции

Функция является предоставленной пользователем если она объявлена пользователем и не является явно defaulted или deleted при первом объявлении. Предоставленная пользователем явно defaulted функция (т.е. явно defaulted после первого объявления) определяется в точке, где она явно defaulted; если такая функция неявно определяется как deleted, программа является некорректной. Объявление функции как defaulted после первого объявления может обеспечить эффективное выполнение и краткое определение, одновременно позволяя стабильный бинарный интерфейс для развивающейся кодовой базы.

// Все специальные функции-члены «trivial»
// определены по умолчанию в своих первых объявлениях соответственно,
// они не являются предоставленными пользователем
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(); // первое объявление
};
// не определен по умолчанию при первом объявлении,
// предоставлен пользователем и определен здесь
nontrivial::nontrivial() = default;

Разрешение Неоднозначностей

В случае неоднозначности между телом функции и инициализатором , начинающимся с { или = (since C++26) , неоднозначность разрешается проверкой типа деклараторного идентификатора для noptr-declarator :

• Если тип является функциональным типом, неоднозначная последовательность токенов трактуется как тело функции.
• В противном случае неоднозначная последовательность токенов трактуется как инициализатор.

using T = void(); // тип функции
using U = int;    // не функциональный тип
T a{}; // определяет функцию, не выполняющую действий
U b{}; // инициализирует значение объекта int
T c = delete("hello"); // определяет функцию как удаленную
U d = delete("hello"); // копирует инициализацию объекта int с
                       // результатом выражения delete (некорректно)

__func__

В теле функции предопределенная локальная переменная __func__ определяется так, как если бы

static const char __func__[] = "имя-функции";

Эта переменная имеет блочную область видимости и статическую продолжительность хранения:

struct S
{
    S(): s(__func__) {} // OK: список инициализации является частью тела функции
    const char* s;
};
void f(const char* s = __func__); // Ошибка: список параметров является частью декларатора

#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

Спецификаторы контракта функции

Объявления функций и лямбда-выражения могут содержать последовательность спецификаторов контракта функции  , каждый спецификатор имеет следующий синтаксис:

Утверждение предусловия и утверждение постусловия вместе называются утверждением контракта функции  .

Утверждение контракта функции — это утверждение контракта , связанное с функцией. Предикат утверждения контракта функции представляет собой его предикат контекстно преобразованный в bool .

Следующие функции не могут быть объявлены с спецификаторами контракта функции:

• виртуальные функции
• удалённые функции
• функции заданные по умолчанию при их первых объявлениях

Утверждения предусловий

Утверждение предусловия связано с входом в функцию:

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

Постусловия утверждений

Постусловие ассерта связано с нормальным выходом из функции.

Если постусловие содержит identifier , спецификатор контракта функции вводит identifier как имя result binding для связанной функции. Result binding обозначает объект или ссылку, возвращаемые вызовом этой функции. Тип result binding соответствует возвращаемому типу связанной функции.

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))
        // выход через исключение никогда не вызывает нарушение контракта
        throw std::invalid_argument("Неверный аргумент");
    return std::sin(num);
}

Если постусловие содержит идентификатор , а возвращаемый тип связанной функции является (возможно, cv-квалифицированным) void , программа является некорректно сформированной:

void f() post(r : r > 0); // Ошибка: для "r" не может быть связано значение

Когда объявленный возвращаемый тип нетemplated функции содержит тип-заполнитель , постусловие с идентификатором  может появляться только в определении функции:

auto g(auto&) post(r : r >= 0); // OK, "g" является шаблоном
auto h() post(r : r >= 0);      // Ошибка: невозможно указать имя возвращаемого значения
auto k() post(r : r >= 0)       // OK, "k" является определением
{
    return 0;
}

Согласованность контрактов

Переобъявление redeclaration D функции или шаблона функции func должно либо не иметь contract-specs , либо иметь те же contract-specs , что и любое первое объявление F , достижимое из D . Если D и F находятся в разных единицах трансляции, диагностика требуется только если D прикреплено к именованному модулю.

Если объявление F1 является первым объявлением func в одной единице трансляции, а объявление F2 является первым объявлением func в другой единице трансляции, F1 и F2 должны указывать одинаковые contract-specs , диагностика не требуется.

Два contract-specs  одинаковы, если они состоят из одинаковых спецификаторов контрактов функций в одинаковом порядке.

Спецификатор контракта функции C1 в объявлении функции D1 совпадает со спецификатором контракта функции C2 в объявлении функции D2 при выполнении всех следующих условий:

• Предикаты predicate  C1 и C2 удовлетворяли бы правилу одного определения при размещении в определениях функций на объявлениях D1 и D2 (если D1 и D2 находятся в разных единицах трансляции, соответствующие сущности, определённые внутри каждого predicate ведут себя как единая сущность с единственным определением), соответственно, за исключением следующих переименований:
  • Переименование параметров объявленной функции.
  • Переименование параметров шаблона, охватывающего объявленную функцию.
  • Переименование привязки результата (если имеется).
• Оба C1 и C2 имеют identifier или оба не имеют.

Если это условие не выполняется исключительно из-за сравнения двух лямбда-выражений, которые содержатся в predicate s, диагностика не требуется.

bool b1, b2;
void f() pre (b1) pre([]{ return b2; }());
void f(); // OK, спецификаторы контракта функции опущены
void f() pre (b1) pre([]{ return b2; }()); // Ошибка: замыкания имеют разные типы
void f() pre (b1); // Ошибка: спецификаторы контракта функции различаются
int g() post(r : b1);
int g() post(b1); // Ошибка: отсутствует привязка результата
namespace N
{
    void h() pre (b1);
    bool b1;
    void h() pre (b1); // Ошибка: спецификаторы контракта функции различаются
                       //        согласно правилу одного определения
}