デフォルト引数

void point(int x = 3, int y = 4);
 
point(1,2); // point(1,2) を呼びます。
point(1);   // point(1,4) を呼びます。
point();    // point(3,4) を呼びます。

int x(int = 1, int); // エラー (x の以前の宣言はないと仮定しています)。
 
void f(int n, int k = 1);
void f(int n = 0, int k); // OK、 k のデフォルトは同じスコープの以前の宣言から供給されます。
 
void g(int, int = 7);
void h() {
  void g(int = 1, int); // エラー、同じスコープではありません。
}

int g(int n = 0, ...); // OK。

void f(int, int);     // #1
void f(int, int = 7); // #2 OK、デフォルトを追加します。
 
void h() {
    f(3); // #1 と #2 が可視です。 f(3,7) の呼び出しを行います。
    void f(int = 1, int); // エラー、内側のスコープの宣言はデフォルトを取得しません。
}
 
void m() { // 新たなスコープが始まります。
    void f(int, int); // 内側のスコープの宣言。 デフォルトを持ちません。
    f(4); // エラー、 f(int, int) を呼ぶために十分な引数がありません。
    void f(int, int = 6); 
    f(4); // OK、 f(4,6); を呼びます。
    void f(int, int = 6); // エラー、同じスコープでデフォルトを再宣言できません。
}
 
void f(int = 1, int); // #3 OK、 #2 にデフォルトを追加します。
 
void n() { // 新たなスコープが始まります。
    f(); // #1、 #2、および #3 が可視です。 f(1, 7); を呼びます。
}

namespace N {
    void f(int, int = 1);
}
using N::f;
void g() {
    f(7); // f(7, 1); を呼びます。
    f();  // エラー。
}
namespace N {
    void f(int = 2, int);
}
void h() {
    f();  // f(2, 1); を呼びます。
}

int a = 1;
int f(int);
int g(int x = f(a)); // f に対する名前探索は ::f を発見し、 a に対する名前探索は ::a を発見します。
                     // ::a の値 (この時点では 1) は使用されません。
void h()
{
  a = 2;  // ::a の値を変更します。
  {
     int a = 3;
     g();       // f(2) を呼び、その戻り値を用いて g() を呼びます。
  }
}

class C {
    void f(int i = 3);
    void g(int i, int j = 99);
    C(int arg); // 非デフォルトコンストラクタ。
};
void C::f(int i = 3) {   // エラー、デフォルト引数はクラススコープ内ですでに指定されています。
}
void C::g(int i = 88, int j) { // OK、この翻訳単位では C::g は引数なしで呼べます。
}
C::C(int arg = 1) {   // エラー、このコンストラクタをデフォルトコンストラクタに転換させます。
}

struct Base {
    virtual void f(int a = 7);
};
struct Derived : Base {
    void f(int a) override;
};
void m() {
    Derived d;
    Base& b = d;
    b.f(); // OK、 Derived::f(7) を呼びます。
    d.f(); // エラー、デフォルトはありません。
}

void f() 
{
    int n = 1;
    extern void g(int x = n); // エラー、ローカル変数はデフォルトにできません。
    extern void h(int x = sizeof n); // OK (CWG 2082 以降の場合)。
}

class A {
  void f(A* p = this) { } // エラー、 this は使用できません。
};

int b;
class X {
  int a;
  int mem1(int i = a); // エラー、非静的メンバは使用できません。
  int mem2(int i = b); // OK、名前探索は静的メンバ X::b を発見します。
  static int b;
};

int a;
int f(int a, int b = a); // エラー、デフォルト引数で引数 a が使用されました。
int g(int a, int b = sizeof a); // エラー (CWG 2082 より前の場合)。
                                // OK (CWG 2082 以降の場合)。 未評価文脈における使用は OK です。

int f(int = 0);
void h() {
  int j = f(1);
  int k = f();  // f(0); を呼びます。
}
int (*p1)(int) = &f;
int (*p2)()    = &f; // エラー、 f の型は int(int) です。

void f2() {
    int i = 1;
    void g1(int = ([i]{ return i; })()); // エラー、何かキャプチャしています。
    void g2(int = ([i]{ return 0; })()); // エラー、何かキャプチャしています。
    void g3(int = ([=]{ return i; })()); // エラー、何かキャプチャしています。
    void g4(int = ([=]{ return 0; })());       // OK、キャプチャなし。
    void g5(int = ([]{ return sizeof i; })()); // OK、キャプチャなし。
}

class C {
    int operator[](int i = 0); // ill-formed。
    int operator()(int x = 0); // OK。
};