From Wikipedia, the free encyclopedia

In computer programming, a parameter is a variable which takes on the meaning of a corresponding argument passed in a call to a subroutine. In the most common case, call-by-value, a parameter acts within the subroutine as a local (isolated) copy of the argument, but in other cases, e.g. call-by-reference, the argument supplied by the caller can be affected by actions within the called subroutine (as discussed in evaluation strategy).

Nearly all programming languages support subroutine parameters. The semantics for how parameters can be declared and how the arguments get passed to the parameters of subroutines are defined by the language, but the details of how this is represented in any particular computer system depends on the calling conventions of that system.

Contents 1 Parameters and arguments 2 Datatypes 3 Argument passing 3.1 Default arguments 3.2 Variable-length parameter lists 3.3 Named parameters 4 See also

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. When discussing code that is calling into a subroutine, any values or references passed into the subroutine are the arguments, and the place in the code where these values or references are given is the parameter list. When discussing the code inside the subroutine definition, the variables in the subroutine's parameter list are the parameters, while the values of the parameters at runtime are the arguments.

Many programmers use parameter and argument interchangeably, depending on context to distinguish the meaning. In practice, distinguishing between the two terms is usually unnecessary in order to use them correctly or communicate their use to other programmers. Alternatively, the equivalent terms formal parameter and actual parameter may be used.

To better understand the difference, consider the following subroutine written in C:

int sum(int addend1, int addend2)
{
    return addend1 + addend2;
}

The subroutine sum has two parameters, named addend1 and addend2. It adds the values passed into the parameters, and returns the result to the subroutine's caller (using a technique automatically supplied by the C compiler).

The code which calls the sum subroutine might look like this:

int sumValue;
int value1 = 40;
int value2 = 2;

sumValue = sum(value1, value2);

The variables value1 and value2 are initialized with values. The variables are not arguments or parameters.

At runtime, the values assigned to these variables are passed to the subroutine sum. In the sum subroutine, the parameters addend1 and addend2 are evaluated, yielding the arguments 40 and 2, respectively. The values of the arguments are added, and the result is returned to the caller, where it is assigned to the variable sumValue.

In strongly-typed programming languages that are explicitly typed, each parameter's type is specified in the subroutine's declaration. Languages using type inference attempt to discover the types automatically from the function's body and usage, while weakly-typed programming languages defer type resolution to run-time.

Some languages use a special keyword (e.g. void) to indicate that the subroutine has no parameters; in formal type theory, such functions take an empty parameter list (whose type is not void, but rather unit).

The exact mechanism for assigning arguments to parameters, called argument passing, depends upon the evaluation strategy used for that parameter (typically call-by-value), which may be specified using keywords.

Some programming languages such as Windows PowerShell and Python allow for a default argument to be explicitly or implicity given in a subroutine's declaration. This allows the caller to omit that argument when calling the subroutine. If the default argument is explicitly given, then that value is used if it is not provided by the caller. If the default argument is implicit (sometimes by using a keyword such as Optional) then the language provides a well-known value (such as null, Empty, zero, an empty string, etc.) if a value is not provided by the caller.

PowerShell example:

function doc($g = 1.21) {
  "$g gigawatts? $g gigawatts? Great Scott!"
}

PS> doc
1.21 gigawatts? 1.21 gigawatts? Great Scott!

PS> doc 88
88 gigawatts? 88 gigawatts? Great Scott!

Some languages allow subroutines to be defined to accept a variable number of arguments. For such languages, the subroutines must iterate through the list of arguments.

PowerShell example:

function marty {
  $args | foreach { "back to the year $_" }
}

PS> marty 1985
back to the year 1985

PS> marty 2015 1985 1955
back to the year 2015
back to the year 1985
back to the year 1955

Some programming languages allow subroutines to have named parameters. This allows the calling code to be more self-documenting. It also provides more flexibility to the caller, often allowing the order of the arguments to be changed, or for arguments to be omitted as needed.

PowerShell example:

function jennifer($young, $old) {
  "Young Jennifer: I'm $young!"
  "Old Jennifer: I'm $old!"
}

PS> jennifer 'old' 'young'
Young Jennifer: I'm old!
Old Jennifer: I'm young!

PS> jennifer -old 'young' -young 'old'
Young Jennifer: I'm old!
Old Jennifer: I'm young!

• Evaluation strategy
• Operator overloading
• Free variables and bound variables