Default Argument

Default Parametrenin İki Kere Kullanılması
Açıklaması şöyle.

8.3.6 Default arguments
...
⁹ A default argument is evaluated each time the function is called with no argument for the corresponding parameter. The order of evaluation of function arguments is unspecified. Consequently, parameters of a function shall not be used in a default argument, even if they are not evaluated.

Örnek
Şu kod derlenmez.

int f(int a, int b = a); // error: parameter a
                         // used as default argument

Örnek
Şu kod derlenmez.

static int value = 0;

int function(int &value=value) {
    return value;
}

int main() {
  function();
}

Default Parametre ve String
Örnek
String'in bir kere kurulması iyi olabilir. Şöyle yaparız.

void doThat(const std::string& name = "Unnamed"); // Bad

const std::string defaultName = "Unnamed";
void doThat(const std::string& name = defaultName); // Better

Eğer C++17 kullanıyorsak şöyle yaparız.

void doThat(std::string_view name = "Unnamed"); // Best

Örnek
Default parametre dangling reference hatasına sebep olabilir. Elimizde şöyle bir kod olsun

#include <string>

const std::string& foo(const std::string& s = std::string(""))
{
  return s;
}

int main()
{
  const std::string& s1 = foo();
  std::string s2 = foo();

  const std::string& s3 = foo("s");
  std::string s4 = foo("s");
}

Açıklaması şöyle.

In your code, both s1 and s3 are dangling references. s2 and s4 are ok.

In the first call, the temporary empty std::string object created from the default argument will be created in the context of the expression containing the call. Therefore, it will die at the end of the definition of s1, which leaves s1 dangling.

In the second call, the temporary std::string object is used to initialize s2, then it dies.

In the third call, the string literal "s" is used to create a temporary std::string object and that also dies at the end of the definition of s3, leaving s3 dangling.

In the fourth call, the temporary std::string object with value "s" is used to initialize s4 and then it dies.

Default Parametre Kullanan Metodun Template Kodla Function Olarak Geçilmesi
Açıklaması şöyle. Default parametre metod imzasına dahil edilmez.

When you pass the free function as an argument, it undergoes the function-to-pointer conversion. When that happens, the default argument (which is not a part of the function's type) is gone. It's now a pointer to a function ...

Örnek
Elimizde şöyle bir kod olsun. İkinci func seçilir, çünkü default parametre metod imzasına dahil edilmez.

template <typename F>
auto func(F f) -> decltype(f(42))
{
  int a = 51;
  return f(51);
}

template <typename F>
auto func(F f) -> decltype(f(42, 42))
{
  int a = 0;
  int b = 10;
  return f(a, b);
}

int defaultFree(int a, int b = 0)
{
  return a;
}


int foo()
{
  return func(defaultFree);  

}

Örnek
Şu kod derlenmez.

int g(int a = 2, int b = 1)
{
  return a + b;
}

template<class Func>
void generic(Func f)
{
  std::cout << f();
}

int main()
{
  generic(g);
}

g metodu template koda parametre olarak verilince sadece imzası geçer. Yani şöyledir

int (*) (int,int)