Valor padrão do parâmetro da function

1

int Add (int a, int b = 3); int Add (int a, int b) { } 

2

 int Add (int a, int b); int Add (int a, int b = 3) { } 

Ambos funcionam; qual é o caminho padrão e por quê ?

Se você colocar a declaração em um arquivo de header e a definição em um arquivo .cpp separado e #include o header de um arquivo .cpp diferente, você poderá ver a diferença.

Especificamente, suponha:

lib.h

 int Add(int a, int b); 

lib.cpp

 int Add(int a, int b = 3) { ... } 

test.cpp

 #include "lib.h" int main() { Add(4); } 

A compilation de test.cpp não verá a declaração de parâmetro padrão e falhará com um erro.

Por esse motivo, a definição do parâmetro padrão é geralmente especificada na declaração da function:

lib.h

 int Add(int a, int b = 3); 

Em C ++, os requisitos impostos aos argumentos padrão em relação à sua localização na lista de parâmetros são os seguintes:

  1. O argumento padrão para um determinado parâmetro deve ser especificado não mais de uma vez. Especificá-lo mais de uma vez (mesmo com o mesmo valor padrão) é ilegal.

  2. parameters com argumentos padrão devem formar um grupo contíguo no final da lista de parâmetros.

Agora, tendo isso em mente, em C ++ você tem permissão para “aumentar” o conjunto de parâmetros que possuem argumentos padrão de uma declaração da function para a próxima, contanto que os requisitos acima sejam continuamente satisfeitos.

Por exemplo, você pode declarar uma function sem argumentos padrão

 void foo(int a, int b); 

Para chamar essa function depois de tal declaração, você terá que especificar ambos os argumentos explicitamente.

Mais tarde (mais abaixo) na mesma unidade de tradução, você pode declará-lo novamente, mas desta vez com um argumento padrão

 void foo(int a, int b = 5); 

e a partir deste ponto você pode chamá-lo com apenas um argumento explícito.

Mais abaixo você pode declará-lo novamente adicionando mais um argumento padrão

 void foo(int a = 1, int b); 

e deste ponto em diante você pode chamá-lo sem argumentos explícitos.

O exemplo completo pode parecer o seguinte

 void foo(int a, int b); int main() { foo(2, 3); void foo(int a, int b = 5); // redeclare foo(8); // OK, calls `foo(8, 5)` void foo(int a = 1, int b); // redeclare again foo(); // OK, calls `foo(1, 5)` } void foo(int a, int b) { // ... } 

Quanto ao código em sua pergunta, ambas as variantes são perfeitamente válidas, mas significam coisas diferentes. A primeira variante declara um argumento padrão para o segundo parâmetro imediatamente. A segunda variante inicialmente declara sua function sem argumentos padrão e, em seguida, adiciona uma para o segundo parâmetro.

O efeito líquido de ambas as suas declarações (ou seja, a maneira como é visto pelo código que segue a segunda declaração) é exatamente o mesmo: a function tem argumento padrão para seu segundo parâmetro. No entanto, se você conseguir espremer algum código entre a primeira e a segunda declaração, essas duas variantes se comportarão de maneira diferente. Na segunda variante, a function não possui argumentos padrão entre as declarações, portanto, você terá que especificar os dois argumentos explicitamente.

Os argumentos padrão devem ser especificados com a primeira ocorrência do nome da function – normalmente, no protótipo da function. Se o protótipo da function for omitido porque a definição da function também serve como protótipo, os argumentos padrão devem ser especificados no header da function.

A primeira maneira seria preferida à segunda.

Isso ocorre porque o arquivo de header mostrará que o parâmetro é opcional e qual será seu valor padrão. Além disso, isso garantirá que o valor padrão seja o mesmo, independentemente da implementação do arquivo .cpp correspondente.

Na segunda maneira, não há garantia de um valor padrão para o segundo parâmetro. O valor padrão pode mudar, dependendo de como o arquivo .cpp correspondente é implementado.