Paramètres par défaut C ++

Une fonction est un code déclaré en dehors de la fonction principale mais exécuté lorsqu'il est appelé à partir du programme principal via un appel de fonction. Toute valeur transmise à toute fonction via l'appel de fonction est connue sous le nom de paramètre de la fonction. Ces arguments sont des variables de types de données spécifiques. Ces paramètres peuvent être par défaut ou introduits au moment de l'exécution.

Paramètres par défaut

Un argument ou un paramètre par défaut est la valeur introduite à la fonction au moment de la déclaration de fonction. Cette valeur est attribuée automatiquement par le compilateur lorsque la fonction est appelée. Pendant tout appel de fonction, si aucune valeur n'est passée en tant que paramètre à la fonction, cela signifie que la valeur par défaut sera utilisée. Sinon, la valeur par défaut sera remplacée par la nouvelle.

Implémentation des paramètres par défaut

Exemple 1

Ici, nous citerons un exemple d'exemple. Cet exemple contiendra une fonction pour calculer la somme des valeurs passées comme paramètres par l'appel de fonction. La fonction contiendra quatre variables. Tout d'abord, tous sont initialisés comme zéro. Nous appellerons la fonction dans le programme principal en passant des arguments à la fonction. Le nombre d'arguments peut varier. Nous passerons deux arguments, puis trois et quatre paramètres seront passés dans le dernier appel de fonction.

Somme (20, 25, 30, 35);

Lorsque vous passez deux paramètres, ces deux seront stockés en deux variables seulement; tandis que le reste restera zéro. Un cas similaire est pour l'appel de fonction avec trois paramètres. Mais, quand il y a quatre arguments, cela signifie que les quatre variables contiendront des valeurs à additionner.

Enregistrez le code puis, exécutez-les dans le terminal Ubuntu en utilisant un compilateur G ++.

$ g ++ -o def def.c
$ ./ def

Vous verrez la valeur résultante pour chaque appel de fonction.

Exemple 2

Cet exemple traite de l'utilisation des paramètres par défaut différemment pour chaque appel de fonction, comme expliqué dans l'exemple précédent. Définissez d'abord la fonction avec le type de retour et les paramètres par défaut. Comme nous le savons, les paramètres par défaut sont déclarés au début. Ainsi, nous déclarerons les valeurs des deux variables ici:

Void affiche (char = '*', int = 3);

L'affichage est le nom de la fonction. Cette déclaration de paramètres par défaut fonctionnera lorsque la fonction est appelée avec des supports d'arguments vides ou sans valeur. À l'intérieur du programme principal, nous avons déclaré une variable de décompte de type entier, qui sera utilisé dans la boucle pour l'itération jusqu'à cette limite. Tout d'abord, l'appel de fonction est fait sans arguments à l'intérieur. Cela signifie que les paramètres par défaut déclarés pour la fonction seront utilisés. Ainsi, les paramètres de cet appel de fonction seront * et 3. Dans le deuxième appel de fonction, nous avons passé un seul symbole de paramètre «#». Ainsi, dans ce cas, le paramètre par défaut de la deuxième variable, 3, sera utilisé tel qu'il est. Mais le symbole qui est passé sera remplacé par le symbole que nous avons déclaré plus tôt.

Afficher ('#');

Maintenant, venant vers l'appel de la troisième fonction, deux arguments seront passés cette fois, un symbole «$», et la variable entière comme Count, qui a été déclaré 5 dans le programme principal. Les deux paramètres par défaut ne seront pas utilisés; Les nouveaux arguments remplaceront ces paramètres par défaut.

Display ('$', count);

En dehors de la fonction principale, la fonction d'affichage, qui a d'abord été déclarée, est maintenant exécutée en ayant une boucle pour une boucle qui iratera jusqu'à la valeur de comptage. Chaque itération affichera le caractère qui lui est passé. Sinon, la valeur par défaut sera affichée.

Maintenant, exécutez l'ensemble du code. Vous verrez que chaque fois qu'un symbole s'affiche au nème nième, la valeur est passée en tant que paramètre.

Exemple 3

Cet exemple concernera le phénomène de surcharge de fonction en C ++ tout en ayant des paramètres par défaut.

Surcharge de fonction

Par exemple, une fonction avec un échantillon de nom est décrite comme:

Int échantillon (int a)
Int échantillon (int a, int b)

Ces fonctions décrites ont le même nom mais ont des arguments différents. Maintenant, nous considérerons un programme C ++ pour élaborer ce concept dans les paramètres par défaut.

Dans la fonction principale, la fonction est appelée avec un nombre différent de paramètres, avec 2, 3 et 4 valeurs. Maintenant, exécutez le code, vous verrez qu'une erreur d'ambiguïté s'est produite.

Lorsque deux fonctions du même nom sont déclarées, il est nécessaire d'avoir des paramètres différents. Mais les deux fonctions ayant le même nom contiennent presque les mêmes paramètres, deux identiques et deux. Les mêmes arguments de la fonction confondre le compilateur tout en choisissant la fonction à choisir car les spécifications des deux fonctions sont les mêmes. Nous avons une solution pour résoudre ce dilemme d'ambiguïté concernant les paramètres par défaut.

Tout d'abord, nous modifierons le type de retour des deux fonctions. De même, les paramètres auront une cohérence dans le type de données de la variable. Par exemple, une fonction prendra le même type de données pour toutes les variables, soit entière ou flottante.

Float sum (float x, float y, float z, float w);

Maintenant, dans le programme principal, tout en appelant la fonction, nous prendrons les deux valeurs en fonction des types de données. Mais n'oubliez pas que tous les nombres en tant qu'arguments suivront le type de données de la variable déclarée. En d'autres termes, tous les nombres d'un seul appel de fonction seront du même type de données.

Somme (1.0f, 1.5f, 2.5f, 3.5f);

Nous avons mentionné «F» sous une forme courte avec chaque valeur flottante pour identifier qu'il s'agit d'une valeur flottante et sera transmise à la fonction ayant des variables de type de données flottantes.

En exécution, vous verrez les résultats obtenus; Les premières et troisième valeurs seront obtenues à partir de la fonction avec des types de données entiers. Tandis que le second sera obtenu à partir de la fonction ayant des types de données flottantes.

Exemple 4

Cet exemple est une fonction de surcharge avec une différence dans le nombre de paramètres. Un affichage de fonction est déclaré ici n'ayant aucun type de retour, car l'instruction COT à l'intérieur de la fonction affichera les résultats. Une fonction prendra deux paramètres: int et un double type de données. La deuxième fonction prendra une seule variable de double type de données, et la troisième ne prendra qu'une variable de type de données entier.

Deux variables seront déclarées dans le programme principal. Ces valeurs seront transmises à la fonction. L'appel de fonction concerne la fonction spécifique dans chaque cellule en fonction du nombre de paramètres par défaut.

Conclusion

Les paramètres par défaut sont déclarés dans la fonction au moment de la déclaration d'une fonction. Nous avons utilisé quelques exemples en C ++ pour développer la déclaration et le processus de paramètres par défaut dans le système Ubuntu. Pendant la fonction primordiale, l'utilisation de paramètres par défaut peut être une situation de difficulté avec les mêmes paramètres par défaut. Nous espérons que vous avez trouvé cet article utile. Consultez les autres articles sur les conseils pour plus de conseils et de tutoriels.