C#中按引用传递与按值传递的区别,以及ref与out关键字的用法详解

/给三个整数从小到大排序并求和及其平均值
//其中，三个待求整数及其排序的结果由引用参数传递；其和由输出参数传递；平均值由返回值返回。
//在main()方法中实现三个待求整数的输入及结果的输出
//目的：定义方法；调用方法；；理解形参和实参的引用传递关系；熟悉引用参数和输出参数的使用。
using system;
class class1
 {
   //x,y,z是形参，按值传递
   static void sort(int x, int y, int z)
    {
      int temp=0;
      if(x>y)
       {
         temp=x;
         x=y;
         y=temp;
       }
      if(y>z)
       {
         temp=z;
         z=y;
         if(x>temp)
          {
            y=x;
            x=temp;
          }
         else
          {
            y=temp;
          }
       }
       console.writeline("the sorted list is {0},{1},{2}",x,y,z);
       x=x+y+z;
    }

   //i,j,k,total是形参，按引用传递(ref参数,out参数，都是按引用传递的方式)
   static double average(ref int i, ref int j, ref int k, out int total)
    {
      double l = 0;
      total = i+j+k;
      i=total;
      l=(double)(total/3.0);
      return l;
    }

   static void main()
    {
      //a,b,c是实参，将要赋值给形参i,j,k,total;
      int a, b, c;

      //声明out参数result,可以不用初始化它
      int result;

      console.write("please enter the first number a =");
      a = convert.toint32(console.readline());
      console.write("please enter the second number b =");
      b = convert.toint32(console.readline());
      console.write("please enter the third number c =");
      c = convert.toint32(console.readline());     

      sort(a,b,c);

      //sort(int x, int y, int z)函数中，形参x,y,z是按值传递的，所以即使函数中有x=x+y+z;函数      //执行后实参a值不变。
      console.writeline("the original value of /"a/" is {0}, it hadn't been changed in spite "+"of manipulating the sort() method, because it is transmitted by a value para /"x/"!",a);

      //average(ref int i, ref int j, ref int k, out int total)函数中，形参a,b,c,result都是        //按引用传递的，执行后实参a值改变。
      console.writeline("the average result is {0}",average(ref a,ref b,ref c, out result));
      //ref参数在调用方法前必须几经初始化。
      //而out参数在调用方法前可以没有初始化，他们都以引用传递方式传递

      console.writeline("the value of /"a/" has been changed due to the average() method"    +" is manipulated, and it is transmitted by a ref para /"ref i/"! now it is {0}!",a);

      console.readline();
    }
 }

问题与解答：

1，值传递时，为什么被调用的方法中的形参值的改变不会影响到相应的实参？
答：因为按值传递时，系统首先为被调用的方法的形参分配内存空间，然后把实参中的值按位置一一对应“复制”给形参。形参中存储的值只是一份实参的拷贝，因此被调用方法中形参值的任何改变都不会影响到相应的形参。

2，值传递和引用传递有什么不同，什么是值参数，它以什么方式传递？
答：值传递时，系统首先为被调用方法的形参分配内存空间，并将实参的值按位置一一对应地复制给形参，此后，被调用方法中形参值得任何改变都不会影响到相应的实参； 而引用传递时，系统不是将实参本身的值复制后传递给形参，而是将其引用值（即地址值）传递给形参，因此，形参所引用的该地址上的变量与传递的实参相同，方法体内相应形参值得任何改变都将影响到作为引用传递的实参。

3，什么是形参，什么是实参？
答：
形参：在定义函数中指定的参数就是形参，在未出现函数调用时，他们并不占内存中的存储单元，只有在发生函数调用时，函数中的形参才被分配内存单元。在调用结束后，形参所占的内存单元也被释放。

实参：实参可以是常量、变量和表达式，但要求有确定的值。在调用时将实参的值赋给形参。在内存中，实参单元和形参单元是不同的单元。在调用函数时，给形参分配存储单元，并将实参对应的值传递给形参，调用结束后，形参单元被释放，实参单元仍保留原值。

理解：
实参就是送进去方法中的东西~~行参就是把送进来的东西在方法中进行拷贝加工，加工完后方法就返回一个东西--返回值。

值传递的时候，实参是不变的~形参是随着计算而变化的~~
指针/引用传递的时候~~行参怎么变~实参就怎么变.... 

参数的传递分为：1.值方式参数传递，2.引用方式参数传递。
1）按值传递（不能改变实参）
实参是变量，表达式等数值。

函数调用的时候，实参和形参存在于内存中2快不同的区域，实参先自己复制一份拷贝，再把拷贝传给形参。由于是传递的是拷贝，所以实参不会受形参的影响，实参值不会被改变。

2）按地址传递（可以改变实参）
实参是指针/引用。

函数调用的时候，指针传给你，形参和实参指针都一样，对形参的任何操作就等于对实参的操做。实参的值就可以被改变。

对参数的影响：
2种数据类型：值类型+引用类型
2种传参方式：值传参+引用传参(ref与out关键字)；

以上的四种参数的组合 除了值传参方式传递值类型数据，其他的组合方式对参数的操作都会影响参数，都会改变！

值类型：简单类型(int,float,double,long,char,bool)+结构+枚举
存储结构:数据存放在栈中(栈:先进后出;单入口,单出口);效率高
赋值方式:传的是值

引用类型：除去简单类型(int,float,double)+结构+枚举以外的类型都是引用数据类型。如string;object;类；数组；委托；接口．．．
存储结构:栈中存地址;堆中放数据;
赋值方式:传的是数据的地址。

形参:全称为"形式参数"是在定义函数名和函数体的时候使用的参数,目的是用来接收调用该函数时传入的参数.
实参:全称为"实际参数"是在调用时传递个该函数的参数.

形参和实参的类型必须要一致,或者要符合隐含转换规则,
当形参和实参不是指针类型时（即不是按引用传递，而是按值传递时）,
在该函数运行时,形参和实参是不同的变量,
他们在内存中位于不同的位置,形参将实
参的内容复制一份,在该函数运行结束的时候形参被释放,
而实参内容不会改变.

而如果函数的参数是指针类型变量（按引用传递）,在调用该函数的过程
中,传给函数的是实参的地址,在函数体内部使用的也是
实参的地址,即使用的就是实参本身.所以在函数体内部
可以改变实参的值.

按引用传递最大的用途是实现“操作符”重载！

ref参数与out参数的区别在于：ref参数在调用方法前必须几经初始化。而out参数在调用方法前可以没有初始化，他们都以引用传递方式传递

c++有了“引用传递”后，“形参的改变不影响实参”被判无效。因为传递给函数的并不是一个值，而是变量自身。在函数中定义的形参虽然还是局部变量，但却是一个引用。虽然这个引用的作用域仅限于函数内部，但是由于它与实参就是同一回事，所以对它的操作完全等同于对实参的操作。比如你叫“黑旋风”去买鱼，或者叫“铁牛”去买鱼，去的都是同一个人。

c++为什么要有“引用传递”这回事？一种说法是只有引用才能达到操作符重载的目的，这个以后再谈。但是，撇开这个不谈，形参是不是引用，直接影响了程序执行的效率。前面提到过，函数调用时要用实参的值去初始化形参，初始化的过程包含了定义一个变量、然后给它赋一个值两个过程，如果这个变量并不是内部变量，而是一个类对象，那么，定义一个类对象可能很复杂，而初始化这个对象一样会很复杂。而引用只是给对象取一个别名，不涉及定义与初始化，离开作用域时也不用释放。

相比之下，用指针传递可以避免类对象的定义、初始化与释放。只需要付出指针变量的定义、初始化与释放的代价。但是，指针的杀伤力太大。即使是熟练的程序员，也不能保证绝不出现“野指针”，野针的代价几乎无一例外是程序崩溃。

引用也不是吃素的，如果说指针传递是“帮你配了一把我家的钥匙”，那么引用传递就是直接把我家的财产都交给了你。有时，我们使用引用传递仅仅是为了效率，而不希望实参被修改，那就要记得把形参标记为const，如“uint getlength(const cstring&)”。

顺便说一句，指针传递也可以这样做。把形参定义为指向const对象的指针（而不是const指针），可以降低杀伤力，保护实参所对应的内存。如果是普通的值传递，那么有没有const对函数外部并不影响。但是，我个人认为，有时候加上const也是一件好事。如果程序的逻辑并不需要改变参数，而实际上误写了代码，加上const可以让编译器帮我们找出bug。