Default arguments

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); // 정상: "k"의 기본 인자는 동일한 범위의
                          // 이전 선언에서 제공됨
void g(int, int = 7);
void h()
{
    void g(int = 1, int); // 오류: 동일한 범위가 아님
}

int g(int n = 0, ...); // 정상

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를 찾음
                     // 이 시점에서 값이 1인 ::a의 값은 사용되지 않음
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(); // 정상: Derived::f(7) 호출
    d.f(); // 오류: 기본 인자가 없음
}

void f()
{
    int n = 1;
    extern void g(int x = n); // 오류: 지역 변수는 기본 인수로 사용할 수 없음
    extern void h(int x = sizeof n); // CWG 2082부터 허용됨
}

class A
{
    void f(A* p = this) {} // 오류: 허용되지 않음
};

int b;
class X
{
    int a;
    int mem1(int i = a); // 오류: 비정적 멤버를 사용할 수 없음
    int mem2(int i = b); // OK: 조회 결과 X::b 정적 멤버를 찾음
    int mem3(int X::* i = &X::a); // OK: 비정적 멤버를 사용할 수 있음
    int mem4(int i = x.a); // OK: 멤버 접근 표현식 내에서
    static X x;
    static int b;
};

int a;
int f(int a, int b = a); // 오류: 기본 인수에서 사용된 매개변수 a
int g(int a, int b = sizeof a); // CWG 2082 해결 전까지 오류
                                // 해결 후 정상: 평가되지 않은 컨텍스트에서의 사용은 허용됨

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)

class C
{
    int operator++(int i = 0); // 잘못된 형식
    int operator[](int j = 0); // C++23부터 허용됨
    int operator()(int k = 0); // 허용됨
};

void f1(int*=0);         // 오류: 여기서 "*="는 예상치 못한 토큰입니다
void g1(const int&=0);   // 오류: 여기서 "&="는 예상치 못한 토큰입니다
void f2(int* = 0);       // 정상
void g2(const int& = 0); // 정상
void h(int&&=0);         // 공백 없어도 정상, "&&"는 여기서 토큰입니다