Function declaration

宣言 で述べたように、宣言子の後には requires 節 を続けることができ、これは関数の関連する 制約 を宣言します。この制約は、 オーバーロード解決 によって関数が選択されるために満たされなければなりません。（例: void f1 ( int a ) requires true ; ）関連する制約は関数のシグネチャの一部ですが、関数型の一部ではないことに注意してください。

volatile修飾されたオブジェクト型をパラメータ型または戻り値の型として使用することは非推奨です。

あらゆる宣言と同様に、宣言の前に現れる属性と、宣言子内の識別子の直後に現れる属性は両方とも、宣言または定義されているエンティティ（この場合は関数）に適用されます：

[[noreturn]] void f [[noreturn]] (); // OK: 両方の属性が関数fに適用される

しかしながら、宣言子の後に現れる属性（上記の構文では）は、関数自体ではなく関数の型に適用されます：

void f() [[noreturn]]; // エラー: この属性は関数自体に効果を持たない

戻り値型の推論

関数宣言の decl-specifier-seq にキーワード auto が含まれている場合、後置戻り値型は省略可能であり、コンパイラによって 非破棄 return 文で使用されるオペランドの型から推論されます。戻り値型が decltype ( auto ) を使用しない場合、推論は テンプレート引数推論 の規則に従います：

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 であるか、あるいは（possibly cv-qualified） auto でなければならず、この場合の推定される戻り値の型は（同一のcv修飾を持つ） void となる：

auto f() {}              // voidを返す
auto g() { return f(); } // voidを返す
auto* x() {}             // エラー: voidからauto*を推論できません

関数内でreturn文が一度見つかると、その文から推測された戻り値の型が関数の残りの部分、他のreturn文を含めて使用されるようになります：

auto sum(int i)
{
    if (i == 1)
        return i;              // sumの戻り値型はint
    else
        return sum(i - 1) + i; // OK: sumの戻り値型は既に判明している
}

戻り値の文が 波括弧で囲まれた初期化子リスト を使用する場合、推論は許可されません：

auto func() { return {1, 2, 3}; } // エラー

仮想関数 および コルーチン (C++20以降) は戻り値型の推論を使用できません：

struct F
{
    virtual auto f() { return 2; } // エラー
};

関数テンプレート のうち、 ユーザー定義変換関数 以外は戻り値型の推論を使用できます。この推論は、return文内の式が 依存名 でない場合でも、インスタンス化時に発生します。このインスタンス化は、 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をインスタンス化して戻り値の型を決定し、
                                  // 2番目のテンプレートオーバーロードを選択

戻り値の型推論を使用する関数または関数テンプレートの再宣言または特殊化は、同じ戻り値のプレースホルダーを使用する必要があります：

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 または concept type )を使用する場合、その関数宣言は 省略形関数テンプレート 宣言となる:

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 ) )は 明示的オブジェクトパラメータ を宣言する。

明示的オブジェクトパラメータは function parameter pack にはなれず、以下の宣言のパラメータリストの最初のパラメータとしてのみ現れることができる:

• member function またはmember function templateの宣言
• explicit instantiation または explicit specialization のテンプレート化されたmember function
• lambda 宣言

明示的オブジェクトパラメータを持つmember functionには以下の制限がある:

• 関数は 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

• 例外指定が 非スロー の場合、宣言される関数の型は
  「派生宣言子型リスト noexcept 関数で、
  パラメータ型リスト cv  (オプション) ref   (オプション) を引数に取り T を返す型」となる。

構文 (2) において、 noptr-declarator を独立した宣言と仮定し、 noptr-declarator 内の qualified-id または unqualified-id の型が「derived-declarator-type-list T 」である場合（この場合 T は auto でなければならない）：

• 例外指定が non-throwing の場合、宣言される関数の型は
  「derived-declarator-type-list noexcept function of
  parameter-type-list cv  (オプション) ref   (オプション) returning trailing 」となる。

• それ以外の場合、 (C++17以前) それ以外の場合、 (C++17以降) 宣言される関数の型は
  「derived-declarator-type-list function of
  parameter-type-list cv  (オプション) ref   (オプション) returning trailing 」となる。

attr が存在する場合、それは関数型に適用される。

• ref

• 末尾 requires 節

• 関数が非テンプレートの friend 関数で末尾 requires 節を持つ場合、そのシグネチャは外側の名前空間ではなく外側のクラスを含みます。シグネチャには末尾 requires 節も含まれます。

関数定義が virt-specs を含む場合、それは メンバー関数 を定義しなければならない。

関数定義が requires-clause を含む場合、それは テンプレート化された関数 を定義しなければならない。

デフォルト化関数

関数定義が構文 ( 3 ) の場合、その関数は 明示的にデフォルト化された ものとして定義されます。

明示的にデフォルト化された関数は、 特殊メンバ関数 または 比較演算子関数 (C++20以降) でなければならず、 デフォルト引数 を持ってはならない。

明示的にデフォルト化された特殊メンバ関数 F1 は、暗黙的に宣言された対応する特殊メンバ関数 F2 と以下の点で異なることが許可されています：

• F1 と F2 は異なる ref および/または except を持つ可能性があります。
• F2 が型 const C & の非オブジェクトパラメータを持つ場合、 F1 の対応する非オブジェクトパラメータは型 C& である可能性があります。

F1 の型が F2 の型と、前述の規則で許可されている以外の方法で異なる場合：

• F1 が代入演算子であり、かつ F1 の戻り値の型が F2 の戻り値の型と異なるか、または F1 の非オブジェクトパラメータ型が参照ではない場合、プログラムは不適格です。
• それ以外の場合、 F1 が最初の宣言で明示的にdefault指定されている場合、それはdeletedとして定義されます。
• それ以外の場合、プログラムは不適格です。

最初の宣言で明示的にデフォルト化された関数は、暗黙的に inline となり、また constexpr function として可能な場合には暗黙的にconstexprとなります。

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、コピーコンストラクタを定義

明示的にデフォルト化された関数と暗黙的に宣言された関数は、まとめて デフォルト化された 関数と呼ばれます。それらの実際の定義は暗黙的に提供されます。詳細については、それぞれの対応するページを参照してください。

削除された関数

関数定義が構文 ( 4 ) または ( 5 ) (C++26以降) の場合、その関数は 明示的に削除された と定義されます。

削除された関数のあらゆる使用は不適格です（プログラムはコンパイルされません）。これには、明示的な呼び出し（関数呼び出し演算子を使用）と暗黙的な呼び出し（削除されたオーバーロード演算子、特殊メンバ関数、アロケーション関数などの呼び出し）、削除された関数へのポインタまたはメンバへのポインタの構築、および potentially-evaluated ではない式における削除された関数の使用も含まれます。

非純粋仮想メンバー関数は、暗黙的に odr-used されている場合でも、deletedとして定義することができます。deleted関数はdeleted関数によってのみオーバーライドでき、非deleted関数は非deleted関数によってのみオーバーライドできます。

関数がオーバーロードされている場合、 オーバーロード解決 が最初に行われ、削除された関数が選択された場合にのみプログラムは不適格となります：

struct T
{
    void* operator new(std::size_t) = delete;
    void* operator new[](std::size_t) = delete("new[] is deleted"); // 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; // エラー: 最初の宣言で削除されなければならない

ユーザー提供関数

関数は、それがユーザー宣言されており、かつ最初の宣言で明示的にデフォルト化または削除されていない場合、 user-provided となります。ユーザー提供の明示的デフォルト化関数（すなわち、最初の宣言後に明示的にデフォルト化されたもの）は、明示的にデフォルト化された時点で定義されます。このような関数が暗黙的に削除済みとして定義される場合、プログラムは不適格となります。最初の宣言後に関数をデフォルト化として宣言することは、効率的な実行と簡潔な定義を提供するとともに、進化するコードベースへの安定したバイナリインターフェースを可能にします。

// 「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;

曖昧性解決

関数本体と 初期化子 の間の曖昧性が生じる場合で、かつ { で始まる または = (C++26以降) 場合、この曖昧性は 宣言子識別子 の型をチェックすることで解決されます noptr-declarator :

• 型が関数型の場合、曖昧なトークンシーケンスは関数本体として扱われます。
• それ以外の場合、曖昧なトークンシーケンスは初期化子として扱われます。

using T = void(); // 関数型
using U = int;    // 非関数型
T a{}; // 何もしない関数を定義
U b{}; // intオブジェクトを値初期化
T c = delete("hello"); // 関数をdeleteとして定義
U d = delete("hello"); // intオブジェクトをdelete式の結果で
                       // コピー初期化（不適格）

__func__

関数本体内部では、関数ローカルで事前定義された変数 __func__ は、以下のように定義されているかのように扱われます

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

この変数はブロックスコープと静的記憶域期間を持ちます：

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

関数契約指定子

関数宣言と lambda expressions は一連の function contract specifiers  を含むことができ、各指定子は以下の構文を持ちます:

事前条件表明と事後条件表明は総称して 関数契約表明  と呼ばれます。

関数契約表明は、関数に関連付けられた 契約表明 です。関数契約表明の述語は、 述語 が 文脈的に変換 され bool 型となったものです。

以下の関数は関数契約指定子と共に宣言することはできません：

• virtual functions
• deleted functions
• function defaulted on their first declarations

事前条件アサーション

事前条件アサーションは関数のエントリに関連付けられています：

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))
        // 例外による終了は契約違反を引き起こさない
        throw std::invalid_argument("無効な引数");
    return std::sin(num);
}

事後条件表明が identifier を持つ場合、かつ関連する関数の戻り値の型が（possibly cv-qualified） void である場合、プログラムは不適格となります：

void f() post(r : r > 0); // エラー: 「r」に値をバインドできません

非テンプレート関数の宣言された戻り値の型に プレースホルダ型 が含まれる場合、 identifier を含む事後条件アサーションは関数定義内でのみ出現できます：

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;
}

契約の一貫性

関数または関数テンプレート func の 再宣言 D は、 contract-specs を持たないか、または D から到達可能な最初の宣言 F と同じ contract-specs を持たなければなりません。 D と F が異なる翻訳単位にある場合、診断メッセージは D が名前付きモジュールに属している場合にのみ要求されます。

宣言 F1 が1つの翻訳単位における func の最初の宣言であり、宣言 F2 が別の翻訳単位における func の最初の宣言である場合、 F1 と F2 は同じ contract-specs を指定しなければならない（診断は要求されない）。

2つの contract-specs は、同じ順序で同じ関数契約指定子で構成されている場合、同一と見なされます。

関数宣言 D1 上の関数契約指定子 C1 は、以下のすべての条件が満たされる場合、関数宣言 D2 上の関数契約指定子 C2 と同じです：

• C1 と C2 の predicate は、宣言 D1 と D2 の関数定義内に配置された場合（ D1 と D2 が異なる翻訳単位にある場合、各 predicate 内で定義された対応するエンティティは単一の定義を持つ単一のエンティティであるかのように振る舞う）、以下の名前変更を除いて one-definition rule を満たすものとする：
  • 宣言された関数のパラメータの名前変更。
  • 宣言された関数を囲むテンプレートのテンプレートパラメータの名前変更。
  • 結果バインディング（存在する場合）の名前変更。
• C1 と C2 の両方が identifier を持つか、どちらも持たない。

この条件が、単に述語内に含まれる2つのラムダ式の比較のみが原因で満たされない場合、 診断は要求されません。

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); // エラー：関数契約指定子が
                       //        一定義規則に従って異なります
}