Quelle est la différence entre un argument et un paramètre?

StackOverflow https://stackoverflow.com/questions/156767

Question

Lorsque je parle verbalement de méthodes, je ne suis jamais sûr d’utiliser le mot argument ou le 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 également si les gens utilisent des termes différents dans des langues différentes.

Pour mémoire, je suis autodidacte sans formation en informatique. (Ne me dites pas de lire Code complet parce que je demande ceci pour le bénéfice d'autres personnes qui ne possèdent pas déjà une copie de Steve McConnell

Résumé

De l'avis général, il est correct 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 l'argument / paramètre formel " et "argument / paramètre actuel " pour lever l’ambiguïté.

Était-ce utile?

La solution

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

Autres conseils

Le paramètre est une variable dans la déclaration de fonction.

L'argument est la valeur réelle de cette variable qui est transmise à la fonction.

Il existe déjà une entrée Wikipedia sur le sujet (voir Paramètre ) 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 Wikipédia indique également que les deux termes sont souvent utilisés comme des synonymes (en particulier pour raisonner de manière informelle sur le code):

  

Bien que les paramètres soient aussi couramment   appelés arguments, arguments   sont plus correctement considérés comme le   valeurs réelles ou références assignées   aux variables de paramètre lorsque le   Le sous-programme est appelé à l'exécution.

Étant donné que la fonction d'exemple suivante en C ajoute deux entiers, x et y sont appelés ses 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 sont appelés > arguments de l'appel. 

int result = add(123, 456);

De plus, certaines spécifications de langage (ou documentation formelle) choisissent d'utiliser exclusivement paramètre ou argument et utilisent des adjectifs tels que formal et réelle au lieu de la désambiguïser entre les deux cas. Par exemple, la documentation C / C ++ fait souvent référence à la fonction paramètres en tant que arguments formels et à l'appel de la fonction arguments en tant que arguments effectifs . Pour un exemple, voir « Arguments formels et réels » dans le Référence du langage Visual C ++ .

Simple:

  • P ARAMETER ? P LACEHOLDER (Ceci signifie qu'un espace réservé appartient à la fonction de nommage et est utilisé dans le corps de la fonction)
  • A RGUMENT ? A VALEUR CTUELLE (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.

Un peu plus d'infos sur: http://en.wikipedia.org/wiki/Parameter_(computer_science)#Parameters_and_arguments< a>

  

L'utilisation des termes paramètres et arguments a été mal utilisée   un peu parmi les programmeurs et même les auteurs. En traitant avec   méthodes, le terme paramètre est utilisé pour identifier les espaces réservés dans   la signature de la méthode, alors que le terme arguments est la valeur réelle   les valeurs que vous transmettez à la méthode.

Kit de formation de la CMDD (examen 70-483) Programmation en C # , 1re édition, Wrox, 2013

Scénario de cas concrets 

// 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 édition, je suis souvent découragé 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, il est partie à l'appel, ce qui limite la réponse.

Un " argument " est une position qui est envisagée. 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.

Interactions

Pensez à l’argument en tant que partie masculine, le paramètre étant alors partie féminine. L'argument va dans le paramètre.

Utilisation

Un paramètre est généralement utilisé dans les définitions. Un argument est habituellement utilisé dans les invocations.

Questions

Terminez la phrase pour la rendre moins dissonante.

(A) En parlant d'une définition:

  1. Quel argument sera utilisé []?
  2. Quel [] ce paramètre []?

(B) En parlant d'une invocation:

  1. Quel paramètre utiliserez-vous, []?
  2. Quel [] sera [] ce paramètre?

Réponses

(A)

  1. sur / dans / contre / avec ce paramètre
  2. argument (s) ... prendre

(B)

  1. et quels sont quelques exemples d'arguments
  2. 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. Ils risquent de devenir confus si vous ne donnez que des exemples d'arguments.

    • 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.

Les paramètres 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 comme ceci, dans le cas d'arguments optionnels pour une méthode: 

public void Method(string parameter = "argument") 
{

}

paramètre est le paramètre, sa valeur, " argument " est l'argument:)

Paramètres et arguments

  

Tous les différents termes relatifs aux paramètres et arguments   peut être déroutant. Cependant, si vous gardez quelques points simples à l’esprit,   vous pourrez facilement gérer ces termes.

     
      
  1. 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. 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.
    2.   
  2. Un argument est un élément utilisé pour renseigner un paramètre formel.   Lorsque vous écrivez un appel de fonction, les arguments sont listé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.
    3.   
  3. Les termes appel par valeur et appel par référence font référence au mécanisme   qui est utilisé dans le processus de branchement. Dans la méthode d'appel par valeur   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 la   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.
    4.   

Source: C ++ absolu, Walter Savitch

C’est-à-dire

entrez la description de l'image ici

Les termes sont quelque peu interchangeables. La distinction décrite dans d’autres réponses s’exprime mieux avec 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 d’appel ( Les arguments formels et les arguments sont également communs).

Notez également qu'en mathématiques, le terme argument est beaucoup plus courant et paramètre signifie généralement quelque chose de très différent (bien que le paramètre paramètre de une équation paramétrique est essentiellement le argument à deux fonctions ou plus).

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

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 envoyez-le 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.

Rappelez-vous toujours que: - Les arguments sont passés pendant que les paramètres sont reçus.

Un argument est une instanciation d'un paramètre.

Oui! Les paramètres et les arguments ont différentes significations, qui peuvent être facilement expliquées comme suit:

Fonction Les paramètres sont les noms répertoriés dans la définition de la fonction.

Fonction Les arguments sont les valeurs réelles transmises à (et reçues par) la fonction.

Explications simples sans code

Un paramètre " est une chose très générale, 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, 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 acceptent les paramètres de 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 sans plomb / essence.

Exemple 3 - Développement 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 une personne avec un nom particulier qui est mis dans la machine. L'argument est spécifique et concret.

C'est la différence. Simple.

Confus?

Publiez un commentaire et je vais corriger l'explication.

Ou encore plus simple ...

Arguments dans!

Paramètres out!

Ils n’ont pas beaucoup de différence d’utilisation en C, les deux termes sont utilisés en 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 est 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 effectifs.

Les tutoriels Java d’Oracle définissent cette distinction comme suit: "Paramètres" fait référence à la liste des variables dans une déclaration de méthode. Les arguments sont les valeurs réelles qui sont transmises lorsque la méthode est appelée. Lorsque vous appelez une méthode, les arguments utilisés doivent correspondre aux paramètres de la déclaration dans le type et l'ordre. "

Une discussion plus détaillée des paramètres et des arguments: https://docs.oracle.com/javase/tutorial/java/javaOO /arguments.html

Logiquement, nous parlons 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 les arguments comme suit:

Les

paramètres sont les sockets du point de connexion, qui peuvent prendre différentes formes. Mais seuls certains types de bouchons leur conviennent.
Les arguments seront les prises réelles qui seraient connectées aux points / prises de connexion pour activer certains équipements.

Lorsque nous créons la méthode (fonction) en Java, la méthode est la suivante.

nom du type de données de la méthode (nom de variable du type de données)

Dans la parenthèse, ce sont les paramètres, et lorsque nous appelons la méthode (fonction), nous passons la valeur de ce paramètre, appelés les arguments.

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 (autant que cela soit italien ou russe), les synonymes sont largement utilisés.

  • paramètre = paramètre formel
  • argument = paramètre réel

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

?>

Les paramètres sont les variables reçues par une fonction. Par conséquent, elles sont visibles dans la déclaration de fonction. Elles contiennent le nom de la variable avec son 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

Les paramètres formels d'une fonction sont listés dans la déclaration de la fonction et sont utilisés dans le corps de la définition de la fonction. Un paramètre formel (de toute sorte) est une sorte d’espace ou un espace réservé qui est rempli avec quelque chose lorsque la fonction est appelée.

Un argument est un élément 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 des variables utilisées pour stocker les données transmises à une fonction à utiliser. Les 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);

J'ai réfléchi et réalisé que ma réponse précédente était fausse. Voici une définition bien meilleure

{ Imaginez une boîte d'œufs: un ensemble de liens de saucisses: et une servante } qui représentent les éléments d'une fonction nécessaire à la préparation et 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 de 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'oeufs et le nombre de saucisses que vous voulez manger sont __variable_.) _

Votre décision est un argument:

Il représente la __Valeur_ du nombre choisi d'oeufs et / ou de saucisses que vous cuisinez ._

{ Mnémonique }

_ " Lorsque vous appelez la femme de ménage et que vous lui demandez de préparer le petit-déjeuner, elle vous explique 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.)

Cela s’explique parfaitement dans Paramètre (programmation informatique) - Wikipedia / p>

En gros, un paramètre est un type et un argument est une instance.

Dans la définition de fonction f (x) = x * x , la variable x est un paramètre. dans l'appel de fonction f (2) , la valeur `` 2 est l'argument de la fonction.

Et Paramètre - Wikipedia

Dans programmation informatique , deux notions de paramètre sont couramment utilisés et sont appelés paramètres et arguments - ou plus formellement en tant que paramètre formel et paramètre réel . .

Par exemple, dans la définition d'une fonction telle que

y = f (x) = x + 2,

x est le paramètre formel (le paramètre ) de la fonction définie.

Lorsque la fonction est évaluée pour une valeur donnée, comme dans

f (3): ou, y = f (3) = 3 + 2 = 5,

est le paramètre actuel (le argument ) pour évaluation par la fonction définie; c'est une valeur donnée (valeur réelle) qui remplace le paramètre formel de la fonction définie. (En utilisation occasionnelle, les termes paramètre et argument risquent d'être intervertis par inadvertance et, de ce fait, utilisés de manière incorrecte.)

Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top