C语言函数传递方式
 
值传递
 
定义
 
所谓的值传递，顾名思义就是使用变量、常量、数组等作为函数的参数。实际是将实参的值复制到形参相应的存储单元中，即形参和实参分别占用不同的存储单元。
 
特点
 
值传递的特点是单向传递，即主调函数被调用时给形参分配存储单元，把实参的值传递给形参，在调用结束后，形参的存储单元被释放，而形参值的任何变化都不会影响到实参的值，实参的存储单元仍保留并维持数值不变。
 
示意图
 

 其实值传递过程中由隐含的一步，如下代码所示：
 
	int x = a;
	int y = b; 
 
所以swap1函数交换的是x和y，而原来的a和b从未改变。
 
代码演示
 
void swap1(int x,int y)
{
	int temp;
	temp = x;
	x = y;
	y = temp;
	printf("x = %d,y = %d\n",x,y);	
}
int main(int argc, char *argv[]) 
{
	int a = 12,b = 24;
    swap1(a,b); // 值传递 
    printf("a = %d b = %d",a,b);
}

 
运行结果
 
 
 
地址传递
 
说明
 
大家都知道，在C语言中，数组名就代表数组的首地址。所谓的地址传递，指的就是函数的参数是数组名或者指针。传递的是数组的首地址或指针的值，而形参接收到的是地址，即指向实参的存储单元，形参和实参占用相同的存储单元，即形参和实参是相同的。
 
特点
 
形参并不存在存储空间，编译系统不为形参数组分配内存。因此在数组名或指针作函数参数时所进行的传送只是地址传送，形参在取得该地址之后，与实参共同拥有一段内存空间，形参的变化也就是实参的变化。
 
示意图
 

 注意：这里也有一个隐含动作，如下代码所示：
 
	x = &a;
	y = &b;
 
分别将a的地址，b的地址赋值给x和y，这样swap2函数操作的数其实就是a和b。
 
代码演示
 
void swap2(int* x,int* y)
{
	int temp;
	temp = *x;
	*x = *y;
	*y = temp;
	printf("x = %d y = %d\n",*x,*y);
}
int main(int argc, char *argv[]) 
{
	int a = 12,b = 24;
	swap2(&a,&b); //地址传递
	printf("a = %d b = %d",a,b); 
}
 
运行结果
 

 以上就是C语言值传递和地址传递的区别了，相信大家应该很清楚了吧！

C语言值传递 地址传递 引用传递：
 
 
1.值传递
 
eg:
 
 
void Exchg1(int x, int y)
{
     int tmp;
     tmp = x;
     x = y;
     y = tmp;
     printf("x = %d, y = %d\n", x, y);
}
main()
{
     int a = 4,b = 6;
     Exchg1(a, b);
     printf("a = %d, b = %d\n", a, b);
     return(0);
}
 

 

 
 
本例中：在调用Exchg1(a,b)时最开始做的两个隐含动作是：int x=a;int y=b;.及x=a;y=b;
 
        原来函数在调用时是隐含地把参数a,b的值分别赋值给了x,y。之后在函数体内一直是对形参x,y进行操作。并没有对a,b进行任何操作。
 
        函数只是把a,b的值通过赋值传递将值传递给了x,y。函数里操作的只是x,y的值，并不是a,b的值。这就是所谓的值传递
 
 
 
2.地址传递
 
eg:
 
 
void Exchg2(int *px, int *py)
{
      int tmp = *px;
      *px = *py;
      *py = tmp;
      printf("*px = %d, *py = %d.\n",*px, *py);
}
main()
{
      int a = 4,b = 6;
      Exchg2(&a, &b);
      printf("a = %d, b = %d.\n", a,b);
      return(0);
}
 

 

 
 
本例中：在调用Exchg2(&a,&b)时最开始做的两个隐含动作是：int *px=&a;int *py=&b;.及 px=&a;py=&b;.
 
        原来函数在调用时是隐含地把参数a,b的地址分别传递给了指针px,py。之后在函数体内一直是对指针px,py进行操作。也就是对a,b的地址进行的操作。
 
        
 
(注：上述有说到，复制到tmp中，这种说法是不对的，tmp是一个变量。但不妨碍我们理解)
 
 
 
3.引用传递
 
eg:
 
 
void Exchg3(int &x, int &y)
{
     int tmp = x;
     x = y;
     y = tmp;
     printf("x= %d,y = %d\n", x, y);
}
main()
{
     int a = 4,b =6;
     Exchg3(a, b);
     printf("a= %d, b = %d\n", a, b);
     return(0);
}
 

 

 
 
本例中：与值传递相比，代码上只有只有一处不同，即函数定义处：void Exchg3(int &x, int &y)
 
Exchg3函数的定义处Exchg3(int&x, int &y)。调用时我们可以像值传递（如： Exchg1(a, b); ）一样调用函数（如： Exchg3(a,b);）。但是x、y前都有一个取地址符号“&”。有了这个，调用Exchg3时函数会将a、b 分别代替了x、y了，我们称：x、y分别引用了a、b变量。这样函数里操作的其实就是实参a、b本身了，因此函数的值可在函数里被修改
 
 

什么是值传递，地址传递和引用传递？它们有什么不同？这在学校考试，找工作面试中都是常见的问题。它们之间的区别容易搞错，长时间不用也容易忘记。最近又被问到这个问题，想想还是整理一下记下来，也方便以后参考。
 
首先，看以下三段代码。
 
1. 
 
 

void swap1(int x, int y)  
{
  int tmp=x;
  x=y;
  y=tmp;
  print(“x=%d, y=%d\n”, x, y);
}

void main()
{
  int a=2,b=7;
  swap1(a,b) ;
  printf(“a=%d, b=%d\n”, a, b);
}

 
输出结果是什么？
 
---
 
x=7, y=2
 
a=2, b=7
 
 

 
 
2. 
 
 

void swap2(int *px, int *py)
{
  int tmp=*px;
  *px=*py;
  *py=tmp;
  print(“*px=%d, *py=%d\n”, *px, *py);
}

void main()
{
  int a=2;
  int b=7;
  swap2(&a,&b);
  Print(“a=%d, b=%d\n”, a, b);
}
这次输出结果是什么？
 
---
 
 
*px=7, *py=2
 
a=7, b=2
 
 

 
3. 
 
 

void swap3(int &x, int &y)
{
  int tmp=x;
  x=y;
  y=tmp;
  print(“x=%d, y=%d\n”, x, y);
}

void main()
{
  int a=2;
  int b=7;
  swap3(a,b);
  Print(“a=%d, b=%d\n”, a, b);
}
那这次输出结果又是什么？

 
 
---
 
 
x=7, y=2
 
a=7, b=2
 

 
 
接下来，分析一下为什么是这样的结果呢？
 
上面的1，2，3分别是值传递，地址传递，和引用传递。
 
先看值传递。swap1函数的操作是将x，y进行对调。需要注意的是，对形参的操作不会影响到a，b。我们可以设想，在swap1函数执行语句的最前面，隐含地存在x=a; y=b;这两条语句，这样就便于理解了。当a，b把值赋给x，y之后，对x，y不论再做什么操作，都不会影响到a，b本身。
 

 
 
再看地址传递。注意，这时的函数的声明和调用的写法与值传递不同。
 
函数声明：swap2(int *px, int *py)
 
函数调用：swap2(&a, &b)
 
 
但是与值传递的分析一样，我们同样可以设想，在swap2函数里，隐含地存在px=&a; py=&b;这两条语句，这表示a的地址代入到了px，b的地址代入到了py。这样一来，对*px, *py的操作就是a，b本身的操作。所以a，b的值被对调了。
 

 
 
接下来看引用传递。先看函数的声明和调用的写法，函数调用和值传递的写法是一样的，但是函数声明是不一样的。
 
函数声明：swap3(int &x, int &y)
 
函数调用：swap3(a, b)
 
因为定义的x，y前面有&取地址符，调用函数swap3时，a，b分别代替了x，y，即x，y分别引用了a，b变量。因此，函数里的操作，实际上是对实参a，b本身的操作，其值发生了对调。
 
 

 

首先发现问题是好事情，只有发现问题，才会有提高，不然整体都在写相同的代码，写个几年，不还是原来的水平。
 

 
 
这个地址传递和值传递
 
不论在什么语言都有这个问题，一旦出问题，就是很微妙的问题。想破天都不知道为啥的时候，多半就是 这个问题在作怪啦。
 
(js,java,c)c语言的话就很常见的问题，java有时候会出现，js也会，
 
 
lz表示最近在java里面遇到的这个问题，学会了还有java里面还有clone这个神器。
 
在js里面遇到，暂时还没调查有没有同样的clone方法存在。
 
出现问题的代码如下：
 
 
function initEditModal_SI(node) {
   if (node.siArray == undefined) {
       node.siArray = new Object();
   }
   var sis = new Array();
   // for (var index in node.siArray) {
     // sis.push(node.siArray[index]);
   // }
   if (node.siArray != null) {
            $.each(node.siArray, function (id, obj) {
            if(obj != null){
                var object = new Object();
                object.id = obj.id;
                object.ip = obj.ip;
                object.name = obj.name;
                object.portEnd = obj.portEnd;
                object.portStart = obj.portStart;
                sis.push(object);
            }
        });
   };
。。。。。。。。。。。。。。。
   
}

 
原意是想：
 
new一个数组sis，可以自由修改数组 sis 里面的值，且不会影响到后台获得的node对象里面的siArray里面的值。
 
这样就可以在想reset这个页面的时候还可以用node对象去做reset，但是，发现，修改了sis数组的值，node.siArray里面的值也跟着变了。
 
那么，问题来了。
 

 
 

 
 
注释掉的部分就是出问题的部分。
 

 
 
为什么会有问题：
 
因为新建的数组，直接用的就是函数传递过来的参数的地址。(直接给push进去，push进去的不是值，而是值的地址)
 
所以在以后的代码中修改了做这个新建的数组，看似没有修改原来数据的值，但是在你再次使用原来的参数去初始化页面的时候发现这个时候，原来的参数的值。莫名其妙的改变啦。
 
这个时候只能用下面代替的方法，其实和clone的性质是一样的，完完全全的真真正正的clone一遍，
 
然后就可以随便修改这个值，用于页面操作。
 
只要不提交数据到后台去保存。那么本地的那个node.siArray(即传进方法的node.siArray)就不会被改变，
 
当然，当你保存数据的时候，这个全局参数才应该跟着刷新一下，才可以保持数据的一致。
 

 
 
至于string类型，不论是java还是js，还是c一旦声明了一个string 那他就固定了。就算修改他，也只是再新建一个而已。(这个东西在新手面试的时候经常被问到)
 

 
 
总结如下：
 
1.JS的基本类型，是按值传递的。
 
2.对于对象而言：分两种情况
 
(a).如果传递给函数的参数是对象，并且修改了这个对象的属性(某些字段的值)，那么奇妙的问题就来了。原参数就被修改了。
 
(b).如果传递给函数的参数是对象，并且没有修改这个对象的属性的值，而是把对象作为一个整体来操作的话。原参数就没有被修改。
 

 
 
要想知道为什么。即原理
 
按共享传递
 
具体看链接：
 
http://www.jb51.net/article/60568.htm
 
 

 
 
他的代码我测试了。
 
输出结果和写的是一样的
 

 
 
再看下面的例子，也是有值传递和地址引用传递的问题。
 
(虽然看似效果是没问题的，但是不好，有点误打误撞的感觉)
 
 
var widgetArr = [];		//这个数组是个全局变量，为了维护后台请求过来的数据，方便在所有方法里面使用。
/**
 * 根据ID从全局数组中找到需要的一个。
 * 这个返回的就是一个引用，你在其他地方修改
 * 返回的参数，同时这个全局数组也被修改了。
 */
function getWidgetInfoById(id) {
	for (var wi = 0; wi < widgetArr.length; wi++) {
        if (widgetArr[wi].infoId == id)
            return widgetArr[wi];
    }
    return undefined;
}
ajax.({//更新全局变量中的某个到数据库中，然后前台的数据也得同步更新。
xxxxxxxxxx
success : function (data) {
	if (data.success) {
		var widgetinfo = getWidgetInfoById($item.attr("id"));
		//经过一些操作之后修改了全局变量，但是没必要再去后台请求一次全局变量
		//所以下面是想
		//更新一下对应的全局变量的属性
		widgetinfo.colspan = $item.attr("colspan");
		widgetinfo.rowspan = $item.attr("rowspan");		
	} else {
		GMS.error("x");
	}
}
xxxxxxxxxx
});

 上述代码里面虽然看似更新的是一个局部变量，好像也真是修改 了一个局部变量的属性值，乍一看好像跟全局变量没关系，但是他却达到了他想要的效果：全局变量数组的值也跟着被修改了。因为他们都是引用的同一个地方的值，就是2个人各自都拿了一把钥匙，以为自己都打开的是自己家，其实这个“自己家”是同一个地方。就看你这个编程者知不知道这2个是不是开的同一个门咯。 
 
为了不产生歧义，所以最好还是直接对全局数组修改，代码意思才直接，不会给人模糊的感觉。因为你都不确定你改的是啥。