関数宣言

[[noreturn]] void f [[noreturn]] (); // OK、両方の属性が関数 f に適用されます。

void f() [[noreturn]]; // エラー、この属性は型に対しては効果がありません。

int x = 1;
auto f() { return x; }        // 戻り値の型は int です。
const auto& f() { return x; } // 戻り値の型は const int& です。

int x = 1;
decltype(auto) f() { return x; }  // 戻り値の型は int (decltype(x) と同じ) です。
decltype(auto) f() { return(x); } // 戻り値の型は int& (decltype((x)) と同じ) です。

auto f(bool val)
{
    if (val) return 123; // 戻り値の型は int と推定されます。
    else return 3.14f;   // エラー、戻り値の型は float と推定されます。
}

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

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}; } // エラー。

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

auto f();               // 宣言されたけれどもまだ定義されていません。
auto f() { return 42; } // 定義。 戻り値の型は int です。
int f();                // エラー、推定後の型は使用できません。
decltype(auto) f();     // エラー、異なる種類の推定。
auto f();               // OK、再宣言。
 
template<typename T>
struct A { friend T frf(T); };
auto frf(int i) { return i; } // A<int> のフレンドではありません。

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つめのテンプレートオーバーロードを選択します。

template<typename T> auto g(T t) { return t; } // #1
template auto g(int);      // OK、戻り値の型は int です。
//template char g(char);     // エラー、マッチするテンプレートがありません。
 
template<> auto g(double); // OK、戻り値の型が不明な前方宣言。
template<typename T> T g(T t) { return t; } // OK、 #1 と同等ではありません。
template char g(char);     // OK、今回はマッチするテンプレートがあります。
template auto g(float);    // まだ #1 にマッチします。
//void h() { return g(42); } // エラー、曖昧です。

template<typename T> auto f(T t) { return t; }
extern template auto f(int); // f<int> を実体化しません。
int (*p)(int) = f; // 戻り値の型を決定するために f<int> を実体化しますが、
                   // プログラム内のどこかに明示的実体化の定義が
                   // 必要なことは変わりません。

void f1(auto);    // template<class T> void f(T) と同じです。
void f2(C1 auto); // template<C1 T> void f7(T) と同じです (C1 がコンセプトの場合)。

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

struct sometype
{
    void* operator new(std::size_t) = delete;
    void* operator new[](std::size_t) = delete;
};
sometype* p = new sometype; // エラー、削除された sometype::operator new を
                            // 呼び出そうとしています。

struct sometype { sometype(); };
sometype::sometype() = delete; // エラー、最初の宣言で削除されなければなりません。

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

struct S
{
    S(): s(__func__) {} // OK、初期化子リストは関数本体の一部です。
    const char* s;
};
void f(const char* s = __func__); // エラー、引数リストは宣言子の一部です。