问题是“vs”。

没有人指出一个重要的点。在传递值时，会占用额外的内存来存储传递的变量值。

在传递引用时，值不会占用额外的内存(在某些情况下内存是有效的)。

“按值传递”将发送存储在指定变量中的数据的副本，“按引用传递”将发送到变量本身的直接链接。

因此，如果你通过引用传递一个变量，然后改变你传递给它的块中的变量，原始变量将被改变。如果只是按值传递，原始变量将不能被传递到的块所改变，但您将获得调用时它所包含的任何内容的副本。

下面是一个例子，演示了通过值-指针值-引用传递之间的区别:

void swap_by_value(int a, int b){
    int temp;

    temp = a;
    a = b;
    b = temp;
}   
void swap_by_pointer(int *a, int *b){
    int temp;

    temp = *a;
    *a = *b;
    *b = temp;
}    
void swap_by_reference(int &a, int &b){
    int temp;

    temp = a;
    a = b;
    b = temp;
}

int main(void){
    int arg1 = 1, arg2 = 2;

    swap_by_value(arg1, arg2);
    cout << arg1 << " " << arg2 << endl;    //prints 1 2

    swap_by_pointer(&arg1, &arg2);
    cout << arg1 << " " << arg2 << endl;    //prints 2 1

    arg1 = 1;                               //reset values
    arg2 = 2;
    swap_by_reference(arg1, arg2);
    cout << arg1 << " " << arg2 << endl;    //prints 2 1
}

“参照传递”方法有一个重要的局限性。如果参数声明为引用传递(因此前面有&号)，其对应的实际参数必须是变量。

引用“按值传递”形式参数的实际参数一般可以是表达式，因此它不仅可以使用变量，还可以使用文字甚至函数调用的结果。

该函数不能将值放在变量以外的东西中。它不能将新值赋给文字或强制表达式更改其结果。

PS:你也可以在当前的线程中检查Dylan Beattie的答案，它用简单的语言解释了它。

这里有一个例子:

#include <iostream>

void by_val(int arg) { arg += 2; }
void by_ref(int&arg) { arg += 2; }

int main()
{
    int x = 0;
    by_val(x); std::cout << x << std::endl;  // prints 0
    by_ref(x); std::cout << x << std::endl;  // prints 2

    int y = 0;
    by_ref(y); std::cout << y << std::endl;  // prints 2
    by_val(y); std::cout << y << std::endl;  // prints 2
}

A major difference between them is that value-type variables store values, so specifying a value-type variable in a method call passes a copy of that variable's value to the method. Reference-type variables store references to objects, so specifying a reference-type variable as an argument passes the method a copy of the actual reference that refers to the object. Even though the reference itself is passed by value, the method can still use the reference it receives to interact with—and possibly modify—the original object. Similarly, when returning information from a method via a return statement, the method returns a copy of the value stored in a value-type variable or a copy of the reference stored in a reference-type variable. When a reference is returned, the calling method can use that reference to interact with the referenced object. So, in effect, objects are always passed by reference.

In c#, to pass a variable by reference so the called method can modify the variable's, C# provides keywords ref and out. Applying the ref keyword to a parameter declaration allows you to pass a variable to a method by reference—the called method will be able to modify the original variable in the caller. The ref keyword is used for variables that already have been initialized in the calling method. Normally, when a method call contains an uninitialized variable as an argument, the compiler generates an error. Preceding a parameter with keyword out creates an output parameter. This indicates to the compiler that the argument will be passed into the called method by reference and that the called method will assign a value to the original variable in the caller. If the method does not assign a value to the output parameter in every possible path of execution, the compiler generates an error. This also prevents the compiler from generating an error message for an uninitialized variable that is passed as an argument to a method. A method can return only one value to its caller via a return statement, but can return many values by specifying multiple output (ref and/or out) parameters.

请参阅c#讨论和示例链接文本

通过值传递-函数复制变量并使用副本(因此它不会改变原始变量中的任何内容)

引用传递——函数使用原始变量。如果你改变了另一个函数中的变量，它也会改变原来的变量。

示例(复制并使用/自己尝试一下):

#include <iostream>

using namespace std;

void funct1(int a) // Pass-by-value
{
    a = 6; // Now "a" is 6 only in funct1, but not in main or anywhere else
}

void funct2(int &a)  // Pass-by-reference
{
    a = 7; // Now "a" is 7 both in funct2, main and everywhere else it'll be used
}

int main()
{
    int a = 5;

    funct1(a);
    cout << endl << "A is currently " << a << endl << endl; // Will output 5
    funct2(a);
    cout << endl << "A is currently " << a << endl << endl; // Will output 7

    return 0;
}

保持简单，伙计们。成堆的文字是个坏习惯。