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

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

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

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

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

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

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))

(примечание: "const decltype(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 отсутствует или если аргумент оператора return - это выражение void, объявленный тип возвращаемого значения должен быть либо decltype(auto), в этом случае выведенный тип возвращаемого значения - void, или (возможно, с квалификатором cv) auto, в этом случае выведенный тип возвращаемого значения тогда (тождественно с квалификатором cv) void:

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; // okay: sum’s return type is already known
}

Если оператор return использует braced-init-list, вывод не разрешен:

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);     // okay: 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);      // okay: 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

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

template<typename... Args>
void f(Args..., ...);
 
template<typename... Args>
void f(Args... ...);
 
template<typename... Args>
void f(Args......);

Пример использования такого объявления — возможное реализация std::is_function.

#include <cstdio>
 
template<typename... Variadic, typename... Args>
constexpr void invoke(auto (*fun)(Variadic......), Args... args)
{
    fun(args...);
}
 
int main()
{
    invoke(std::printf, "%dm•%dm•%dm = %d%s%c", 2,3,7, 2*3*7, "m³", '\n');
}

Вывод:

2m•3m•7m = 42m³

• Если спецификация исключений — не выбрасывающая исключения, тип объявленной функции —
  «список типов производных деклараторов noexcept функция с
  списком типов параметров cv (необязательно) ref  (необязательно) возвращающая T».

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

• Тип(до C++17)В противном случае тип(с C++17) объявленной функции —
  «список типов производного декларатора функция от
  списка типов параметров cv (необязательно) ref  (необязательно) возвращающая trailing ».

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

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

Если вместо тела функции используется специальный синтаксис = delete;, функция определена как явным образом удаленная. Любое использование удаленной функции является ошибочным (программа не будет компилироваться). Это включает в себя вызовы, как явные (с оператором вызова функции), так и неявные (вызов удаленного перегруженного оператора, специального члена-функции, функции выделения памяти и т. д.), создание указателя или указателя на член на удаленную функцию, а также использование удаленной функции в выражении, которое не является потенциально вычисляемым. Однако, неявное ODR-использование нечистой виртуальной функции-члена, которая случайно является удаленной, разрешено.

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

struct sometype
{
    void* operator new(std::size_t) = delete;
    void* operator new[](std::size_t) = delete;
};
sometype* p = new sometype; // error: attempts to call deleted sometype::operator new

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

struct sometype { sometype(); };
sometype::sometype() = 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;

__func__

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

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

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

struct S
{
    S(): s(__func__) {} // okay: 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