Quelle est la différence entre un argument et un paramètre?
Quand je parle verbalement de méthodes, je ne suis jamais sûr de savoir s'il faut utiliser Word argument ou paramètre ou autre chose. De toute façon, les autres personnes savent ce que je veux dire, mais qu'est-ce qui est correct et quel est l'historique des termes?
Je suis un programmeur C #, mais je me demande aussi si les gens utilisent des termes différents dans des langues différentes.
Pour mémoire, je suis autodidacte sans formation en informatique. (S'il vous plaît, ne me dites pas de lire Code Complete parce que je le demande pour le bénéfice d'autres personnes qui ne possèdent pas déjà une copie du merveilleux livre de Steve McConnell .)
Résumé
Le consensus général semble être qu'il est acceptable d'utiliser ces termes de manière interchangeable dans un environnement d'équipe. Sauf peut-être lorsque vous définissez la terminologie précise; alors vous pouvez également utiliser "formal argument/paramètre" et "actual argument/paramètre" pour lever la ambiguïté.
Un paramètre est une variable dans une définition de méthode. Lorsqu'une méthode est appelée, les arguments sont les données que vous transmettez dans les paramètres de la méthode.
public void MyMethod(string myParam) { }
...
string myArg1 = "this is my argument";
myClass.MyMethod(myArg1);
Le paramètre est une variable dans la déclaration de fonction.
Argument est la valeur réelle de cette variable qui est transmise à function.
Il existe déjà une entrée Wikipedia sur le sujet (voir Parameter ) qui définit et distingue les termes paramètre et argument. En bref, un paramètre fait partie de la signature de fonction/procédure/méthode et un argument est la valeur réelle fournie au moment de l'exécution et/ou du site de l'appel pour le paramètre.
L'article de Wikipedia indique également que les deux termes sont souvent utilisés de manière synonyme (en particulier pour raisonner de manière informelle sur le code):
Bien que les paramètres soient aussi couramment appelé arguments, arguments sont plus correctement considérés comme le valeurs réelles ou références attribuées aux variables de paramètre lorsque le Le sous-programme est appelé à l'exécution.
Étant donné l'exemple de fonction suivant en C qui ajoute deux entiers, x et y seront appelés paramètres:
int add(int x, int y) {
return x + y;
}
Sur un site d'appel utilisant add, comme dans l'exemple ci-dessous, 123 et 456 seront appelés les arguments de l'appel.
int result = add(123, 456);
En outre, certaines spécifications de langage (ou documentation formelle) choisissent d'utiliser exclusivement paramètre ou argument et utilisent des adjectifs tels que formal et actual à la place de la ambiguïté entre les deux cas. Par exemple, la documentation C/C++ fait souvent référence à la fonction parameters en tant que arguments formels et à l'appel de fonction arguments en tant que arguments réels. Pour un exemple, voir “ Arguments formels et réels ” dans le Référence du langage Visual C++ .
Simple:
- PARAMETER →PLACEHOLDER (Cela signifie qu'un paramètre fictif appartient au nom de la fonction et est utilisé dans le corps de la fonction)
- ARGUMENT →AVALEUR CTUELLE (Ceci signifie une valeur réelle transmise par la fonction appelante)
Un paramètre est quelque chose que vous devez renseigner lorsque vous appelez une fonction. Ce que vous y mettez, c'est l'argument.
Simplement défini: l'argument va dans le paramètre, un argument est la valeur du paramètre.
Plus d'infos sur: http://fr.wikipedia.org/wiki/Parameter_(computer_science)#Parameters_and_arguments
L'utilisation des termes paramètres et arguments a été quelque peu mal utilisée par les programmeurs et même par les auteurs. Lorsqu'il s'agit de méthodes, le terme paramètre est utilisé pour identifier les espaces réservés dans la signature de la méthode, tandis que le terme arguments correspond aux valeurs réelles que vous transmettez à la méthode.
MCSD Cerfification Toolkit (Examen 70-483) Programmation en C #, 1re édition, Wrox, 2013
Scénario de cas réel
// Define a method with two parameters
int Sum(int num1, int num2)
{
return num1 + num2;
}
// Call the method using two arguments
var ret = Sum(2, 3);
En montage, je suis souvent décontenancé par la façon dont les gens oublient: les langages de structure sont basés sur des langages naturels.
En anglais
Un "paramètre" est un espace réservé. Ils définissent le format de réponse, en langue parlée. Par définition, c'est partie à l'appel, ce qui limite la réponse.
Un "argument" est une position à l'étude. Vous défendez votre opinion: vous considérez un argument.
Différence principale
Le rôle thématique d'un argument est agent. Le rôle thématique du paramètre est destinataire.
Les interactions
Pensez à l'argument comme à la partie masculine, le paramètre étant la partie féminine. L'argument va dans le paramètre.
Usage
Un paramètre est généralement utilisé dans les définitions. Un argument est généralement utilisé dans les invocations.
Des questions
Terminez la phrase pour la rendre moins dissonante.
(A) En parlant d'une définition:
- Quel argument sera utilisé []?
- Quel [] sera ce paramètre []?
(B) En parlant d'une invocation:
- Quel paramètre utiliserez-vous, []?
- Quel [] sera [] ce paramètre?
Réponses
(UNE)
- sur/dans/contre/avec ce paramètre
- argument (s) ... prendre
(B)
- et quels sont quelques exemples d'arguments
- argument (s) ... utilisé sur/dans/contre/avec
Chevauchements
Comme vous pouvez l’imaginer, après avoir répondu: dans la langue parlée, ces mots produisent parfois des réponses identiques!
Donc, en règle générale:
Généralement, si quelqu'un souhaite obtenir des informations sur les paramètres, il souhaite en savoir plus sur le type, le nom de la variable, etc.
- Généralement, si quelqu'un veut des informations d'argument, il veut savoir quelle valeur vous avez transmise à une fonction ou à ses paramètres.
Parameter est une variable dans la déclaration de fonction.
Argument est la valeur réelle de cette variable qui est transmise à la fonction . 
Les parameters d'une fonction/méthode vous décrivent les valeurs qu'elle utilise pour calculer son résultat.
Les arguments de a sont les valeurs affectées à ces paramètres lors d'un appel particulier de la fonction/méthode.
Ou peut-être est-il encore plus simple à retenir de la sorte, en cas d'arguments optionnels pour une méthode
public void Method(string parameter = "argument")
{
}
parameter est le paramètre, sa valeur, "argument" est l'argument :)
Paramètres et arguments
Tous les différents termes relatifs aux paramètres et aux arguments peut être déroutant. Cependant, si vous gardez quelques points simples à l’esprit, vous serez capable de gérer facilement ces termes.
- Les paramètres formels pour une fonction sont répertoriés dans la déclaration de la fonction et utilisés dans le corps de la définition de la fonction. UNE paramètre formel (de toute sorte) est une sorte de blanc ou d'espace réservé qui est rempli avec quelque chose lorsque la fonction est appelée.
- Un argument est quelque chose qui est utilisé pour renseigner un paramètre formel . Lorsque vous écrivez un appel de fonction, les arguments sont répertoriés dans parenthèses après le nom de la fonction. Lorsque l'appel de fonction est exécutés, les arguments sont branchés pour les paramètres formels.
- Les termes call-by-value et call-by-reference font référence au mécanisme qui est utilisé dans le processus de branchement. Dans la méthode call-by-value seule la valeur de l'argument est utilisée. Dans cet appel par valeur mécanisme, le paramètre formel est une variable locale qui est initialisé à la valeur de l'argument correspondant. Dans le mécanisme d'appel par référence, l'argument est une variable et le toute la variable est utilisée. Dans le mécanisme d’appel par référence, le La variable argument est substituée au paramètre formel de sorte que toute modification apportée au paramètre formel est en fait apportée à la variable d'argument.
Source: C++ absolu, Walter Savitch
C'est,
Disons que vous êtes une compagnie aérienne. Vous construisez un avion. Vous y installez des sièges. Ensuite, vous remplissez l'avion avec des passagers et l'envoyez quelque part. Les passagers (ou plutôt leur version modifiée spatio-temporellement) débarquent. Le lendemain, vous réutilisez le même avion et les mêmes sièges, mais avec des passagers différents cette fois-ci.
L'avion est votre fonction.
Les paramètres sont les sièges.
Les arguments sont les passagers qui vont dans ces sièges.
Cet exemple pourrait aider.
int main () {
int x = 5;
int y = 4;
sum(x, y); // **x and y are arguments**
}
int sum(int one, int two) { // **one and two are parameters**
return one + two;
}
Les termes sont quelque peu interchangeables. La distinction décrite dans d'autres réponses est mieux exprimée par les termes paramètre formel pour le nom utilisé dans le corps de la fonction et paramètre pour la valeur fournie sur le site de l'appel (argument formel et argument sont également courants).
Notez également qu'en mathématiques, le terme argument est beaucoup plus courant et que paramètre signifie généralement quelque chose de très différent (bien que le paramètre paramètre dans une équation paramétrique soit essentiellement le paramètre argument deux fonctions ou plus).
Rappelez-vous toujours que: -.____. Les arguments sont passés pendant que les paramètres sont reçus.
Oui! Les paramètres et les arguments ont différentes significations, qui peuvent être facilement expliquées comme suit:
Fonction Paramètres sont les noms énumérés dans la définition de la fonction.
Fonction Arguments sont les valeurs réelles transmises à (et reçues par) la fonction.
Un argument est une instanciation d'un paramètre.
Ils n’ont pas beaucoup de différence d’utilisation en C, les deux termes sont utilisésen pratique . La plupart du temps, les arguments sont souvent utilisés avec des fonctions. La valeur transmise avec l'instruction call function est appelée l'argument. Et le paramètre serait la variable qui copie la valeur dans la définition de la fonction (appelée paramètre formel).
int main ()
{
/* local variable definition */
int a = 100;
int b = 200;
int ret;
/* calling a function to get max value */
ret = max(a, b);
printf( "Max value is : %d\n", ret );
return 0;
}
/* function returning the max between two numbers */
int max(int num1, int num2)
{
/* local variable declaration */
int result;
if (num1 > num2)
result = num1;
else
result = num2;
return result;
}
Dans le code ci-dessus, num1 et num2 sont des paramètres formels et a et b sont des arguments réels.
Ou encore plus simple ...
Arguments dans!
Paramètres out!
Explications simples sans code
Un "paramètre" est une chose très générale très large, mais un "argument" est une chose très spécifique et concrète. Ceci est mieux illustré par des exemples quotidiens:
Exemple 1: Distributeurs automatiques - Money est le paramètre, $ 2.00 est l'argument
La plupart des machines prennent une entrée et retournent une sortie. Par exemple, un distributeur automatique prend comme entrée: de l'argent et renvoie: des boissons pétillantes comme sortie. Dans ce cas particulier, il accepte comme paramètre: l'argent.
Quel est alors l'argument? Eh bien, si je mets 2,00 $ dans la machine, alors l’argument est le suivant: 2,00 $ - c’est l’entrée très spécifique utilisée.
Exemple 2: Voitures - L'essence est le paramètre
Considérons une voiture: ils acceptent l’essence (essence sans plomb). On peut dire que ces machines acceptentparamètresde type: petrol. L'argument serait la contribution exacte et concrète que j'ai mise dans ma voiture. par exemple. Dans mon cas, l’argument serait le suivant: 40 litres d’essence/essence sans plomb.
Exemple 3 - Élaboration d'arguments
Un argument est un exemple particulier et spécifique d'une entrée. Supposons que ma machine prenne une personne comme entrée et la transforme en quelqu'un qui n'est pas un menteur.
Qu'est-ce qu'un argument? L'argument sera la personne particulière qui est réellement mise dans la machine. par exemple. si Colin Powell est mis dans la machine, alors l'argument serait Colin Powell.
Le paramètre serait donc une personne en tant que concept abstrait, mais l'argument serait toujours unpersonne particulièreavec unnom particulierqui est placé dans la machine. L'argument est spécifique et concret.
C'est la différence. Simple.
Confus?
Postez un commentaire et je vais corriger l'explication.
Logiquement parlant, nous parlons en fait de la même chose… Mais je pense qu'une simple métaphore serait utile pour résoudre ce dilemme.
Si les métaphores peuvent être appelées différents points de connexion, nous pouvons les assimiler à des points enfichables sur un mur . Dans ce cas, nous pouvons considérer les paramètres et arguments comme suit
Paramètres sont les prises du plug-point qui peuvent prendre différentes formes. Mais seuls certains types de bouchons leur conviennent.
Arguments seront les prises qui seraient branchées aux points/prises de prise pour activer certains équipements.
Les didacticiels Java d’Oracle définissent cette distinction comme suit: les paramètres de la déclaration dans le type et l'ordre. "
Une discussion plus détaillée des paramètres et arguments: https://docs.Oracle.com/javase/tutorial/Java/javaOO/arguments.html
Selon le livre de Joseph Alabahari "C # in a Nutshell" (C # 7.0, p. 49):
static void Foo (int x)
{
x = x + 1; // When you're talking in context of this method x is parameter
Console.WriteLine (x);
}
static void Main()
{
Foo (8); // an argument of 8.
// When you're talking from the outer scope point of view
}
Dans certaines langues humaines (après l’italien, le russe), les synonymes sont largement utilisés pour ces termes.
- paramètre = paramètre formel
- argument = paramètre actuel
Dans mon université, les professeurs utilisent les deux types de noms.
Le paramètre est une variable dans une définition de fonction
L'argument est une valeur de paramètre
<?php
/* define function */
function myFunction($parameter1, $parameter2)
{
echo "This is value of paramater 1: {$parameter1} <br />";
echo "This is value of paramater 2: {$parameter2} <br />";
}
/* call function with arguments*/
myFunction(1, 2);
?>
Paramètres sont des variables utilisées pour stocker les données transmises à une fonction à utiliser. Arguments sont les données réelles transmises à une fonction lors de son appel:
// x and y are parameters in this function declaration
function add(x, y) {
// function body
var sum = x + y;
return sum; // return statement
}
// 1 and 2 are passed into the function as arguments
var sum = add(1, 2);
Vous devez revenir à la base. Les constructeurs et les méthodes ont des paramètres et des arguments.Beaucoup de gens appellent même des constructeurs un type spécial de méthodes. Voici comment une méthode est déclarée les paramètres sont utilisés :
type name(parameters){
//body of method
}
Et voici comment un constructeur est déclaré les paramètres sont utilisés :
classname(parameters){
//body
}
Voyons maintenant un exemple de code à l'aide duquel nous calculons le volume d'un cube:
public class cuboid {
double width;
double height;
double depth;
cuboid(double w,double h,double d) {
//Here w,h and d are parameters of constructor
this.width=w;
this.height=h;
this.depth=d;
}
public double volume() {
double v;
v=width*height*depth;
return v;
}
public static void main(String args[]){
cuboid c1=new cuboid(10,20,30);
//Here 10,20 and 30 are arguments of a constructor
double vol;
vol=c1.volume();
System.out.println("Volume is:"+vol);
}
}
Vous comprenez donc maintenant que lorsque nous appelons un constructeur/une méthode sur un objet à un endroit ultérieur du code, nous transmettons des arguments et non des paramètres. Par conséquent, les paramètres sont limités à l'emplacement où l'objet logique est défini, mais des arguments entrent en jeu lorsqu'un objet physique l'objet est réellement créé.
Les paramètres formels d'une fonction sont répertoriés dans la déclaration de la fonction et utilisés dans le corps de la définition de la fonction. Un paramètre paramètre (de toute sorte) est une sorte de blanc ou d'espace réservé qui est rempli avec quelque chose lorsque la fonction est appelée.
Un argument est quelque chose qui est utilisé pour renseigner un paramètre formel. Lorsque vous écrivez un appel de fonction, les arguments sont listés entre parenthèses après le nom de la fonction. Lorsque l'appel de fonction est exécuté, les arguments sont insérés pour les paramètres formels.
Les termes appel par valeur et appel par référence font référence au mécanisme utilisé dans le processus de branchement. Dans la méthode call-by-value, seule la valeur de l'argument est utilisée. Dans ce mécanisme d'appel par valeur, le paramètre formel est une variable locale initialisée à la valeur de l'argument correspondant. Dans le mécanisme d'appel par référence, l'argument est une variable et la variable entière est utilisée. Dans le mécanisme d'appel par référence, la variable argument est remplacée par le paramètre formel, de sorte que toute modification apportée au paramètre formel est réellement apportée à la variable argument.
Les paramètres sont les variables reçues par une fonction.Elles sont donc visibles dans la déclaration de la fonction. Elles contiennent le nom de la variable avec leur type de données . Les arguments sont des valeurs réelles qui sont transmises à une autre fonction. C'est pourquoi nous pouvons les voir dans l'appel de fonction. Ce ne sont que des valeurs sans leur type de données
Je réfléchis et réalisai que ma réponse précédente était fausse. Voici une bien meilleure définition
{ Imaginez une boîte d'œufs: Un paquet de saucisses: Et une bonne } Celles-ci représentent les éléments d'une fonction nécessaire à la préparation appelée: (utilisez n'importe quel nom: Disons que la cuisson est le nom de ma fonction).
Une femme de ménage est une méthode.
(Vous devez __call_ ou demander cette méthode pour préparer le petit-déjeuner) (Le fait de prendre le petit-déjeuner est une fonction appelée cuisson ) _
Les œufs et les saucisses sont des paramètres:
(parce que le nombre d'œufs et le nombre de saucisses que vous voulez manger sont __variable_.) _
Votre décision est un argument:
Il représente la __Value_ du nombre choisi d'oeufs et/ou de saucisses que vous cuisinez ._
{ Mnémonique }
_ "Lorsque vous appelez la femme de chambre et que vous lui demandez de préparer le petit-déjeuner, elle __argues_ avec vous sur le nombre d'œufs et de saucisses que vous devriez manger. Elle se préoccupe de votre cholestérol" __
(Les arguments sont donc les valeurs de la combinaison de paramètres que vous avez déclarés et que vous avez décidé de transmettre à votre fonction.)