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)
{

}

Beide arbeiten; Welches ist der Standardweg und warum ?

Wenn Sie die Deklaration in eine Header-Datei und die Definition in eine separate .cppDatei und #includeden Header aus einer anderen .cppDatei einfügen, können Sie den Unterschied erkennen.

Nehmen wir insbesondere an:

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);
}

Bei der Kompilierung von test.cppwird die Standardparameterdeklaration nicht angezeigt und ein Fehler schlägt fehl.

Aus diesem Grund wird die Standardparameterdefinition normalerweise in der Funktionsdeklaration angegeben :

lib.h.

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

In C ++ lauten die Anforderungen an Standardargumente hinsichtlich ihrer Position in der Parameterliste wie folgt:

1. Das Standardargument für einen bestimmten Parameter darf nicht mehr als einmal angegeben werden. Die mehrmalige Angabe (auch bei gleichem Standardwert) ist unzulässig.

2. Parameter mit Standardargumenten müssen am Ende der Parameterliste eine zusammenhängende Gruppe bilden.

Unter Berücksichtigung dessen können Sie in C ++ den Parametersatz "erweitern", der Standardargumente von einer Deklaration der Funktion zur nächsten enthält, solange die oben genannten Anforderungen kontinuierlich erfüllt werden.

Sie können beispielsweise eine Funktion ohne Standardargumente deklarieren

void foo(int a, int b);

Um diese Funktion nach einer solchen Deklaration aufzurufen, müssen Sie beide Argumente explizit angeben.

Später (weiter unten) in derselben Übersetzungseinheit können Sie sie erneut deklarieren, diesmal jedoch mit einem Standardargument

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

und von diesem Punkt an können Sie es mit nur einem expliziten Argument aufrufen.

Weiter unten können Sie es erneut deklarieren und ein weiteres Standardargument hinzufügen

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

und von diesem Punkt an können Sie es ohne explizite Argumente aufrufen.

Das vollständige Beispiel könnte wie folgt aussehen

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)
{
  // ...
}

Was den Code in Ihrer Frage betrifft, sind beide Varianten vollkommen gültig, aber sie bedeuten unterschiedliche Dinge. Die erste Variante deklariert sofort ein Standardargument für den zweiten Parameter. Die zweite Variante deklariert Ihre Funktion zunächst ohne Standardargumente und fügt dann eines für den zweiten Parameter hinzu.

Der Nettoeffekt Ihrer beiden Deklarationen (dh wie er im Code nach der zweiten Deklaration angezeigt wird) ist genau der gleiche: Die Funktion verfügt über ein Standardargument für ihren zweiten Parameter. Wenn Sie es jedoch schaffen, Code zwischen der ersten und der zweiten Deklaration zusammenzudrücken, verhalten sich diese beiden Varianten unterschiedlich. In der zweiten Variante hat die Funktion keine Standardargumente zwischen den Deklarationen, daher müssen Sie beide Argumente explizit angeben.

Der erste Weg wäre dem zweiten vorzuziehen.

Dies liegt daran, dass in der Header-Datei angezeigt wird, dass der Parameter optional ist und der Standardwert lautet. Dadurch wird außerdem sichergestellt, dass der Standardwert unabhängig von der Implementierung der entsprechenden CPP-Datei gleich ist.

Zweitens gibt es keine Garantie für einen Standardwert für den zweiten Parameter. Der Standardwert kann sich ändern, je nachdem, wie die entsprechende CPP-Datei implementiert ist.

Standardargumente müssen beim ersten Auftreten des Funktionsnamens angegeben werden - normalerweise im Funktionsprototyp. Wenn der Funktionsprototyp weggelassen wird, weil die Funktionsdefinition auch als Prototyp dient, sollten die Standardargumente im Funktionsheader angegeben werden.