一、数组做函数参数   
 
 
数组做函数参数：在传递过程中，传递的是实参中每个元素的拷贝，如果实参数组较大，效率比较低
package main

import "fmt"

//数组作为函数的参数，是进行值传递
//实参数组的每一个元素，在传递的时候，都给形参拷贝一份，因此当实参数组较大，效率就比较低
//简而言之：形参数组是实参数组的复制品
func transferAndModify(arr [5]int) {
	arr[0] = 111
	fmt.Println("modify:arr=", arr)  //modify:arr= [111 5 3 9 10]
}

func main() {
	// 定义一个数组
	arr := [5]int{1, 5, 3, 9, 10}
	// 定义一个函数
	transferAndModify(arr) // 值传递
	fmt.Println("main:arr=", arr)   //main:arr= [1 5 3 9 10]
}
 
 
 
二、数组指针做函数的参数
 
 
   数组的指针做函数的参数：传递实参的内存地址，指向实参的内存
package main

import "fmt"

//p指向实参数组arr,p就是数组arr的指针
//*p代表指针所指向的内存，就是实参arr

func transferAndModify(p *[5]int) {
	(*p)[0] = 111
	fmt.Println("transferAndModify:*p=", *p)  //transferAndModify:*p= [111 5 3 9 10]
}

func main() {
	// 定义一个数组
	arr := [5]int{1, 5, 3, 9, 10}
	// 定义一个函数
	transferAndModify(&arr) //地址传递
	fmt.Println("main:arr=", arr)  //main:arr= [111 5 3 9 10]
}
 
 

看下面代码：
int  main()
{
	int a[5]={3,6,4,2,5};
	char *ptrChar="hello world";//ptrChar是char类型的指针，指向内存空间
	int *ptrInt=a;//ptrInt是指向int类型的指针
	printf("sizeof(char):%d\n",sizeof(char));
	printf("sizeof(int):%d\n",sizeof(int));
        printf("sizeof(ptrChar):%d\n",sizeof(ptrChar));
	printf("sizeof(ptrInt):%d\n",sizeof(ptrInt));
	printf("value of ptrChar is:%d\n",ptrChar);
	printf("value of (ptrChar+1) is:%d\n",ptrChar+1);
	printf("value of ptrInt is:%d\n",ptrInt);
	printf("value of (ptrInt+1) is:%d\n",ptrInt+1);
	system("pause");
	return 1;
}




程序运行结果如下：


从程序的运行结果可以得出：
指针本身是一个变量，它所存储的是另一个变量的地址，指针变量所占的内存是4个字节，这与它所指向的变量所占的内存空间大小是没有关系的，指针变量本身和它所指向的内存空间是完全独立的。
在源代码级别上对指针变量+1，编译器内部增加的值是该指针所指向的变量的宽度，这种优化避免了指针指向一个不完整的地址。
下面的代码：
void arraySort(int num[5],int lenth)
{
	int i,j,temp;
	int tmpLenth=sizeof(num)/sizeof(num[0]);
	printf("tmpLenth:%d\n",tmpLenth);
	for(i=0;i<lenth;i++)
	{
		for(j=i+1;j<lenth;j++)
		{
			if(num[i]>num[j])
			{
				temp=num[i];
				num[i]=num[j];
				num[j]=temp;
			}
		}
	}
}
void displayArray(int num[5],int lenth)
{
	int i;
	for(i=0;i<lenth;i++)
	{
		printf("%d\t",num[i]);
	}
	printf("\n");
}
int main()
{
	
	int a[5]={3,6,4,2,5};
	int lenth=sizeof(a)/sizeof(a[0]);//a是数组名，也是数组的首地址，sizeof(a)是整个数组所占的内存空间的大小
	printf("lenth:%d\n",lenth);
	printf("origin:");
	displayArray(a,lenth);
	arraySort(a,lenth);
	printf("final:");
	displayArray(a,lenth);
	system("pause");
	return 1; 
}

运行结果：




这里，数组做函数参数，运行结果发现函数内sizeof(num)/sizeof(num[0])的结果是1，就是说传过来的参数根本不是数组。这里如果真的把数组作为函数参数的话，需要分配临时的栈区执行拷贝等操作，所以编译器对代码进行了优化，把数组退化成了指针，因为指针做函数参数本身就是C语言的精华所在。这里的参数写成num[5],但是编译器在优化的时候会直接忽略中括弧里的数，常见的写法是不写括弧里的数：num[],或者直接写成指针*pNum。

如果Go中的数组作为函数的参数，那么实际传递的参数是一份数组的拷贝，而不是数组的指针。（C/C++区分）
 首先看一下C++的代码：
 
#include <iostream>
#include<map>
using namespace std;

void fun(int a[]){
    a[0]=100;
}

int main(){
    int a[4]={1,2,3,4};
    fun(a);
    cout<<a[0];
    return 0;
}
 
执行结果：a[0]=100
 再看一下golang的代码:
 
package main

import "fmt"

func sum(a [4]int){
	a[0]=100
}

func main(){
	a:=[4]int{1,1,1,1}//数组
	sum(a)
	fmt.Println(a[0])
}
 
执行结果：a[0]=1
 
go语言中针对这种问题解决方法有两种：
 方法一：传递数组的地址操作
 
package main

import "fmt"

func sum(a *[4]int){//指针
	a[0]=100
}

func main(){
	a:=[4]int{1,1,1,1}
	sum(&a)//引用
	fmt.Println(a[0])
}
 
执行结果:a[0]=100
 
方法二：使用切片代替数组（切片和数组的区别可参考：切片数组区别）
 
package main

import "fmt"

func sum(a []int){
	a[0]=100
}

func main(){
	a:=[]int{1,1,1,1}//切片
	sum(a)
	fmt.Println(a[0])
}
 
执行结果：a[0]=100

1、数组作为函数参数
 
C语言中，数组做为函数的参数，退化为指针。数组作为参数传给函数时，传的是指针而不是数组，传递的是数组的首元素的地址。这里我们以将以整形变量排序来讲解。
 
void sortArray ( int a[ ] , int num ) 以及void sortArray (int a[100] ,int num ) 都可以用void sortArray (int *a ,int num ) 表示。一般来说函数参数如果为数组，可以有两个参数，一个是数组名，一个是数组长度。对于排序而已，一般是要知道给定数组的首元素的地址，即需要排序的数组在内存中的起始地址，同时还需给定待排序的数据个数。
 
       这里我们采用简单的冒泡排序，模块代码如下：
 
 
 /*2016-7-12 Jason Gel */
void sortArray(int *a ,int num )
{
	int i ,j ,temp;
	for(i =0 ;i <num;i++)              //外层：每次选定出需要排序的一个元素，依次向后
	{
		for( j=i+1; j<num; j++ )  //内层：外层选定的一个元素与其后所有元素依次比较，找出最小的元素
		{
			if(a[i]>a[j])     //交换类代码
			{
				temp = a[i];
				a[i]=a[j];
				a[j]=temp;				
			}
		}
	}
	
}           
 
 
2、参数传递
 
 
如果a是一个数组，很显然大家都知道如何传递参数，代码如下：
 
 
	int num =0 ;                       //在32机器中告诉C编译器分配4个字节的内存 
	int a [] = {1,3,5,12,6,7,54,32};   //告诉C编译器分配32个字节的内存 	
 //    num = sizeof(a)/sizeof(int);  
     num = sizeof(a)/sizeof(a[0]); 
	printf("排序之前：");
	printArray(a,num);
	sortArray(a,num); 
	printf("排序之后：");
	printArray(a,num);
}

如果a是一个单一整形变量的地址，还能类似于用 num = sizeof(a)/sizeof(a[0]) 求得num的值吗？如以下代码： 
 
 
        int test =5;
	int *p = &test;
	int num1 = 0;
	
	num1 = sizeof(p)/sizeof(p[0]);
	sortArray(p,num1); 
	printf("排序之后：");
	printArray(p,num1);
 
           这样可以吗？很多人犯迷糊了，p[0]不是指数组首元素的值吗，这里p不是数组啊，p[0]都好像不存在，怎么能这样用？我们一定还记得，在C语言中可以用指针表示数组的每一个元素，本质上，对同一个对象有两种不同的符号表示，如定义：a[n]时等价于*(a+n)，即寻址到内存的a，然后移动n个单元，再取出数组。故p[0]等价于*(p+0),该值的类型为int型。
 
   num1=sizeof(p)/sizeof(p[0]) 等价于 num1=sizeof(p)/sizeof(int );
 
该语句在语法上面没有任何错误，但是在32机器和64位机器运行结果不同，在32机器出现正常结果，64位机器出现错误结果，原因见本文最后。
 
3、声明数组参量
 

 
 前提：实际参数是一个数组名。C对于int a  [ ] 和 int * a作了同样解释，即a是指向int的指针。 
 

 由于原型允许省略名称，因此下列4种原型都是等价的。
 

 
/**   函数原型声明4中等价形式 
int sum (int *a , int n)
int sum (int * , int )
int sum (int a[] , int n)
int sum (int [] , int )   //可能略微不熟悉的一种 
*/ 
       定义函数时，名称是不可以省略的，以下两种形式是等价的。
 

 
 
 
/**   函数原型声明4中等价形式 
int sum (int *a , int n)
{}
int sum (int a[] , int n)
{}
*/ 
 
 
4、a与&a的区别
 
 

 
	int num =0 ;                       //在32机器中告诉C编译器分配4个字节的内存 
	int a [] = {1,3,5,12,6,7,54,32};   //告诉C编译器分配32个字节的内存 
	
	printf("a:%d ,a+1:%d,&a:%d,&a+1:%d\n",a,a+1,&a,&a+1) ;
	
	//a+1 和 &a+1 结果不一样  
	//虽然输出结果上面，a和&a一样 。 但是a 和 &a所代表的数据类型不一样
	
	/*重要*/ 
	//a 代表的数据首元素的地址 (首元素)，同时与整个数组地址重合，但其不能代表整个数组，只能代表起始个体的地址 
	//&a代表的是整个数组的地址   （特别特别的注意） 它的加1是以整块数组所占字节数总数为单位1
 
 
 

 输出
 结果：a:1638176 ,a+1:1638180,&a:1638176,&a+1:1638208
 
 
 
5、指针所占字节数
 

             
   指针所占用的字节数和操作系统和编译器有关。
 

 
/**
2016-7-12 Jason Gel 
**/
#include<stdio.h>
#include<stdlib.h>
#include<string.h>

//void printArray(int * a ,int num ) 和  void printArray(int a[] ,int num )是等价的

//函数定义时候，名称是不可以省略的。函数原型容许省略名称。
/**   函数原型声明4中等价形式 
int sum (int *a , int n)
int sum (int * , int )
int sum (int a[] , int n)
int sum (int [] , int )   //可能略微不熟悉的一种 
*/ 
 
void printArray(int * a ,int num )
{
	int i ;
	for(i = 0; i< num; i++)
	{
		printf("%3d",a[i]);
	}
	printf("\n");
}
//这里用的是冒泡排序(起泡排序) 
void sortArray(int *a ,int num )
{
	int i ,j ,temp;
	for(i =0 ;i <num;i++)              //外层：每次选定出需要排序的一个元素，依次向后
	{
		for( j=i+1; j<num; j++ )  //内层：外层选定的一个元素与其后所有元素依次比较，找出最小的元素
		{
			if(a[i]>a[j])     //交换类代码
			{
				temp = a[i];
				a[i]=a[j];
				a[j]=temp;				
			}
		}
	}
	
}                         

int main ()
{
	int num =0 ;                       //在32机器中告诉C编译器分配4个字节的内存 
	int a [] = {1,3,5,12,6,7,54,32};   //告诉C编译器分配32个字节的内存 
	
	int test =5;
	int *p = &test;
	int num1 = 0;
	
	num1 = sizeof(p)/sizeof(p[0]);
	
	printf("num1:%d, sizeof(p):%d,sizeof(p[0]):%d \n",num1,sizeof(p),sizeof(p[0]));
	sortArray(p,num1); 
	printf("单一元素排序之后：");
	printArray(p,num1);
	
	printf("a:%d ,a+1:%d,&a:%d,&a+1:%d\n",a,a+1,&a,&a+1) ;
    printf("sizeof(num1):%d\n",sizeof(num1)); 
    printf("sizeof(a):%d\n\n",sizeof(a)); 
	printf("sizeof(int):%d sizeof(double):%d sizeof(char):%d \n",sizeof(int),sizeof(double),sizeof(char)) ;
	
	printf("sizeof(int *):%d sizeof(double*):%d sizeof(char*):%d \n",sizeof(int *),sizeof(double*),sizeof(char*)) ;
	
	//a+1 和 &a+1 结果不一样  
	//虽然输出结果上面，a和&a一样 。 但是a 和 &a所代表的数据类型不一样
	
	/*重要*/ 
	//a 代表的数据首元素的地址 (首元素)，同时与整个数组地址重合，但其不能代表整个数组，只能代表起始个体的地址 
	//&a代表的是整个数组的地址   （特别特别的注意） 它的加1是以整块数组所占字节数总数为单位1
	
	
//	num =sizeof(a);//这个是获取的整个数组的字节数，为32个字节
	printf("实参a的数据类型为整个数组，所占字节为：%d \n",sizeof(a)) ;
//    num = sizeof(a)/sizeof(int);  
    num = sizeof(a)/sizeof(a[0]); //注意规范
	printf("排序之前：");
	printArray(a,num);
	sortArray(a,num); 
	printf("排序之后：");
	printArray(a,num);
	return 0;
}

 
 
 
 
VC 32位编译器 运行截图：
 

 
 
64位编译器运行截图：
 

 
 
 
核心：
 
 
可以看出在64位机器中，int*的指针为8个字节，在32位中int*为 4个字节，由于：
 
sizeof(p)/sizeof(p[0]) //等价于sizeof（int * ） /sizeof( int )
 
 
所以在64位机器上面原本应该为1的现在变成了2，导致程序出现错误。
 

 
 
      从程序输出结果我们可以看出：实参a的数据类型为整个数组，所占字节为32。虽然实参a表示的是数组名，但是它实际的数据类型不是int *,而是表示的整个数组所占字节数。这里不要与前文的a与&a表示地址时候弄混淆。