Parameter (computer programming)
   HOME

TheInfoList



OR:

In
computer programming Computer programming is the process of performing a particular computation (or more generally, accomplishing a specific computing result), usually by designing and building an executable computer program. Programming involves tasks such as anal ...
, a parameter or a formal argument is a special kind of variable used in a
subroutine In computer programming, a function or subroutine is a sequence of Instruction (computer science), program instructions that performs a specific task, packaged as a unit. This unit can then be used in programs wherever that particular task shou ...
to refer to one of the pieces of data provided as input to the subroutine. These pieces of data are the values of the arguments (often called ''actual arguments'' or ''actual parameters'') with which the subroutine is going to be called/invoked. An ordered list of parameters is usually included in the definition of a subroutine, so that, each time the subroutine is called, its arguments for that call are evaluated, and the resulting values can be assigned to the corresponding parameters. Unlike ''argument'' in usual mathematical usage, the ''argument'' in computer science is the actual input expression passed/supplied to a function, procedure, or routine in the invocation/call statement, whereas the ''parameter'' is the variable inside the implementation of the subroutine. For example, if one defines the add subroutine as def add(x, y): return x + y, then x, y are parameters, while if this is called as add(2, 3), then 2, 3 are the arguments. Note that variables (and expressions thereof) from the calling context can be arguments: if the subroutine is called as a = 2; b = 3; add(a, b) then the ''variables'' a, b are the arguments, not the ''values'' 2, 3. See the Parameters and arguments section for more information. The semantics for how parameters can be declared and how the (value of) arguments are passed to the parameters of subroutines are defined by the evaluation strategy of the language, and the details of how this is represented in any particular computer system depend on the
calling convention In computer science, a calling convention is an Programming language implementation, implementation-level (low-level) scheme for how subroutines or functions receive Parameter (computer programming), parameters from their caller and how they Retu ...
of that system. In the most common case,
call by value In a programming language, an evaluation strategy is a set of rules for evaluating expressions. The term is often used to refer to the more specific notion of a ''parameter-passing strategy'' that defines the kind of value that is passed to the f ...
, a parameter acts within the subroutine as a new local variable initialized to the value of the argument (a
local Local may refer to: Geography and transportation * Local (train) In rail transport, a train (from Old French , from Latin , "to pull, to draw") is a series of connected vehicles that run along a railway track and Passenger train, transport ...
(isolated) copy of the argument if the argument is a variable), but in other cases, e.g.
call by reference In a programming language, an evaluation strategy is a set of rules for evaluating expressions. The term is often used to refer to the more specific notion of a ''parameter-passing strategy'' that defines the kind of value that is passed to the f ...
, the argument variable supplied by the caller can be affected by actions within the called subroutine.


Example

The following program in the
C programming language ''The C Programming Language'' (sometimes termed ''K&R'', after its authors' initials) is a computer programming book written by Brian Kernighan and Dennis Ritchie, the latter of whom originally designed and implemented the language, as well as ...
defines a function that is named "SalesTax" and has one parameter named "price". The type of price is "double" (i.e. a double-precision floating point number). The function's return type is also a double. double SalesTax(double price) After the function has been defined, it can be invoked as follows: SalesTax(10.00); In this example, the function has been invoked with the ''argument'' 10.00. When this happens, 10.00 will be assigned to price, and the function begins calculating its result. The steps for producing the result are specified below, enclosed in . 0.05 * price indicates that the first thing to do is multiply 0.05 by the value of price, which gives 0.50. return means the function will produce the result of 0.05 * price. Therefore, the final result (ignoring possible round-off errors one encounters with representing decimal fractions as binary fractions) is 0.50.


Parameters and arguments

The terms ''parameter'' and ''argument'' may have different meanings in different programming languages. Sometimes they are used interchangeably, and the context is used to distinguish the meaning. The term ''parameter'' (sometimes called ''formal parameter'') is often used to refer to the variable as found in the function definition, while ''argument'' (sometimes called ''actual parameter'') refers to the actual input supplied at function call. For example, if one defines a function as def f(x): ..., then x is the parameter, and if it is called by a = ...; f(a) then a is the argument. A parameter is an (unbound) variable, while the argument can be a literal or variable or more complex expression involving literals and variables. In case of call by value, what is passed to the function is the value of the argument – for example, f(2) and a = 2; f(a) are equivalent calls – while in call by reference, with a variable as argument, what is passed is a reference to that variable - even though the syntax for the function call could stay the same. The specification for pass-by-reference or pass-by-value would be made in the function declaration and/or definition. Parameters appear in procedure definitions; arguments appear in procedure calls. 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. Loosely, a parameter is a type, and an argument is an instance. A parameter is an intrinsic property of the procedure, included in its definition. For example, in many languages, a procedure to add two supplied integers together and calculate the sum would need two parameters, one for each integer. In general, a procedure may be defined with any number of parameters, or no parameters at all. If a procedure has parameters, the part of its definition that specifies the parameters is called its ''parameter list''. By contrast, the arguments are the expressions supplied to the procedure when it is called, usually one expression matching one of the parameters. Unlike the parameters, which form an unchanging part of the procedure's definition, the arguments may vary from call to call. Each time a procedure is called, the part of the procedure call that specifies the arguments is called the ''argument list''. Although parameters are also commonly referred to as arguments, arguments are sometimes thought of as the actual values or references assigned to the parameter variables when the subroutine is called at run-time. 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. For example, in C, when dealing with threads it's common to pass in an argument of type void* and cast it to an expected type: void ThreadFunction(void* pThreadArgument) To better understand the difference, consider the following function written in C: int Sum(int addend1, int addend2) The function ''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'' function might look like this: int value1 = 40; int value2 = 2; int sum_value = Sum(value1, value2); The variables ''value1'' and ''value2'' are initialized with values. ''value1'' and ''value2'' are both arguments to the ''sum'' function in this context. At runtime, the values assigned to these variables are passed to the function ''Sum'' as arguments. In the ''Sum'' function, 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 ''sum_value''. Because of the difference between parameters and arguments, it is possible to supply inappropriate arguments to a procedure. The call may supply too many or too few arguments; one or more of the arguments may be a wrong type; or arguments may be supplied in the wrong order. Any of these situations causes a mismatch between the parameter and argument lists, and the procedure will often return an unintended answer or generate a runtime error.


Alternative convention in Eiffel

Within the Eiffel software development method and language, the terms ''argument'' and ''parameter'' have distinct uses established by convention. The term ''argument'' is used exclusively in reference to a routine's inputs, and the term ''parameter'' is used exclusively in type parameterization for generic classes. Consider the following routine definition: sum (addend1: INTEGER; addend2: INTEGER): INTEGER do Result := addend1 + addend2 end The routine sum takes two arguments addend1 and addend2, which are called the routine's formal arguments. A call to sum specifies actual arguments, as shown below with value1 and value2. sum_value: INTEGER value1: INTEGER = 40 value2: INTEGER = 2 … sum_value := sum (value1, value2) Parameters are also thought of as either formal or actual. Formal generic parameters are used in the definition of generic classes. In the example below, the class HASH_TABLE is declared as a generic class which has two formal generic parameters, G representing data of interest and K representing the hash key for the data: class HASH_TABLE , K -> HASHABLE When a class becomes a client to HASH_TABLE, the formal generic parameters are substituted with actual generic parameters in a generic derivation. In the following attribute declaration, my_dictionary is to be used as a character string based
dictionary A dictionary is a listing of lexemes from the lexicon of one or more specific languages, often arranged Alphabetical order, alphabetically (or by radical-and-stroke sorting, radical and stroke for ideographic languages), which may include inf ...
. As such, both data and key formal generic parameters are substituted with actual generic parameters of type STRING. my_dictionary: HASH_TABLE TRING, STRING


Datatypes

In
strongly typed programming language In computer programming Computer programming is the process of performing a particular computation (or more generally, accomplishing a specific computing result), usually by designing and building an executable computer program. Programming i ...
s, each parameter's type must be specified in the procedure declaration. Languages using
type inference Type inference refers to the automatic detection of the type (type theory), type of an expression in a formal language. These include programming languages and mathematical type systems, but also natural languages in some branches of computer scie ...
attempt to discover the types automatically from the function's body and usage. Dynamically typed programming languages defer type resolution until run-time. Weakly typed languages perform little to no type resolution, relying instead on the programmer for correctness. Some languages use a special keyword (e.g. ''void'') to indicate that the subroutine has no parameters; in formal
type theory In mathematics Mathematics is an area of knowledge that includes the topics of numbers, formulas and related structures, shapes and the spaces in which they are contained, and quantities and their changes. These topics are represented in mo ...
, such functions take an empty parameter list (whose type is not ''void'', but rather ''
unit Unit may refer to: Arts and entertainment * UNIT, a fictional military organization in the science fiction television series ''Doctor Who'' * Unit of action, a discrete piece of action (or beat) in a theatrical presentation Music * Unit (album), ...
'').


Argument passing

The exact mechanism for assigning arguments to parameters, called ''argument passing'', depends upon the evaluation strategy used for that parameter (typically
call by value In a programming language, an evaluation strategy is a set of rules for evaluating expressions. The term is often used to refer to the more specific notion of a ''parameter-passing strategy'' that defines the kind of value that is passed to the f ...
), which may be specified using keywords.


Default arguments

Some programming languages such as Ada, C++,
Clojure Clojure (, like ''closure'') is a dynamic programming language, dynamic and functional programming, functional dialect (computing), dialect of the Lisp (programming language), Lisp programming language on the Java (software platform), Java plat ...
,
Common Lisp Common Lisp (CL) is a dialect of the Lisp programming language, published in ANSI standard document ''ANSI INCITS 226-1994 (S20018)'' (formerly ''X3.226-1994 (R1999)''). The Common Lisp HyperSpec, a hyperlinked HTML version, has been derived ...
, Fortran 90,
Python Python may refer to: Snakes * Pythonidae The Pythonidae, commonly known as pythons, are a Family (biology), family of Venomous snake, nonvenomous snakes found in Africa, Asia, and Australia. Among its members are some of the largest snakes i ...
,
Ruby A ruby is a pinkish red to blood-red colored gemstone, a variety of the mineral corundum (aluminium oxide). Ruby is one of the most popular traditional jewelry gems and is very durable. Other varieties of gem-quality corundum are called sapp ...
, Tcl, and
Windows PowerShell PowerShell is a task automation and configuration management program from Microsoft, consisting of a command-line shell (computing), shell and the associated scripting language. Initially a Windows component only, known as Windows PowerShell, it ...
allow for a
default argument In computer programming Computer programming is the process of performing a particular computation (or more generally, accomplishing a specific computing result), usually by designing and building an executable computer program. Programming i ...
to be explicitly or implicitly 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) PS > doc 1.21 gigawatts? 1.21 gigawatts? Great Scott! PS > doc 88 88 gigawatts? 88 gigawatts? Great Scott! Default arguments can be seen as a special case of the variable-length argument list.


Variable-length parameter lists

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


Named parameters

Some programming languages—such as Ada and
Windows PowerShell PowerShell is a task automation and configuration management program from Microsoft, consisting of a command-line shell (computing), shell and the associated scripting language. Initially a Windows component only, known as Windows PowerShell, it ...
—allow subroutines to have named parameters. This allows the calling code to be more
self-documenting In computer programming, self-documenting (or self-describing) source code and user interfaces follow naming conventions (programming), naming conventions and structured programming conventions that enable use of the system without prior specific ...
. 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($adjectiveYoung, $adjectiveOld) PS > jennifer 'fresh' 'experienced' Young Jennifer: I'm fresh! Old Jennifer: I'm experienced! PS > jennifer -adjectiveOld 'experienced' -adjectiveYoung 'fresh' Young Jennifer: I'm fresh! Old Jennifer: I'm experienced!


Multiple parameters in functional languages

In
lambda calculus Lambda calculus (also written as ''λ''-calculus) is a formal system in mathematical logic for expressing computability, computation based on function Abstraction (computer science), abstraction and function application, application using variable ...
, each function has exactly one parameter. What is thought of as functions with multiple parameters is usually represented in lambda calculus as a function which takes the first argument, and returns a function which takes the rest of the arguments; this is a transformation known as
currying In mathematics and computer science, currying is the technique of translating the evaluation of a Function (mathematics), function that takes multiple Parameter (computer science), arguments into evaluating a sequence of functions, each with a sin ...
. Some programming languages, like ML and
Haskell Haskell () is a General-purpose programming language, general-purpose, static typing, statically-typed, purely functional programming, purely functional programming language with type inference and lazy evaluation. Designed for teaching, resear ...
, follow this scheme. In these languages, every function has exactly one parameter, and what may look like the definition of a function of multiple parameters, is actually
syntactic sugar In computer science, syntactic sugar is Syntax (programming languages), syntax within a programming language that is designed to make things easier to read or to express. It makes the language "sweeter" for human use: things can be expressed more c ...
for the definition of a function that returns a function, etc.
Function application In mathematics, function application is the act of applying a function (mathematics), function to an argument from its domain of a function, domain so as to obtain the corresponding value from its range of a function, range. In this sense, functi ...
is left-associative in these languages as well as in lambda calculus, so what looks like an application of a function to multiple arguments is correctly evaluated as the function applied to the first argument, then the resulting function applied to the second argument, etc.


Output parameters

An output parameter, also known as an out parameter or return parameter, is a parameter used for output, rather than the more usual use for input. Using
call by reference In a programming language, an evaluation strategy is a set of rules for evaluating expressions. The term is often used to refer to the more specific notion of a ''parameter-passing strategy'' that defines the kind of value that is passed to the f ...
parameters, or call by value parameters where the value is a reference, as output parameters is an idiom in some languages, notably C and C++, while other languages have built-in support for output parameters. Languages with built-in support for output parameters include Ada8.2 Parameter Modes


(see Ada subprograms), Fortran (since Fortran 90; see Fortran "intent"), various procedural extensions to SQL, such as
PL/SQL PL/SQL (Procedural Language for SQL) is Oracle Corporation's Procedural programming, procedural programming language, extension for SQL and the Oracle Database, Oracle relational database. PL/SQL is available in Oracle Database (since version 6 ...
(see PL/SQL functions) and
Transact-SQL Transact-SQL (T-SQL) is Microsoft's and Sybase's proprietary extension to the SQL (Structured Query Language) used to interact with relational databases. T-SQL expands on the SQL standard to include procedural programming, local variables, variou ...
, C# and the .NET Framework,
Swift Swift or SWIFT most commonly refers to: * SWIFT, an international organization facilitating transactions between banks ** SWIFT code * Swift (programming language) * Swift (bird), a family of birds It may also refer to: Organizations * SWIFT, a ...
, and the scripting language TScript (see TScript function declarations). More precisely, one may distinguish three types of parameters or parameter modes: ''s'', ''output parameters,'' and ''s;'' these are often denoted in, out, and in out or inout. An input argument (the argument to an input parameter) must be a value, such as an initialized variable or literal, and must not be redefined or assigned to; an output argument must be an assignable variable, but it need not be initialized, any existing value is not accessible, and must be assigned a value; and an input/output argument must be an initialized, assignable variable, and can optionally be assigned a value. The exact requirements and enforcement vary between languages – for example, in Ada 83 output parameters can only be assigned to, not read, even after assignment (this was removed in Ada 95 to remove the need for an auxiliary accumulator variable). These are analogous to the notion of a value in an expression being an r-value (has a value), an l-value (can be assigned), or an r-value/l-value (has a value and can be assigned), respectively, though these terms have specialized meanings in C. In some cases only input and input/output are distinguished, with output being considered a specific use of input/output, and in other cases only input and output (but not input/output) are supported. The default mode varies between languages: in Fortran 90 input/output is default, while in C# and SQL extensions input is default, and in TScript each parameter is explicitly specified as input or output. Syntactically, parameter mode is generally indicated with a keyword in the function declaration, such as void f(out int x) in C#. Conventionally output parameters are often put at the end of the parameter list to clearly distinguish them, though this is not always followed. TScript uses a different approach, where in the function declaration input parameters are listed, then output parameters, separated by a colon (:) and there is no return type to the function itself, as in this function, which computes the size of a text fragment: TextExtent(WString text, Font font : Integer width, Integer height) Parameter modes are a form of
denotational semantics In computer science, denotational semantics (initially known as mathematical semantics or Scott–Strachey semantics) is an approach of formalizing the meanings of programming languages by constructing mathematical objects (called ''denotations'' ...
, stating the programmer's intent and allowing compilers to catch errors and apply optimizations – they do not necessarily imply
operational semantics Operational semantics is a category of Formal language, formal programming language Semantics (computer science), semantics in which certain desired properties of a Computer program, program, such as correctness, safety or security, are formal ve ...
(how the parameter passing actually occurs). Notably, while input parameters can be implemented by call by value, and output and input/output parameters by call by reference – and this is a straightforward way to implement these modes in languages without built-in support – this is not always how they are implemented. This distinction is discussed in detail in the ''Ada '83 Rationale,'' which emphasizes that the parameter mode is abstracted from which parameter passing mechanism (by reference or by copy) is actually implemented. For instance, while in C# input parameters (default, no keyword) are passed by value, and output and input/output parameters (out and ref) are passed by reference, in PL/SQL input parameters (IN) are passed by reference, and output and input/output parameters (OUT and IN OUT) are by default passed by value and the result copied back, but can be passed by reference by using the NOCOPY compiler hint. A syntactically similar construction to output parameters is to assign the
return value In computer programming Computer programming is the process of performing a particular computation (or more generally, accomplishing a specific computing result), usually by designing and building an executable computer program. Programming ...
to a variable with the same name as the function. This is found in Pascal and Fortran 66 and Fortran 77, as in this Pascal example: function f(x, y: integer): integer; begin f := x + y; end; This is semantically different in that when called, the function is simply evaluated – it is not passed a variable from the calling
scope Scope or scopes may refer to: People with the surname * Jamie Scope (born 1986), English footballer * John T. Scopes (1900–1970), central figure in the Scopes Trial regarding the teaching of evolution Arts, media, and entertainment * Cinem ...
to store the output in.


Use

The primary use of output parameters is to return multiple values from a function, while the use of input/output parameters is to modify state using parameter passing (rather than by shared environment, as in global variables). An important use of returning multiple values is to solve the
semipredicate problem In computer programming, a semipredicate problem occurs when a subroutine intended to return a useful value can fail, but the signalling of failure uses an otherwise valid return value. The problem is that the caller of the subroutine cannot tell ...
of returning both a value and an error status – see Semipredicate problem: Multivalued return. For example, to return two variables from a function in C, one may write: int width int height; F(x, &width, &height); where x is an input parameter and width and height are output parameters. A common use case in C and related languages is for
exception handling In computing and computer programming, exception handling is the process of responding to the occurrence of ''exceptions'' – anomalous or exceptional conditions requiring special processing – during the Execution (computing), execution of a C ...
, where a function places the return value in an output variable, and returns a boolean corresponding to whether the function succeeded or not. An archetypal example is the TryParse method in .NET, especially C#, which parses a string into an integer, returning true on success and false on failure. This has the following signature:Int32.TryParse Method (String, Int32)
/ref> public static bool TryParse(string s, out int result) and may be used as follows: int result; if (!Int32.TryParse(s, result)) Similar considerations apply to returning a value of one of several possible types, where the return value can specify the type and then value is stored in one of several output variables.


Drawbacks

Output parameters are often discouraged in modern programming, essentially as being awkward, confusing, and too low-level – commonplace return values are considerably easier to understand and work with.CA1021: Avoid out parameters
/ref> Notably, output parameters involve functions with side effects (modifying the output parameter) and are semantically similar to references, which are more confusing than pure functions and values, and the distinction between output parameters and input/output parameters can be subtle. Further, since in common programming styles most parameters are simply input parameters, output parameters and input/output parameters are unusual and hence susceptible to misunderstanding. Output and input/output parameters prevent
function composition In mathematics, function composition is an operation that takes two function (mathematics), functions and , and produces a function such that . In this operation, the function is function application, applied to the result of applying the ...
, since the output is stored in variables, rather than in the value of an expression. Thus one must initially declare a variable, and then each step of a chain of functions must be a separate statement. For example, in C++ the following function composition: Object obj = G(y, F(x)); when written with output and input/output parameters instead becomes (for F it is an output parameter, for G an input/output parameter): Object obj; F(x, &obj); G(y, &obj); In the special case of a function with a single output or input/output parameter and no return value, function composition is possible if the output or input/output parameter (or in C/C++, its address) is also returned by the function, in which case the above becomes: Object obj; G(y, F(x, &obj));


Alternatives

There are various alternatives to the use cases of output parameters. For returning multiple values from a function, an alternative is to return a
tuple In mathematics Mathematics is an area of knowledge that includes the topics of numbers, formulas and related structures, shapes and the spaces in which they are contained, and quantities and their changes. These topics are represented in m ...
. Syntactically this is clearer if automatic sequence unpacking and
parallel assignment In computer programming Computer programming is the process of performing a particular computation (or more generally, accomplishing a specific computing result), usually by designing and building an executable computer program. Programming ...
can be used, as in Go or Python, such as: def f(): return 1, 2 a, b = f() For returning a value of one of several types, a
tagged union In computer science Computer science is the study of computation, automation, and information. Computer science spans theoretical disciplines (such as algorithms, theory of computation, information theory, and automation) to Applied scien ...
can be used instead; the most common cases are
nullable type Nullable types are a feature of some programming languages which allow a value to be set to the special value NULL instead of the usual possible values of the data type. In statically typed languages, a nullable type is an option type, while in d ...
s ( option types), where the return value can be null to indicate failure. For exception handling, one can return a nullable type, or raise an exception. For example, in Python one might have either: result = parse(s) if result is None: # exception handling or, more idiomatically: try: result = parse(s) except ParseError: # exception handling The micro-optimization of not requiring a local variable and copying the return when using output variables can also be applied to conventional functions and return values by sufficiently sophisticated compilers. The usual alternative to output parameters in C and related languages is to return a single data structure containing all return values. For example, given a structure encapsulating width and height, one can write: WidthHeight width_and_height = F(x); In object-oriented languages, instead of using input/output parameters, one can often use call by sharing, passing a reference to an object and then mutating the object, though not changing which object the variable refers to.


See also

*
Command-line argument A command-line interpreter or command-line processor uses a command-line interface (CLI) to receive command Command may refer to: Computing * Command (computing), a statement in a computer language * COMMAND.COM, the default operating system ...
*
Evaluation strategy In a programming language A programming language is a system of notation for writing computer program, computer programs. Most programming languages are text-based formal languages, but they may also be visual programming language, graphical ...
*
Operator overloading In computer programming, operator overloading, sometimes termed ''operator ad hoc polymorphism'', is a specific case of polymorphism (computer science), polymorphism, where different Operator (computer programming), operators have different impl ...
*
Free variables and bound variables In mathematics, and in other disciplines involving formal languages, including mathematical logic and computer science, a free variable is a Mathematical notation, notation (symbol) that specifies places in an expression (mathematics), expressi ...


Notes


References

{{DEFAULTSORT:Parameter (Computer Science) Subroutines Variable (computer science)