Аргументы по умолчанию

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) {} // ошибка: это не разрешено
};

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 x = 0); // OK
};

void f1(int*=0);          // Ошибка, '*=' здесь не ожижается
void g1(const int&=0);    // Ошибка, '&=' здесь не ожижается
void f2(int* = 0);        // OK
void g2(const int& = 0);  // OK
void h(int&&=0);          // ОК, даже без пробелов, '&&' здесь является токеном