L'initialisation de la variable en C++ la fonction d'en-tête

J'ai rencontré certains de code C++ qui ressemble à ceci (simplifiée de ce post):

(Voici le prototype de fonction situé dans someCode.hpp)

void someFunction(const double & a, double & b, const double c = 0, const double * d = 0);

(Ici de la première ligne du corps de fonction situé dans someCode.cpp que #include's someCode.hpp)

void someFunction(const double & a, double & b, const double c, const double * d);

Puis-je légalement someFunction à l'aide de:

someFunction(*ptr1, *ptr2);

et/ou

someFunction(*ptr1, *ptr2, val1, &val2);

où les variables ptr1, ptr2, val, et val2 ont été définis de façon appropriée et val1 et val2 n'est pas égal à zéro? Pourquoi ou pourquoi pas?

Et si c'est légal, c'est cette syntaxe préféré vs surcharger une fonction de compte pour les paramètres facultatifs?

OriginalL'auteur Evan | 2011-05-13

c++function initialization prototype variables

5

Oui, c'est légal, ce qui est appelé les arguments par défaut. Je dirais qu'il est préféré à la surcharge due à la participation de moins de code, oui.

Concernant votre commentaire sur const, qui ne s'applique pas à la valeur par défaut lui-même, il s'applique à l'argument. Si vous avez un argument de type const char* fruit = "apple", cela ne signifie pas qu'il doit être appelé avec un pointeur de caractère dont la valeur est la même que l'adresse de la "apple" littéral de chaîne (ce qui est bon, parce qu'il serait difficile de garantie). Cela signifie simplement qu'il doit être appelé avec un pointeur constant de caractères, et vous indique que la fonction appelée n'a pas besoin d'écrire pour que la mémoire, c'est seulement la lecture.

Merci pour la réponse et pour le lien répondu. Je ne savais pas ce que ces ont été appelés. Pourquoi est-il légal si la valeur par défaut arguments sont const? Il semble que les rendant const signifie qu'ils ne peuvent pas être modifiés.
Le const qualificatif s'applique à l'argument de la fonction, et non pas la valeur par défaut qui est fourni. L'affectation de la valeur par défaut se produit en fonction du temps d'appel, tout comme l'affectation d'un argument fourni. Si les choses travaillé à la façon dont vous pensez, alors il serait illégal d'appeler une fonction avec const paramètres plus d'une fois.

OriginalL'auteur unwind
1

Oui, les paramètres sont optionnels et quand vous ne passez pas d'eux, étant donné les valeurs par défaut seront utilisées.

Il a quelques avantages et inconvénients à utiliser des valeurs de paramètre par défaut au lieu de les surcharger. L'avantage est de moins en moins de taper dans les deux interface et la mise en œuvre de la partie. Mais l'inconvénient est que la valeur par défaut est une partie de l'interface avec toutes ses conséquences. Ensuite, lorsque vous modifiez la valeur par défaut, vous avez par exemple besoin de recompiler beaucoup de code au lieu d'un seul fichier lors de l'utilisation de la surcharge.

Personnellement, je préfère les paramètres par défaut.

OriginalL'auteur Juraj Blaho
1

J'aimerais développer un peu plus si les Paramètres par Défaut sont privilégiées par rapport à la surcharge.

Habituellement, ils sont pour toutes les raisons citées dans les autres réponses, notamment moins de code réutilisable.

Il y a aussi des raisons valables qui font de surcharger une meilleure alternative dans certaines situations:

Les valeurs par défaut sont une partie de l'interface, des changements pourraient casser des clients (@Juraj déjà noté)
En outre, les Surcharges de le rendre plus facile d'en ajouter d'autres (les combinaisons de paramètres, sans casser l' (binaire) de l'interface.

Surcharges sont résolus au moment de la compilation, ce qui peut donner le compilateur meilleure optimisation esp (inlining) possibilités. par exemple, si vous avez quelque chose comme ceci:
```
void foo(Something* param = 0) {
   if (param == 0) {
      simpleAlgorithm();
   } else {
      complexAlgorithm(param);
   }
}
```
Il pourrait être préférable d'utiliser les surcharges.

OriginalL'auteur Fabio Fracassi
0

Puis-je légalement someFunction à l'aide de:

someFunction(*ptr1, *ptr2);

Absolument! Oui, les 2 autres variables que la fonction accepte aurait des valeurs par défaut que vous avez défini dans le fichier d'en-tête qui est de zéro pour les deux arguments.

Mais si vous ne vous offre le 3ème et le 4ème argument à la fonction, puis ces valeurs sont considérées comme à la place des valeurs par défaut.

OriginalL'auteur omggs

Vous devez vous connecter pour publier un commentaire.