Lorsque je parle verbalement de méthodes, je ne sais jamais s'il faut utiliser le mot argument ou paramètre ou autre chose. Quoi qu'il en soit, les autres personnes savent ce que je veux dire, mais qu'est-ce qui est correct et quelle est l'histoire des termes?

Je suis un programmeur C #, mais je me demande également si les gens utilisent des termes différents dans différentes langues.

Pour mémoire, je suis autodidacte sans expérience en informatique. (S'il vous plaît, ne me dites pas de lire Code complet parce que je demande cela au profit d'autres personnes qui n'ont pas déjà une copie du merveilleux livre de Steve McConnell .)

Sommaire

Le consensus général semble être qu'il est OK 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 " argument / paramètre formel " et " argument / paramètre réel " pour lever l'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 aux paramètres de la méthode.

public void MyMethod(string myParam) { }

...

string myArg1 = "this is my argument";
myClass.MyMethod(myArg1);

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

L'argument est la valeur réelle de cette variable qui est passée à 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 d'appel pour le paramètre.

L'article de Wikipédia indique également que les deux termes sont souvent utilisés de manière synonyme (en particulier pour raisonner sur le code de manière informelle):

Bien que les paramètres soient également communément appelés arguments, les arguments sont plus correctement considérés comme les valeurs réelles ou les références affectées aux variables de paramètre lorsque le sous-programme est appelé au moment de l'exécution.

Étant donné l'exemple de fonction suivant en C qui ajoute deux entiers, xet yserait appelé ses paramètres:

int add(int x, int y) {
    return x + y;
}

Sur un site d'appel utilisant add, tel que l'exemple illustré ci-dessous, 123 et 456 seraient appelés les arguments de l'appel.

int result = add(123, 456);

De plus, certaines spécifications de langage (ou documentation formelle) choisissent d'utiliser exclusivement des paramètres ou des arguments et utilisent des adjectifs tels que formel et réel pour lever l'ambiguïté entre les deux cas. Par exemple, la documentation C / C ++ fait souvent référence aux paramètres de fonction comme arguments formels et aux arguments d' appel de fonction comme arguments réels . Pour un exemple, consultez « Arguments formels et réels » dans la référence du langage Visual C ++ .

Facile:

• P ARAMÈTRE → P LACEHOLDER (Cela signifie qu'un espace réservé appartient à la fonction et qu'il doit être utilisé dans le corps de la fonction)
• A RGUMENT → A CTUAL VALUE (Cela signifie une valeur réelle qui est transmise par la fonction appelant)

Un paramètre est quelque chose que vous devez remplir lorsque vous appelez une fonction. Ce que vous y mettez, c'est l'argument.

Définissez simplement: l'argument va dans le paramètre, un argument est la valeur du paramètre.

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

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

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

L'utilisation des termes paramètres et arguments a été quelque peu mal utilisée par les programmeurs et même les auteurs. Lorsque vous traitez des méthodes, le paramètre term est utilisé pour identifier les espaces réservés dans la signature de la méthode, tandis que les arguments term sont les valeurs réelles que vous transmettez à la méthode.

MCSD Cerfification Toolkit (Exam 70-483) Programming in C # , 1st edition, 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 édition, je suis souvent découragé par la façon dont les gens oublient: les langages de structure sont basés sur les 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 à l'étude. Vous discutez de 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

Considérez l'argument comme la partie masculine, faisant du paramètre 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:

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

(B) Parlant d'une invocation:

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

Réponses

(UNE)

1. on / in / against / 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: en langage parlé, ces mots produiront parfois des réponses identiques!

Donc, en règle générale:

• Habituellement, si quelqu'un veut des informations sur les paramètres, il veut en savoir plus sur le type, le nom de la variable, etc. Ils peuvent devenir confus si vous ne donnez que des exemples d'arguments.

  • Habituellement, si quelqu'un veut des informations sur les arguments, il veut savoir quelle valeur vous avez transmise à une fonction ou à ses paramètres.

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

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

Les paramètres d'une fonction / méthode vous décrivent les valeurs qu'elle utilise pour calculer son résultat.

Les arguments d'une fonction sont les valeurs affectées à ces paramètres lors d'un appel particulier de la fonction / méthode.

Ou peut être encore plus simple à retenir comme ceci, en cas d'arguments optionnels pour une méthode:

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

}

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

Disons que vous êtes une compagnie aérienne. Vous construisez un avion. Vous y installez des sièges. Ensuite, vous remplissez l'avion de passagers et l'envoyez quelque part. Les passagers (ou plutôt une version modifiée dans l'espace et dans le temps) 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.

L'avion est votre fonction.

Les paramètres sont les sièges.

Les arguments sont les passagers qui vont dans ces sièges.

Paramètres et arguments

Tous les différents termes liés aux paramètres et aux arguments peuvent prêter à confusion. Cependant, si vous gardez à l'esprit quelques points simples, vous pourrez facilement gérer ces termes.

1. Les paramètres formels d'une fonction sont répertoriés dans la déclaration de fonction et sont utilisés dans le corps de la définition de fonction. Un 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. Un argument est quelque chose qui est utilisé pour remplir un paramètre formel. Lorsque vous écrivez un appel de fonction, les arguments sont répertoriés entre parenthèses après le nom de la fonction. Lorsque l'appel de fonction est exécuté, les arguments sont branchés pour les paramètres formels.
3. 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 d'appel par valeur, 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 qui est 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 d'argument est substituée au paramètre formel de sorte que toute modification apportée au paramètre formel est réellement apportée à la variable d'argument.

Source: Absolute C ++, Walter Savitch

C'est,

Les termes sont quelque peu interchangeables. La distinction décrite dans d'autres réponses est mieux exprimée 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 ( l'argument formel et l' argument sont également courants).

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

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

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

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

Les arguments de fonction 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 et 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 - l'argent est le paramètre, 2,00 $ est l'argument

La plupart des machines acceptent une entrée et renvoient une sortie. Par exemple, un distributeur automatique prend comme entrée: de l'argent et renvoie: des boissons gazeuses comme sortie. Dans ce cas particulier, il accepte comme paramètre: l'argent.

Quel est donc l'argument? Eh bien, si je mets 2,00 $ dans la machine, l'argument est: 2,00 $ - c'est l'entrée très spécifique utilisée.

Exemple 2: Voitures - L'essence est le paramètre

Prenons une voiture: ils acceptent l'essence (essence sans plomb) comme intrant. On peut dire que ces machines acceptent des paramètres de type: essence. L'argument serait l'apport exact et concret que je mettrais dans ma voiture. Par exemple, dans mon cas, l'argument serait: 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 accepte une personne comme entrée et la transforme en quelqu'un qui n'est pas un menteur.

Qu'est-ce donc 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, l'argument serait Colin Powell.

Ainsi, le paramètre serait une personne en tant que concept abstrait, mais l'argument serait toujours une personne particulière avec un nom particulier qui est mise dans la machine. L'argument est spécifique et concret.

Voilà la différence. Facile.

Confus?

Postez un commentaire et je corrigerai l'explication.

Ou encore plus simple ...

Arguments dedans!

Paramètres sortis!

Ils n'ont pas tous deux une grande différence d'utilisation en C, les deux termes sont utilisés dans la pratique. La plupart du temps, les arguments sont souvent utilisés avec des fonctions. La valeur transmise avec l'instruction d'appel de fonction 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 comme 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 num1et num2sont des paramètres formels et aet bsont des arguments réels.

Les didacticiels Java d'Oracle définissent ainsi cette distinction: "Les paramètres font 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 invoquée. Lorsque vous appelez une méthode, les arguments utilisés doivent correspondre aux paramètres de la déclaration par type et par 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 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 de connexion sur un mur. Dans ce cas, nous pouvons considérer les paramètres et les arguments comme suit;

Les paramètres sont les prises 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 branchées sur les points / prises de prise pour activer certains équipements.

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

?>

De manière générale, les termes paramètre et argument sont utilisés de manière interchangeable pour désigner les informations transmises à une fonction.

Pourtant, du point de vue d'une fonction:

• Un paramètre est la variable répertoriée entre parenthèses dans la définition de la fonction.
• Un argument est la valeur envoyée à la fonction lors de son appel.

Lorsque nous créons la méthode (fonction) en Java, la méthode comme celle-ci.

data-type name of the method (data-type variable-name)

Entre parenthèses, ce sont les paramètres, et lorsque nous appelons la méthode (fonction), nous transmettons la valeur de ce paramètre, qui sont appelés les arguments.

Selon le livre d'Alabahari de Joseph "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 (afaik italien, russe), des synonymes sont largement utilisés pour ces termes.

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

Dans mon université, les professeurs utilisent les deux types de noms.

Les paramètres sont les variables reçues par une fonction, d'où ils sont visibles dans la déclaration de fonction et contiennent le nom de la variable avec son type de données. Les arguments sont des valeurs réelles qui sont passées à 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 répertoriés dans la déclaration de fonction et sont utilisés dans le corps de la définition de fonction. Un paramètre formel (de n'importe quelle 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 remplir un paramètre formel. Lorsque vous écrivez un appel de fonction, les arguments sont répertoriés entre parenthèses après le nom de la fonction. Lorsque l'appel de fonction est exécuté, les arguments sont branché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 d'appel par valeur, 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 qui est 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 d'argument est substituée au paramètre formel de sorte que toute modification apportée au paramètre formel est réellement apportée à la variable d'argument.

Les paramètres sont des variables qui sont utilisées pour stocker les données qui sont passées dans une fonction pour la fonction à utiliser. Les arguments sont les données réelles transmises à une fonction lorsqu'elle est invoquée:

// 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 bien meilleure définition

{ Imaginez un carton d'oeufs: Un paquet de liens de saucisse: Et une femme de chambre } Ceux-ci représentent des éléments d'une fonction nécessaire à la préparation appelée: (utilisez n'importe quel nom: disons que la cuisine est le nom de ma fonction).

Une femme de chambre est une méthode.

(Vous devez __appeler_ ou demander cette méthode pour préparer le petit déjeuner) (L'acte de préparer le petit déjeuner est une fonction appelée Cuisine ) _

Les œufs et les saucisses sont des paramètres:

(parce que le nombre d'oeufs et le nombre de saucisses que vous voulez manger est __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 chambre et 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 est préoccupée par 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)