Объявление функции

Как упоминалось в статье Объявления, за деклараторами может следовать предложение requires, объявляющее связанные с функцией ограничения, которые должны выполняться, чтобы функция могла быть выбрана при разрешении перегрузки. (пример: 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), выведение выполняется по правилам выведения аргументов шаблона:

int x = 1;
auto f() { return x; }        // return type is int
const auto& f() { return x; } // return type is const int&

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

int x = 1;
decltype(auto) f() { return x; }  // return type is int, same as decltype(x)
decltype(auto) f() { return(x); } // return type is int&, same as decltype((x))

(примечание: «constdecltype(auto)&» — ошибка; decltype(auto) необходимо использовать отдельно)

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

auto f(bool val)
{
    if (val) return 123; // deduces return type int
    else return 3.14f;   // Error: deduces return type float
}

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

auto f() {}              // returns void
auto g() { return f(); } // returns void
auto* x() {}             // Error: cannot deduce auto* from void

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

auto sum(int i)
{
    if (i == 1)
        return i;              // sum’s return type is int
    else
        return sum(i - 1) + i; // OK: sum’s return type is already known
}

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

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

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

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

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

template<class T>
auto f(T t) { return t; }
typedef decltype(f(1)) fint_t;    // instantiates f<int> to deduce return type

template<class T>
auto f(T* t) { return *t; }
void g() { int (*p)(int*) = &f; } // instantiates both fs to determine return types,
                                  // chooses second template overload

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

auto f(int num) { return num; }
// int f(int num);            // Error: no placeholder return type
// decltype(auto) f(int num); // Error: different placeholder

template<typename T>
auto g(T t) { return t; }
template auto g(int);     // OK: return type is int
// template char g(char); // Error: not a specialization of the primary template g

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

int f(int num);
// auto f(int num) { return num; } // Error: not a redeclaration of f

template<typename T>
T g(T t) { return t; }
template int g(int);      // OK: specialize T as int
// template auto g(char); // Error: not a specialization of the primary template g

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

template<typename T>
auto f(T t) { return t; }
extern template auto f(int); // does not instantiate f<int>

int (*p)(int) = f; // instantiates f<int> to determine its return type,
                   // but an explicit instantiation definition 
                   // is still required somewhere in the program

Если в любом из параметров функции используется заполнитель (либо 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)) объявляет явный параметр объекта.

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

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

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

• Функция не является статической.
• Функция не является виртуальной.
• Декларатор функции не содержит 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

• операнд оператора рефлексии.

• ref

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

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

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

Функции, заданные по умолчанию

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

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

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

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

Если тип F1 отличается от типа F2 иначе, чем это допускается приведёнными выше правилами, то:

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

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

struct S
{
    S(int a = 0) = default;             // error: default argument
    void operator=(const S&) = default; // error: non-matching return type
    ~S() noexcept(false) = default;     // OK, different exception specification
private:
    int i;
    S(S&);          // OK, private copy constructor
};

S::S(S&) = default; // OK, defines copy constructor

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

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

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

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

Нечисто виртуальную функцию-член можно определить как удалённую, даже если она неявно используется в смысле ODR. Удалённую функцию могут переопределять только удалённые функции, а не удалённую функцию — только не удалённые функции.

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

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;    // Error: attempts to call deleted T::operator new
T* p = new T[5]; // Error: attempts to call deleted T::operator new[],
                 //        emits a diagnostic message “new[] is deleted”

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

struct T { T(); };
T::T() = delete; // Error: must be deleted on the first declaration

Функции, предоставленные пользователем

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

// All special member functions of “trivial” are
// defaulted on their first declarations respectively,
// they are not user-provided
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(); // first declaration
};

// not defaulted on the first declaration,
// it is user-provided and is defined here
nontrivial::nontrivial() = default;

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

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

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

using T = void(); // function type
using U = int;    // non-function type

T a{}; // defines a function doing nothing
U b{}; // value-initializes an int object

T c = delete("hello"); // defines a function as deleted
U d = delete("hello"); // copy-initializes an int object with
                       // the result of a delete expression (ill-formed)

__func__

В теле функции предопределённая переменная, локальная для функции, __func__ определяется так, как если бы она была объявлена следующим образом:

static const char __func__[] = "function-name";

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

struct S
{
    S(): s(__func__) {} // OK: initializer-list is part of function body
    const char* s;
};
void f(const char* s = __func__); // Error: parameter-list is part of declarator

#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

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

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

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

Утверждение контракта функции — это утверждение контракта, связанное с функцией. Предикат утверждения контракта функции — это его predicate, контекстно преобразуемый к 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 как имя привязки результата связанной функции. Привязка результата обозначает объект или ссылку, возвращаемые при вызове этой функции. Тип привязки результата совпадает с возвращаемым типом связанной функции.

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))
        // exiting via an exception never causes contract violation
        throw std::invalid_argument("Invalid argument");
    return std::sin(num);
}

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

void f() post(r : r > 0); // Error: no value can be bound to “r”

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

auto g(auto&) post(r : r >= 0); // OK, “g” is a template

auto h() post(r : r >= 0);      // Error: cannot name the return value

auto k() post(r : r >= 0)       // OK, “k” is a definition
{
    return 0;
}

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

Повторное объявление 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 , диагностика не требуется.

bool b1, b2;

void f() pre (b1) pre([]{ return b2; }());
void f(); // OK, function contract specifiers omitted
void f() pre (b1) pre([]{ return b2; }()); // Error: closures have different types
void f() pre (b1); // Error: function contract specifiers are different

int g() post(r : b1);
int g() post(b1); // Error: no result binding

namespace N
{
    void h() pre (b1);
    bool b1;
    void h() pre (b1); // Error: function contract specifiers differ
                       //        according to the one−definition rule
}