What's the difference between an argument and a parameter?

Question

When verbally talking about methods, I'm never sure whether to use the word argument or parameter or something else. Either way the other people know what I mean, but what's correct, and what's the history of the terms?

I'm a C# programmer, but I also wonder whether people use different terms in different languages.

For the record I'm self-taught without a background in Computer Science. (Please don't tell me to read Code Complete because I'm asking this for the benefit of other people who don't already have a copy of Steve McConnell's marvelous book.)

Ginni

I use them interchangeably.. no one has laughed at me yet.. 'this function has 4 arguments.. this function takes 4 parameters.' sounds the same. – Keller

It's okay to use them interchangably except when you're trying to describe how parameters work and how arguments are passed etc. At that point the precise terminology (which can be a pain to express sometimes) is useful. – Oleaginous

There are at least two non-closed, language-agnostic versions of this question: #3176810 and https://mcmap.net/q/54234/-arguments-or-parameters-duplicate. There's also another C# version of this question; I've requested a merge. – Brune

@LordTorgamus: I've added language-agnostic to this one, since the poster was also asking about whether other language communities used the same terminology. – Northwester

It's a moveable target. When I started in IT all those years ago it was always 'formal argument, actual parameter'. Judging by the answers here it is now evidently the other way around. – Shonda

Glad that you mentioned Steve McConnell. I got to know about one more guy who knows software craftsmanship along with Robert C. Martin. – Soot

I think regardless of whether you are in a formal environment or not, you should strive to use the correct terms. I think its pretty simple. When you call a method, you pass in arguments. When you define the method, you are defining the parameters that will take the arguments from the method / function call. argument - an independent variable associated with a function and determining the value of the function. parameter - a limit or boundary that defines the scope of a particular process or activity. – Galarza

The parameters characterize the function, f(x) is different from f(x, y), while arguments are concrete expressions like f( 3+7-1/2*5%7 ). – Serica

Just imagine a Platypus eating an Apple. – Beera

Answer 1

A parameter is a variable in a method definition. When a method is called, the arguments are the data you pass into the method's parameters.

public void MyMethod(string myParam) { }

...

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

Hildegard

An alliterating mnemonic that may help: Arguments are Actual. ;) – Hopscotch

The answer mentions that "Parameter is a variable in a method definition" but it might be better to say "method declaration" [if someone is making a distinction between 'declaration' and 'definition'] – Cattleya

"You define parameters, and you make arguments." – Gerundive

parameter => when we define the function , argument => when we call to that method. (CORRECT ME IF I AM WRONG.) – Brunobruns

But even though the code above seems correct surely myParam is technically an argument when used within the body of the MyMethod (and a param in the signature)? – Pneumococcus

@nashwan myParam would be an argument if it was directly used to invoke another method within MyMethod (e.g. in public void MyMethod(string myParam) { AnotherMethod(myParam) }, myParam is a parameter of MyMethod and an argument of AnotherMethod). – Harping

@Prageeth there is no function in java. only methods – Larios

Argument passed to a function/method is stored in its parameter. – Saturable

well when you "call" the function you make an "argument" right ? – Pedi

Is there any literature, that first defined these terms and established this meaning for the computer science? – Syphilology

Parameters are the Names. Arguments are the Values. – Colonialism

I think "how am I going to argue with this function, this time" - you can argue with it in many different ways (provide different arguments in different calls). – Gone

Minor point - Java books have main method as main(String [ ] args). It should be main(String [ ] params) instead. – Frankfrankalmoign

@Cattleya We don't need to specify the variable in the method declaration. Only the data type is enough – Uigur

No parameter and argument are used interchangeably. A few counter examples - 'The argument base is a pointer' in the MSDN qsort() reference, 'The argument path points to a pathname' in the POSIX exec() reference. – Critta

@MasterJoe, not only java. A lot of language books and standard committees. For example C usually use int main(int argc, char **argv);. – Sarmatia

@Frankfrankalmoign No, it shouldn't. main is supplied with an array of (command line) arguments, args for short. Usually you name your parameters neither formally nor technically but semantically, otherwise all your function/method declarations would have (param1, param2, ... , paramN) or (string1, string2, int1, int2, ...). [NB: The nor my be a bit different if you worked für MS's applications division or Windows development team.] – Pinfeather

does this apply to any other language, like python too ? – Kneeland

they says : parameter A named entity in a function (or method) definition that specifies an argument (or in some cases, arguments) that the function can accept. T – Kneeland

The method definition has parameters, and the calling method passes arguments – Ornithopter

Each argument provided during the execution of a function satisfies a parameter defined by that function. – Giraudoux

Answer 2

Parameter is the variable in the declaration of the function.

Argument is the actual value of this variable that gets passed to the function.

Master

These languages usually refer to the argument/parameter list passed to a method as *args or ARGV and not *params :-) – Dentilingual

*params would be the name of a variable that is meant to hold the parameter names (perhaps used for introspection). – Kiyokokiyoshi

@Dentilingual And that is completely in line with this distinction, actually. Parameters are named at declaration time, arguments are known only at call time. The syntax *args declares a parameter args whose value is a list (name and type known at declaration time) of the arguments (whose number is known only at call time). – Velvety

I think it's better to remember it the other way around. As long as you remember "Argument is the actual value that gets passed to a function.", then Parameter is the other one. "variable in the declaration" is harder to remember than "value passed in" – Genuine

Answer 3

Simple:

• PARAMETER → PLACEHOLDER (This means a placeholder belongs to the function naming and be used in the function body)
• ARGUMENT → ACTUAL VALUE (This means an actual value which is passed by the function calling)

Wrist

Answer 4

A parameter is a variable in the declaration of the function.

An argument is the actual value of the variable that gets passed to the function.

Errantry

Isn't this just a copy (including grammatical errors that I've now fixed) of @Rinat Abdullin's answer with an added picture? – Genuine

I, for one, found the picture helpful. – Avidin

Answer 5

There is already a Wikipedia entry on the subject (see Parameter) that defines and distinguishes the terms parameter and argument. In short, a parameter is part of the function/procedure/method signature and an argument is the actual value supplied at run-time and/or call-site for the parameter.

The Wikipedia article also states that the two terms are often used synonymously (especially when reasoning about code informally):

Although parameters are also commonly referred to as arguments, arguments are more properly thought of as the actual values or references assigned to the parameter variables when the subroutine is called at runtime.

Given the following example function in C that adds two integers, x and y would be referred to as its parameters:

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

At a call-site using add, such as the example shown below, 123 and 456 would be referred to as the arguments of the call.

int result = add(123, 456);

Also, some language specifications (or formal documentation) choose to use parameter or argument exclusively and use adjectives like formal and actual instead to disambiguate between the two cases. For example, C/C++ documentation often refers to function parameters as formal arguments and function call arguments as actual arguments. For an example, see “Formal and Actual Arguments” in the Visual C++ Language Reference.

Beutler

+1 for explaining how they are commonly used as well as their formal definitions, and also for mentioning the common use of "formal" and "actual" arguments/parameters to distinguish them without ambiguity. – Northwester

This is a great explanation but it is nearly impossible to understand compared to the simplicity of the concept. A parameter is what is accepted, an argument is what is called. It is a one-way street. – Fulford

@Fulford That doesn't sound right to my ears. A parameter is what does accepting, and an argument is what is provided when making a call. But a parameter accepts an argument, so it is an argument that is accepted, not a parameter. And if anything, an argument is given in a call to a parameter (or at least, some function with a parameter), so it is more the parameter that is called than the argument. – Gusto

Answer 6

A parameter is something you have to fill in when you call a function. What you put in it is the argument.

Simply set: the argument goes into the parameter, an argument is the value of the parameter.

A bit more info on: http://en.wikipedia.org/wiki/Parameter_(computer_science)#Parameters_and_arguments

Berardo

Answer 7

Let's say you're an airline. You build an airplane. You install seats in it. Then, you fill the plane up with passengers and send it somewhere. The passengers disembark. Next day, you re-use the same plane, and same seats, but with different passengers this time.

The plane is your function.

The parameters are the seats.

The arguments are the passengers that go in those seats.

function fly(seat1, seat2) {
    seat1.sayMyName();
    // Estraven
    seat2.sayMyName();
    // Genly Ai
    etc.
}

var passenger1 = "Estraven";
var passenger2 = "Genly Ai";

fly(passenger1, passenger2); 

Mambo

I've heard a similar analogy where mailboxes are the parameters and the mail within them are the arguments. – Declamation

"The arguments are the passengers that go in those seats." Sounds like all of the passengers have arguments about the way that the airline functions. ;) – Metcalfe

Answer 8

The use of the terms parameters and arguments have been misused somewhat among programmers and even authors. When dealing with methods, the term parameter is used to identify the placeholders in the method signature, whereas the term arguments are the actual values that you pass in to the method.

MCSD Cerfification Toolkit (Exam 70-483) Programming in C#, 1st edition, Wrox, 2013

Real-world case scenario

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

Cathern

Answer 9

Generally speaking, the terms parameter and argument are used interchangeably to mean information that is passed into a function.

Yet, from a function's perspective:

• A parameter is the variable listed inside the parentheses in the function definition.
• An argument is the value that is sent to the function when it is called.

Redbird

Answer 10

Always Remember that:
Arguments are passed while parameters are received.

Serotonin

Answer 11

In editing, I'm often put off at how people forget: structure languages are based on natural languages.

In English

A "parameter" is a placeholder. They set the response format, in spoken language. By definition, it's party to the call, limiting the response.

An "argument" is a position that is being considered. You argue your opinion: you consider an argument.

Main difference

The thematic role of an argument is agent. The thematic role of parameter is recipient.

Interactions

Think of the argument as the male part, making the parameter the female part. The argument goes into the parameter.

Usage

A parameter is usually used in definitions. An argument is usually used in invocations.

Questions

Finish the sentence to make it less dissonant.

(A) Speaking of a definition:

1. What argument will be used []?
2. What [] will this parameter []?

(B) Speaking of an invocation:

1. What parameter will you use, []?
2. What [] will be [] this parameter?

Answers

(A)

1. on/in/against/with this parameter
2. argument(s) ... take

(B)

1. and what are some example arguments
2. argument(s) ... used on/in/against/with

Overlaps

As you can imagine, after answering: in spoken language, these words will sometimes produce identical responses!

So, as a rule:

• Usually if someone wants parameter information, they want to know more about the type, the variable name, etc. They may become confused if you only give example arguments.

  • Usually if someone wants argument information, they want to know what value you passed to a function or its parameter(s).

Tympany

"Think of the argument as the male part, making the parameter the female part. The argument goes into the parameter."... err ...umm ...really? – Genuine

>Think of the argument as the male part, making the parameter the female part. The argument goes into the parameter. Bro, you just made my day xD – Upper

Answer 12

Or maybe it's even simpler to remember like this, in case of optional arguments for a method:

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

}

parameter is the parameter, its value, "argument" is the argument :)

Thereinafter

Answer 13

This example might help.

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

Hallow

Answer 14

The parameters of a function/method describe to you the values that it uses to calculate its result.

The arguments of a function are the values assigned to these parameters during a particular call of the function/method.

Kaja

Answer 15

Parameters and Arguments

All the different terms that have to do with parameters and arguments can be confusing. However, if you keep a few simple points in mind, you will be able to easily handle these terms.

1. The formal parameters for a function are listed in the function declaration and are used in the body of the function definition. A formal parameter (of any sort) is a kind of blank or placeholder that is filled in with something when the function is called.
2. An argument is something that is used to fill in a formal parameter. When you write down a function call, the arguments are listed in parentheses after the function name. When the function call is executed, the arguments are plugged in for the formal parameters.
3. The terms call-by-value and call-by-reference refer to the mechanism that is used in the plugging-in process. In the call-by-value method only the value of the argument is used. In this call-by-value mechanism, the formal parameter is a local variable that is initialized to the value of the corresponding argument. In the call-by-reference mechanism the argument is a variable and the entire variable is used. In the call- by-reference mechanism the argument variable is substituted for the formal parameter so that any change that is made to the formal parameter is actually made to the argument variable.

Source: Absolute C++, Walter Savitch

That is,

Disaccharide

Answer 16

The terms are somewhat interchangeable. The distinction described in other answers is more properly expressed with the terms formal parameter for the name used inside the body of the function and parameter for the value supplied at the call site (formal argument and argument are also common).

Also note that, in mathematics, the term argument is far more common and parameter usually means something quite different (though the parameter in a parametric equation is essentially the argument to two or more functions).

Hosmer

But then again the term argument is also overloaded, at least in complex analysis. – Northwester

I have a parameter with the contention that they're interchangeable. ;) – Badminton

Answer 17

Yes! Parameters and Arguments have different meanings, which can be easily explained as follows:

Function Parameters are the names listed in the function definition.

Function Arguments are the real values passed to (and received by) the function.

Encroach

Answer 18

Simple Explanations without code

A "parameter" is a very general, broad thing, but an "argument: is a very specific, concrete thing. This is best illustrated via everyday examples:

Example 1: Vending Machines - Money is the parameter, $2.00 is the argument

Most machines take an input and return an output. For example a vending machine takes as an input: money, and returns: fizzy drinks as the output. In that particular case, it accepts as a parameter: money.

What then is the argument? Well if I put $2.00 into the machine, then the argument is: $2.00 - it is the very specific input used.

Example 2: Cars - Petrol is the parameter

Let's consider a car: they accept petrol (unleaded gasoline) as an input. It can be said that these machines accept parameters of type: petrol. The argument would be the exact and concrete input I put into my car. e.g. In my case, the argument would be: 40 litres of unleaded petrol/gasoline.

Example 3 - Elaboration on Arguments

An argument is a particular and specific example of an input. Suppose my machine takes a person as an input and turns them into someone who isn't a liar.

What then is an argument? The argument will be the particular person who is actually put into the machine. e.g. if Colin Powell is put into the machine then the argument would be Colin Powell.

So the parameter would be a person as an abstract concept, but the argument would always be a particular person with a particular name who is put into the machine. The argument is specific and concrete.

That's the difference. Simple.

Confused?

Post a comment and I'll fix up the explanation.

Agathaagathe

System.out.println(344); vs int v=344; System.out.println(v); which is argument/parameter in Java? Can you please help me? – Decrease

@Decrease perhaps ask a new question for these things. 344 is the argument. the parameter to println looks like an integer in this case. – Followthrough

Answer 19

An argument is an instantiation of a parameter.

Lindholm

It's the explanation I was given by another programmer long ago, and I thought it was a very clear and concise one. I posted it here for that reason. – Lindholm

Answer 20

Arguments are actual values passed to parameters.

Fitment

Answer 21

I'm still not happy with all these answers. They all start talking about "function declarations" and my monkey brain has already wandered off and started thinking about unicorns. That doesn't help me remember at all, it's just the definition.

I want something that I can immediately and forever hold in my head.

The only answer here that I quickly understand is:

"Arguments are actual values that are passed in".

Arguments are easier to define and as long as you know what they are then you know parameters are the other.

The other way I can think of it is:

• Arguments are the variables outside the function
• Parameters are the variables inside the function

Simplified down to:

Arguments outside, parameters inside

If any one wants to disagree with me, you can leave your arguments outside ;)

Genuine

This is how I have always remembered it "Take your arguments outside" – Ferdelance

Just imagine a Platypus eating an Apple. – Beera

Answer 22

Logically speaking,we're actually talking about the same thing. But I think a simple metaphor would be helpful to solve this dilemma.

If the metaphors can be called various connection point we can equate them to plug points on a wall. In this case we can consider parameters and arguments as follows;

Parameters are the sockets of the plug-point which may take various different shapes. But only certain types of plugs fit them.
Arguments will be the actual plugs that would be plugged into the plug points/sockets to activate certain equipments.

Introspect

Answer 23

Oracle's Java tutorials define this distinction thusly: "Parameters refers to the list of variables in a method declaration. Arguments are the actual values that are passed in when the method is invoked. When you invoke a method, the arguments used must match the declaration's parameters in type and order."

A more detailed discussion of parameters and arguments: https://docs.oracle.com/javase/tutorial/java/javaOO/arguments.html

Uncivil

Answer 24

They both dont have much difference in usage in C, both the terms are used in practice. Mostly arguments are often used with functions. The value passed with the function calling statement is called the argument, And the parameter would be the variable which copies the value in the function definition (called as formal parameter).

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

In the above code num1 and num2 are formal parameters and a and b are actual arguments.

Isaacson

Answer 25

Parameter is a variable in a function definition
Argument is a value of parameter

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

?>

Frontogenesis

Answer 26

It's explained perfectly in Parameter (computer programming) - Wikipedia

Loosely, a parameter is a type, and an argument is an instance.

In the function definition f(x) = x*x the variable x is a parameter; in the function call f(2) the value ``2 is the argument of the function.

And Parameter - Wikipedia

In computer programming, two notions of parameter are commonly used, and are referred to as parameters and arguments—or more formally as a formal parameter and an actual parameter.

For example, in the definition of a function such as

y = f(x) = x + 2,

x is the formal parameter (the parameter) of the defined function.

When the function is evaluated for a given value, as in

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

is the actual parameter (the argument) for evaluation by the defined function; it is a given value (actual value) that is substituted for the formal parameter of the defined function. (In casual usage the terms parameter and argument might inadvertently be interchanged, and thereby used incorrectly.)

Saltzman

Answer 27

According to Joseph's Alabahari book "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
}

In some human languages (afaik Italian, Russian) synonyms are widely used for these terms.

• parameter = formal parameter
• argument = actual parameter

In my university professors use both kind of names.

Infamous

Answer 28

When we create the method (function) in Java, the method like this..

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

In the parenthesis, these are the parameters, and when we call the method (function) we pass the value of this parameter, which are called the arguments.

Brokaw

Answer 29

Or even simpler...

Arguments in !

Parameters out !

Antemortem

Parameters out doesn't make sense – Genuine

Answer 30

I thought it through and realized my previous answer was wrong. Here's a much better definition

{Imagine a carton of eggs: A pack of sausage links: And a maid } These represent elements of a Function needed for preparation called : (use any name: Lets say Cooking is the name of my function).

A Maid is a method .

( You must __call_ or ask this method to make breakfast)(The act of making breakfast is a Function called Cooking)_

Eggs and sausages are Parameters :

(because the number of eggs and the number of sausages you want to eat is __variable_ .)_

Your decision is an Argument :

It represents the __Value_ of the chosen number of eggs and/or sausages you are Cooking ._

{Mnemonic}

_" When you call the maid and ask her to make breakfast, she __argues_ with you about how many eggs and sausages you should eating. She's concerned about your cholesterol" __

( Arguments , then, are the values for the combination of Parameters you have declared and decided to pass to your Function )

Worrell

Answer 31

As my background and main environment is C, I will provide some statements/citations to that topic from the actual C standard and an important reference book, from also one of the developers of C, which is often cited and common treated as the first unofficial standard of C:

---

The C Programming Language (2nd Edition) by Brian W. Kernighan and Dennis M. Ritchie (April 1988):

Page 25, Section 1.7 - Functions

We will generally use parameter for a variable named in the parenthesized list in a function definition, and argument for the value used in the call of the function. The terms formal argument and actual argument are sometimes used for the same distinction.

ISO/IEC 9899:2018 (C18):

3.3

argument

actual argument

DEPRECATED: actual parameter

expression in the comma-separated list bounded by the parentheses in a function call expression, or a sequence of preprocessing tokens in the comma-separated list bounded by the parentheses in a function-like macro invocation.

---

3.16

parameter

formal parameter

DEPRECATED: formal argument

object declared as part of a function declaration or definition that acquires a value on entry to the function, or an identifier from the comma-separated list bounded by the parentheses immediately following the macro name in a function-like macro definition.

Corriveau

Answer 32

You need to get back to basics.Both constructors and methods have parameters and arguments.Many people even call constructors special kind of methods.This is how a method is declared parameters are used:

      type name(parameters){
           //body of method
          }

And this is how a constructor is declared parameters are used:

classname(parameters){
//body
}

Now lets see an example code using which we calculate the volume of a 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);

           }
    }

So now you understand that when we call a constructor/method on an object at some place later in the code we pass arguments and not parameters.Hence parameters are limited to the place where the logical object is defined but arguments come into play when a physical object gets actually created.

Alice

Answer 33

Parameters are variables that are used to store the data that's passed into a function for the function to use. Arguments are the actual data that's passed into a function when it is invoked:

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

Gannet

Answer 34

The formal parameters for a function are listed in the function declaration and are used in the body of the function definition. A formal parameter (of any sort) is a kind of blank or placeholder that is filled in with something when the function is called.

An argument is something that is used to fill in a formal parameter. When you write down a function call, the arguments are listed in parentheses after the function name. When the function call is executed, the arguments are plugged in for the formal parameters.

The terms call-by-value and call-by-reference refer to the mechanism that is used in the plugging-in process. In the call-by-value method only the value of the argument is used. In this call-by-value mechanism, the formal parameter is a local variable that is initialized to the value of the corresponding argument. In the call-by-reference mechanism the argument is a variable and the entire variable is used. In the call- by-reference mechanism the argument variable is substituted for the formal parameter so that any change that is made to the formal parameter is actually made to the argument variable.

Sorenson

Answer 35

Parameters are the variables received by a function.Hence they are visible in function declaration.They contain the variable name with their data type. Arguments are actual values which are passed to another function. thats why we can see them in function call. They are just values without their datatype

Kamin

Answer 36

Consider the below java code.

public class Test{
   public String hello(String name){
      return "Hello Mr."+name;
   }

  public static void main(String args[]){
     Test test = new Test();
     String myName = "James Bond";
     test.hello(myName);
  }
}

The method definition of hello(String name) declares a String parameter called name. In the main method we are calling the hello method by passing the argument myName.

So parameter is the placeholder where as argument is the actual value for a method.

Barnabas

Answer 37

• Parameter:
  • A value that is already "built in" to a function.
  • Parameters can be changed so that the function can be used for other things.
• Argument:
  • An input to a function
  • A variable that affects a functions result.

Source

Mchenry

Answer 38

This is a key:value issue...

The parameter is the key

The argument is the value

/****************************************/

Example:

name: "Peter"

/********/

let printName = (name) => console.log(name)

printName("Peter")

/********/

In this case, the parameter is "name", the argument is "Peter"

Nutt