关于语言不可知论：argument 和 parameter有什么区别？


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

当口头上谈论方法时，我从不确定是否要使用参数或参数等词。不管怎样，其他人都知道我的意思，但是什么是正确的，这些术语的历史是什么？

我是一个C程序员，但我也想知道人们是否在不同的语言中使用不同的术语。

据记载，我是自学的，没有计算机科学背景。(请不要告诉我完整地阅读代码，因为我这样做是为了其他人的利益，他们还没有史蒂夫·麦康奈尔的绝妙著作。)

总结

一般的共识似乎是在团队环境中可以互换使用这些术语。除非您定义了精确的术语，否则您也可以使用"正式参数/参数"和"实际参数/参数"来消除歧义。

相关讨论

参数是方法定义中的变量。当调用一个方法时，参数是您传递给该方法参数的数据。

1
2
3
4
5
6
public void MyMethod(string myParam) { }

...

string myArg1 ="this is my argument";
myClass.MyMethod(myArg1);
相关讨论

参数是函数声明中的变量。

参数是传递给函数的该变量的实际值。

相关讨论

已经有一个关于主题的维基百科条目(参见参数)定义并区分术语参数和参数。简而言之，参数是函数/过程/方法签名的一部分，参数是在运行时和/或调用站点为参数提供的实际值。

维基百科文章还指出，这两个术语通常是同义的(尤其是在非正式地推理代码时)：

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.

假设C中的以下示例函数加上两个整数，那么x和y将被称为其参数：

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

在使用add的调用站点，如下面的示例，123和456将被称为调用的参数。

1
int result = add(123, 456);

另外，一些语言规范(或正式文档)选择只使用参数或参数，并使用诸如形式和实际这样的形容词来消除这两种情况之间的歧义。例如，C/C++文档通常将函数参数称为形式参数和函数调用参数作为实际参数。例如，请参阅VisualC++语言引用中的"正式和实际参数"。

相关讨论

简单的：

  • 参数→占位符(这意味着占位符属于函数命名并在函数体中使用)
  • 参数→实际值(这表示由函数调用传递的实际值)
相关讨论

参数是在调用函数时必须填充的内容。你所说的是论点。

简单设置：参数进入参数，参数是参数的值。

更多信息：http://en.wikipedia.org/wiki/parameter_u(计算机科学)参数和参数

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认证工具包(考试70-483)，C编程，第1版，WROX，2013

真实世界案例场景

1
2
3
4
5
6
7
8
// 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);

参数是函数声明中的变量。

参数是传递给函数的该变量的实际值。enter image description here

在编辑方面，我常常对人们如何忘记：结构语言是基于自然语言的。

用英语

"参数"是一个占位符。他们以口头语言设置响应格式。根据定义，它是呼叫方，限制了响应。

"论点"是一种正在考虑的立场。你提出你的观点：你考虑一个论点。

主要区别

辩论的主题作用是代理人。参数的主题作用是接受者。

交互作用

把论点看作是男性的部分，使参数成为女性的部分。参数进入参数。

用法

参数通常用于定义中。参数通常用于调用。

问题

完成句子以减少不协调。

(a)说到定义：

  • 将使用什么参数[]？
  • 这个参数将是什么？

    • (b)谈到调用：

  • 您将使用什么参数，[]？
  • 此参数的[]将是什么？

    • 答案

    (a)

  • 打开/插入/反对/使用此参数
  • 参数…拿

    • (b)

  • 有什么样的论证
  • 参数…用于

    • 重叠

    正如你所能想象的，回答后：在口语中，这些词有时会产生相同的反应！

    因此，通常情况下：

    • 通常，如果有人需要参数信息，他们希望了解更多关于类型、变量名等的信息。如果只提供示例参数，他们可能会感到困惑。

      • 通常，如果有人想要参数信息，他们想要知道传递给函数或其参数的值是什么。

    函数/方法的参数向您描述用于计算其结果的值。

    的参数是在函数/方法的特定调用期间分配给这些参数的值。

    或者在方法的可选参数的情况下，这样更容易记住：

    1
    2
    3
    4
    public void Method(string parameter ="argument")
    {

    }

    parameter为参数，其值，"argument"为参数：)

    参数和参数

    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.

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

    • 资料来源：绝对C++，Walter Savitch

    也就是说，

    enter image description here

    假设你是一家航空公司。你造了一架飞机。你在里面安装座位。然后，你把飞机装满乘客，送到某个地方。乘客(或者更确切地说，一些时空变化的版本)下船。第二天，你重复使用同一架飞机，同样的座位，但这次乘客不同。

    飞机是你的功能。

    参数是座椅。

    争论的是坐在那些座位上的乘客。

    这个例子可能会有所帮助。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    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;
    }

    这些术语有些可互换。其他答案中描述的区别用术语形式参数更恰当地表示，即函数体内部使用的名称和调用站点提供的值的参数(形式参数和参数也是常见的)。

    同样要注意的是，在数学中，术语参数更为常见，参数通常意味着非常不同的东西(尽管参数方程中的参数本质上是两个或多个函数的参数)。

    相关讨论

    永远记住：接收参数时传递参数。

    参数是参数的实例化。

    相关讨论

    无代码的简单解释

    "参数"是一个非常普遍、广泛的事物，但"参数：是一个非常具体、具体的事物"。这一点最好通过日常实例加以说明：

    示例1：自动售货机-money是参数，$2.00是参数

    大多数机器接受输入并返回输出。例如，自动售货机以"钱"作为输入，以"汽水"作为输出。在这种情况下，它接受作为参数：金钱。

    那么争论是什么呢？好吧，如果我把$2.00放进机器，那么参数是$2.00——它是使用的非常具体的输入。

    示例2：汽车-汽油是参数

    让我们考虑一辆车：他们接受汽油(无铅汽油)作为输入。可以说，这些机器接受的参数类型：汽油。这场争论将是我在车里投入的准确而具体的投入。例如，在我的例子中，论点是：40升无铅汽油/汽油。

    例3——论据的阐述

    参数是输入的一个特定的例子。假设我的机器把一个人作为输入，把他变成一个不说谎的人。

    那么争论是什么呢？争论将是实际被放入机器的特定人员。例如，如果把科林·鲍威尔放进机器里，那么这个论点就是科林·鲍威尔。

    所以参数是一个抽象的概念，但是参数总是一个特定的人，有一个特定的名字，被放入机器中。这一论点具体而具体。

    这就是区别。简单。

    困惑的？

    发表评论，我会修正解释。

    对！参数和参数有不同的含义，可以简单地解释如下：

    函数参数是函数定义中列出的名称。

    函数参数是传递给函数(并由函数接收)的实际值。

    它们在C语言中的用法没有太大差别，这两个词都被使用了。在实践中。大多数参数通常与函数一起使用。与函数调用语句一起传递的值称为参数，参数将是复制函数定义中的值的变量(称为形参)。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    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
    ", 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;
    }

    上述代码中，num1和num2是形式参数，a和b是实际参数。

    或者更简单…

    争论！

    参数输出！

    Oracle的Java教程定义了这样的区别："参数是指方法声明中的变量列表。参数是在调用方法时传入的实际值。调用方法时，所用参数的类型和顺序必须与声明的参数匹配。"

    关于参数和参数的更详细讨论：https://docs.oracle.com/javase/tutorial/java/javaoo/arguments.html

    从逻辑上讲，我们实际上是在谈论同一件事。但我认为一个简单的比喻将有助于解决这一困境。

    如果隐喻可以被称为各种连接点，我们可以把它们等同于墙上的插头点。在这种情况下，我们可以考虑如下参数和参数：

    参数是插头点的插座，可能具有不同的形状。但只有某些类型的插头适合它们。参数将是插入插头点/插座以激活某些设备的实际插头。

    参数是函数定义中的变量
    参数是参数的值

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    <?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);

    ?>

    根据约瑟夫的《阿拉巴哈里书》(C 7.0，第49页)的记载：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    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
    }

    在一些人类语言(阿法克语、意大利语、俄语)中，同义词被广泛用于这些术语。

    • 参数=形式参数
    • 参数=实际参数

    在我的大学里，教授们都用这两种名字。

    当我们在爪哇中创建方法(函数)时，这样的方法…

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

    在括号中，这些是参数，当我们调用方法(函数)时，我们传递这个参数的值，这个值被称为参数。

    参数是函数接收到的变量，因此它们在函数声明中可见。它们包含变量名及其数据类型。参数是传递给另一个函数的实际值。这就是为什么我们可以在函数调用中看到它们。它们只是没有数据类型的值

    函数的形式参数列在函数声明中，并在函数定义的主体中使用。形式参数(任何类型)是一种空白或占位符，在调用函数时用某些内容填充。

    参数是用来填充形参的东西。写下函数调用时，参数列在函数名后面的括号中。执行函数调用时，将插入形式参数的参数。

    "按值调用"和"参照调用"是指插入过程中使用的机制。在按值调用方法中，只使用参数的值。在这个按值调用机制中，形参是一个局部变量，它被初始化为相应参数的值。在引用调用机制中，参数是一个变量，使用整个变量。在按引用调用机制中，参数变量被替换为形参，因此对形参所做的任何更改实际上都会对参数变量进行。

    参数是用于存储传递给函数以供函数使用的数据的变量。参数是调用函数时传递给函数的实际数据：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    // 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);

    我想了想，意识到我以前的回答是错的。这里有一个更好的定义

    想象一下一盒鸡蛋：一包香肠链：还有一个女佣这些代表了准备所需的功能元素，叫做：(使用任何名称：假设烹饪是我的功能名称)。

    女仆是一种方法。

    (你必须打电话给或要求这个方法做早餐)(做早餐的行为是一个叫做烹饪的功能)_

    鸡蛋和香肠是参数：

    (因为你想吃的鸡蛋和香肠的数量是可变的。)_

    你的决定是一个论点：

    它代表所选鸡蛋和/或香肠数量的价值。_

    {助记}

    _"当你给女佣打电话让她做早餐时，她会和你争论你应该吃多少鸡蛋和香肠。她担心你的胆固醇__

    (参数是您声明并决定传递给函数的参数组合的值)

    它在参数(计算机编程)维基百科中解释得很好。

    不严格地说，参数是类型，参数是实例。

    在函数定义f(x) = x*x中，变量x是参数；在函数调用f(2)中，值`` 2是函数的参数。

    和参数-维基百科

    在计算机程序设计中，通常使用参数的两个概念，称为参数和参数，或更正式地称为形式参数和实际参数。

    例如，在函数的定义中，例如

    y = f(x) = x + 2,

    x是定义函数的形式参数(参数)。

    当函数对给定值进行计算时，如

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

    是由定义函数计算的实际参数(参数)；它是由定义函数的形式参数替换的给定值(实际值)。(在不经意的用法中，术语参数和参数可能会不经意地互换，从而错误地使用。)

    您需要回到基础知识。构造函数和方法都有参数和参数。许多人甚至调用构造函数特殊类型的方法。这就是如何使用方法声明的参数：

    1
    2
    3
          type name(parameters){
               //body of method
              }

    这就是如何使用构造函数声明参数的方法：

    1
    2
    3
    classname(parameters){
    //body
    }

    现在让我们看一个示例代码，我们使用它计算立方体的体积：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    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);

               }
        }

    现在你明白了，当我们在代码后面的某个地方对一个对象调用一个构造函数/方法时，我们传递的是参数而不是参数。因此，参数仅限于定义逻辑对象的地方，但实际创建物理对象时参数起作用。