说明：
 
数组的两个特殊性质对我们定义和使用作用在数组上的函数有影响，这两个性质分别是： 
 
不允许拷贝数组；
使用数组时通常会将其转换成指针。
 
因为不能拷贝数组，所以我们无法以值传递的方式使用数组参数。 
 因为数组会被转换成指针，所以当我们为函数传递一个数组时，实际上传递的是指向数组首元素的指针。
 
尽管不能以值传递的形式传递数组，但是我们可以把形参写成类似数组的形式：
 
//尽管形式不同，但这三个print函数是等价的
//每个函数都有一个const int*类型的形参
void print(const int*);
void print(const int[]);
void print(const int[10])//这里的维度表示我们期望数组含有多少元素，实际不一定
 
当编译器处理对print函数的调用时，只检查传入的参数是否是const int*类型：
 
int i = 2;
int j[2] = {1,2};
print(&i);  //正确，&i的类型是int*
print(j);   //正确，j被转换成int*并指向j[0]
 
如果我们传给print函数的是一个数组，则实参自动地转换成指向首元素的指针，数组的大小对函数的调用没有影响。
 
案例说明：
 
下面以一个例子来说明数组作为形参被传递时，传递的是指向数组首元素的指针
 
#include<iostream>
using namespace std;

int arraylength(int a[])
{
    int len = sizeof(a) / sizeof(a[0]);
    cout << "len_of_arraylength: " << len << endl;
    return 0;
}
int main()
{
    int a[13] = { 5, 16, 39, 45, 51, 98, 100, 202, 226, 321, 368, 444, 501 };
    int len = sizeof(a) / sizeof(a[0]);
    cout << "len_of_main: " << len << endl;
    arraylength(a);
    return 0;
}
 
 
由于数组实际上是以指针的形式传递给函数的，因此一开始函数并不知道数组的确切尺寸，调用者应该为此提供额外的一些信息。管理指针形参有三种常用的技术：
 
显示传递一个表示数组大小的形参
 
专门定义一个表示数组大小的形参
 
#include<iostream>
using namespace std;
//const int a[]等价于const int *a
//len表示数组的大小，将它显示地传给函数用于控制对a元素的访问
void print(const int a[],int len)               //显示传递一个表示数组大小的形参
{
    for (int i = 0; i < len;i++)
        cout <<"a["<<i<<"]="<< a[i]<< endl;
}
int main()
{
    int a[6] = { 5, 16, 39, 45, 51, 98};
    int len = sizeof(a) / sizeof(a[0]);
    print(a,len);
    return 0;
}
 
使用标记指定数组长度
 
使用标准库函数begin和end
 
C++11标准引入两个名为begin和end的函数，begin函数返回指向数组首元素的指针，end函数返回指向数组尾元素下一位置的指针，这两个函数定义在iterator头文件中。 
 
示例代码如下：
 
#include<iostream>
using namespace std;
void print(const int *abeg, const int *aend)
{
    while (abeg < aend)
    {
        cout << *abeg<< " ";
        abeg++;
    }
    cout << endl;
}

int main()
{
    int a[6] = { 5, 16, 39, 45, 51, 98 };
    int *abeg = begin(a);
    int *aend = end(a);
    print(abeg,aend);
    return 0;
}
 
 
参考博文：https://www.cnblogs.com/larryking/p/5734417.html

 
 
本文介绍了三种在函数中以数组作为形参时的处理方法，重点介绍C++11标准是如何管理数组大小的。 
 
 
数组的两个特殊性质对我们定义和使用作用在数组上的函数有影响，这两个性质分别是： 
 不允许拷贝数组以及使用数组时通常会将其转换成指针。因为不能拷贝数组，所以我们无法以值传递的方式使用数组参数。因为数组会被转换成指针，所以当我们为函数传递一个数组时，实际上传递的是指向数组首元素的指针。
 
尽管不能以值传递的形式传递数组，但是我们可以把形参写成类似数组的形式：
 
//尽管形式不同，但这三个print函数是等价的
//每个函数都有一个const int*类型的形参
void print(const int*);
void print(const int[]);
void print(const int[10])//这里的维度表示我们期望数组含有多少元素，实际不一定
 
当编译器处理对print函数的调用时，只检查传入的参数是否是const int*类型：
 
int i = 2;
int j[2] = {1,2};
print(&i);  //正确，&i的类型是int*
print(j);   //正确，j被转换成int*并指向j[0]
 
如果我们传给print函数的是一个数组，则实参自动地转换成指向首元素的指针，数组的大小对函数的调用没有影响。
 
由于数组实际上是以指针的形式传递给函数的，因此一开始函数并不知道数组的确切尺寸，调用者应该为此提供额外的一些信息。管理指针形参有三种常用的技术：
 
使用标记指定数组长度
 
这种方法要求数组本身包含一个结束标记，使用这种方法的典型示例是C风格字符串。C风格字符串存储在字符数组中，并且在最后一个字符后面跟着一个空字符。函数在处理C风格字符串时遇到空字符就停止：
 
void print(const char *cp)
{
    if(cp){     //若cp不是空指针
        while(*cp){     //只要指针所指字符不是空字符
            cout<<*cp++;    //输出当前字符并将指针前移
        }
    }
}
 
这个方法适用于那些有明显结束标记且该标记不会与普通数据混淆的情况。
 
显示传递一个表示数组大小的形参
 
这种方法是专门定义一个表示数组大小的形参，在C程序和过去的C++程序中常常使用这种方法。
 
//const int ia[]等价于const int *ia
//size表示数组的大小，将它显示地传给函数用于控制对ia元素的访问
void print(const int ia[],size_t size)
{
    for(size_t i = 0; i != size; ++i){
        cout<<ia[i]<<" ";
    }
}
 
这种方法通过形参size的值确定要输出多少个元素，调用print函数时必须传入这个表示数组大小的值：
 
int j[] = {1,2,3};

print(j,3);
 
使用标准库函数begin和end
 
C++11标准引入两个名为begin和end的函数，begin函数返回指向数组首元素的指针，end函数返回指向数组尾元素下一位置的指针，这两个函数定义在iterator头文件中。 
 示例代码如下：
 
#include<iostream>
using namespace std;
int main()
{
    int arr[] = {1,2,3,4,5,6,7,8,9,-1,5,3,4};

    int *pbeg = begin(arr);     //指向arr首元素的指针
    int *pend = end(arr);       //指向arr尾元素的指针

    //寻找第一个负值元素，如果已经检查完全部元素则结束循环
    while(pbeg != pend && *pbeg >= 0){
        ++pbeg;
    }
    cout<<*pbeg<<endl;  //输出第一个负数的值
}
 
对于本文的print函数，可以写成如下形式:
 
void print(const int *beg, const int *end)
{
    //输出beg到end之间（不含end）的所有元素
    while(beg != end)
        cout<<*beg++<<" ";
}
 
为了调用这两个函数，我们需要传入两个指针：一个指向要输出的首元素，另一个指向尾元素的下一个位置。使用方法如下：
 
int a[] = {1,2,3};

print(begin(j),end(j));

在上一篇文章中提到了Python中函数的定义和使用，在这篇文章里我们来讨论下关于函数的一些更深的话题。在学习C语言函数的时候，遇到的问题主要有形参实参的区别、参数的传递和改变、变量的作用域。同样在Python中，关于对函数的理解和使用也存在这些问题。下面来逐一讲解。
 
一.函数形参和实参的区别
 
　　相信有过编程语言经验的朋友对形参和实参这两个东西并不陌生。形参全称是形式参数，在用def关键字定义函数时函数名后面括号里的变量称作为形式参数。实参全称为实际参数，在调用函数时提供的值或者变量称作为实际参数。举个例子：
 
 
 
#这里的a和b就是形参
def add(a,b):
    return a+b

#这里的1和2是实参
add(1,2)
x=2
y=3
#这里的x和y是实参
add(x,y)
 
 
 
二.参数的传递和改变
 
　　在大多数高级语言当中，对参数的传递方式这个问题的理解一直是个难点和重点，因为它理解起来并不是那么直观明了，但是不理解的话在编写程序的时候又极其容易出错。下面我们来探讨一下Python中的函数参数的传递问题。
 
　　首先在讨论这个问题之前，我们需要明确一点就是在Python中一切皆对象，变量中存放的是对象的引用。这个确实有点难以理解，“一切皆对象”？对，在Python中确实是这样，包括我们之前经常用到的字符串常量，整型常量都是对象。不信的话可以验证一下：
 
print id(5)
print id('python')
x=2
print id(x)
y='hello'
print id(y)
 
 
 
　　这段代码的运行结果是：
 
　　
 
　　先解释一下函数id( )的作用。下面这段话是官方文档对id()函数的解释：
 
　　
 
　　显而易见，id(object)函数是返回对象object在其生命周期内位于内存中的地址，id函数的参数类型是一个对象，因此对于这个语句
 
id(2)没有报错，就可以知道2在这里是一个对象。下面再看几个例子：
 
x=2
print id(2)
print id(x)
y='hello'
print id('hello')
print id(y)
 
　　其运行结果为：
 
　　
 
　　从结果可以看出，id(x)和id(2)的值是一样的，id(y)和id('hello')的值也是一样的。
 
　　在Python中一切皆对象，像2，'hello'这样的值都是对象，只不过5是一个整型对象，而'hello'是一个字符串对象。上面的x=2，在Python中实际的处理过程是这样的：先申请一段内存分配给一个整型对象来存储整型值2，然后让变量x去指向这个对象，实际上就是指向这段内存（这里有点和C语言中的指针类似）。而id(2)和id(x)的结果一样，说明id函数在作用于变量时，其返回的是变量指向的对象的地址。因为变量也是对象，所以在这里可以将x看成是对象2的一个引用。
 
　　下面再看几个例子：
 
 
 
x=2
print id(x)
y=2
print id(y)
s='hello'
print id(s)
t=s
print id(t)
 
 
 
　　其运行结果为：
 
　　
 
　　从运行结果可以看到id(x)和id(y)的结果是相同的，id(s)和id(t)的结果也是相同的。这说明x和y指向的是同一对象，而t和s也是指向的同一对象。x=2这句让变量x指向了int类型的对象2，而y=2这句执行时，并不重新为2分配空间，而是让y直接指向了已经存在的int类型的对象2.这个很好理解，因为本身只是想给y赋一个值2，而在内存中已经存在了这样一个int类型对象2，所以就直接让y指向了已经存在的对象。这样一来不仅能达到目的，还能节约内存空间。t=s这句变量互相赋值，也相当于是让t指向了已经存在的字符串类型的对象'hello'（这个原理和C语言中指针的互相赋值有点类似）。
 
　　看这幅图就理解了：
 
　　
 
　　下面再看几个例子：
 
 
 
x=2
print id(2)
print id(x)
x=3
print id(3)
print id(x)
L=[1,2,3]
M=L
print id(L)
print id(M)
print id(L[2])
L[0]=2
print id(L)
print M
 
 
 
　　运行结果为：
 
　　
 
　　下面来分析一下这个结果，两次的id(x)的值不同，这个可能让人有点难以理解。注意，在Python中，单一元素的对象是不允许更改的，比如整型数据、字符串、浮点数等。x=3这句的执行过程并不是先获取x原来指向的对象的地址，再把内存中的值更改为3，而是新申请一段内存来存储对象3，再让x去指向对象3，所以两次id(x)的值不同。然而为何改变了L中的某个子元素的值后，id(L)的值没有发生改变？在Python中，复杂元素的对象是允许更改的，比如列表、字典、元组等。Python中变量存储的是对象的引用，对于列表，其id()值返回的是列表第一个子元素L[0]的存储地址。就像上面的例子，L=[1,2,3]，这里的L有三个子元素L[0]，L[1]，L[2]，L[0]、L[1]、L[2]分别指向对象1、2、3，id(L)值和对象3的存储地址相同，看下面这个图就明白了：
 
　　
 
　　因为L和M指向的是同一对象，所以在更改了L中子元素的值后，M也相应改变了，但是id(L)值并没有改变，因为这句L[0]=2只是让L[0]重新指向了对象2，而L[0]本身的存储地址并没有发生改变，所以id(L)的值没有改变（ id(L)的值实际等于L[0]本身的存储地址）。
 
 
 
　　下面就来讨论一下函数的参数传递和改变这个问题。
 
　　在Python中参数传递采用的是值传递，这个和C语言有点类似。先看几个例子：
 
 
 
def modify1(m,K):
    m=2
    K=[4,5,6]
    return 
    
def modify2(m,K):
    m=2
    K[0]=0
    return

n=100
L=[1,2,3]
modify1(n,L)
print n
print L
modify2(n,L)
print n
print L
    
 
 
 
　　程序运行结果为：
 
　　
 
　　从结果可以看出，执行modify1( )之后，n和L都没有发生任何改变；执行modify2( )后，n还是没有改变，L发生了改变。因为在Python中参数传递采用的是值传递方式，在执行函数modify1时，先获取n和L的id( )值，然后为形参m和K分配空间，让m和K分别指向对象100和对象[1,2,3]。m=2这句让m重新指向对象2，而K=[4,5,6]这句让K重新指向对象[4,5,6]。这种改变并不会影响到实参n和L，所以在执行modify1之后，n和L没有发生任何改变；在执行函数modify2时，同理，让m和K分别指向对象2和对象[1,2,3]，然而K[0]=0让K[0]重新指向了对象0（注意这里K和L指向的是同一段内存），所以对K指向的内存数据进行的任何改变也会影响到L，因此在执行modify2后，L发生了改变。
 
三.变量的作用域
 
　　在Python中，也存在作用域这个问题。在Python中，会为每个层次生成一个符号表，里层能调用外层中的变量，而外层不能调用里层中的变量，并且当外层和里层有同名变量时，外层变量会被里层变量屏蔽掉。举个例子：
 
 
 
def function():
    x=2
    count=2
    while count>0:
        x=3
        print x
        count=count-1

function()        
    
 
 
 
　　在函数function中，while循环外面和while循环里面都有变量x，此时，while循环外面的变量x会被屏蔽掉。注意在函数内部定义的变量作用域都仅限于函数内部，在函数外部是不能够调用的，一般称这种变量为局部变量。
 
　　还有一种变量叫做全局变量，它是在函数外部定义的，作用域是整个文件。全局变量可以直接在函数里面应用，但是如果要在函数内部改变全局变量，必须使用global关键字进行声明。
 
 
 
x=2

def fun1():
    print x
    
def fun2():
    global x
    x=3
    print x

fun1()
fun2()
print x
 
 
 
　　关于函数的形参和实参、参数的传递以及变量的作用域问题这里就讨论这么多了，关于函数参数的类型问题会在《Python中的函数（三）》中继续讲解。

前面的话 
 　　javascript函数的参数与大多数其他语言的函数的参数有所不同。函数不介意传递进来多少个参数，也不在乎传进来的参数是什么数据类型，甚至可以不传参数。 
 arguments 
 　　javascript中的函数定义并未指定函数形参的类型，函数调用也未对传入的实参值做任何类型检查。实际上，javascript函数调用甚至不检查传入形参的个数
 
function add(x){
return x+1;
}
console.log(add(1));//2
console.log(add('1'));//'11'
console.log(add());//NaN
console.log(add(1,2));//2
 
同名形参 
 　　在非严格模式下，函数中可以出现同名形参，且只能访问最后出现的该名称的形参。
 
function add(x,x,x){
return x;
}
console.log(add(1,2,3));//3
 
　　而在严格模式下，出现同名形参会抛出语法错误
 
function add(x,x,x){
'use strict';
return x;
}
console.log(add(1,2,3));//SyntaxError: Duplicate parameter name not allowed in this context
 
参数个数 
 　　当实参比函数声明指定的形参个数要少，剩下的形参都将设置为undefined值
 
function add(x,y){
console.log(x,y);//1 undefined
}
add(1);
 
　　常常使用逻辑或运算符给省略的参数设置一个合理的默认值
 
function add(x,y){
y = y || 2;
console.log(x,y);//1 2
}
add(1);
 
　　[注意]实际上，使用y || 2是不严谨的，显式地设置假值(undefined、null、false、0、-0、”、NaN)也会得到相同的结果。所以应该根据实际场景进行合理设置。更多设置默认参数的方法：ES5和ES6中对函数设置默认参数的方法总结 
 　　 
 　　当实参比形参个数要多时，剩下的实参没有办法直接获得，需要使用即将提到的arguments对象 
 　　javascript中的参数在内部是用一个数组来表示的。函数接收到的始终都是这个数组，而不关心数组中包含哪些参数。在函数体内可以通过arguments对象来访问这个参数数组，从而获取传递给函数的每一个参数。arguments对象并不是Array的实例，它是一个类数组对象，可以使用方括号语法访问它的每一个元素
 
function add(x){
console.log(arguments[0],arguments[1],arguments[2])//1 2 3
return x+1;
}
console.log(add(1,2,3));//2
 
　　arguments对象的length属性显示实参的个数，函数的length属性显示形参的个数
 
function add(x,y){
console.log(arguments.length)//3
return x+1;
}
add(1,2,3);
console.log(add.length);//2
 
　　形参只是提供便利，但不是必需的
 
function add(){
return arguments[0] + arguments[1];
}
console.log(add(1,2));//3
 
对象参数 
 　　当一个函数包含超过3个形参时，要记住调用函数中实参的正确顺序实在让人头疼
 
function arraycopy(/*array*/from,/*index*/form_start,
/*array*/to,/*index*/to_start,/*integer*/length){
//todo
}
 
通过名/值对的形式来传入参数，这样参数的顺序就无关紧要了。定义函数的时候，传入的实参都写入一个单独的对象之中，在调用的时候传入一个对象，对象中的名/值对是真正需要的实参数据
 
function easycopy(args){
arraycopy(args.from,args.form_start || 0,args.to,args.to_start || 0, args.length);
}
var a = [1,2,3,4],b =[];
easycopy({form:a,to:b,length:4});
 
同步 
 　　当形参与实参的个数相同时，arguments对象的值和对应形参的值保持同步
 
function test(num1,num2){
console.log(num1,arguments[0]);//1 1
arguments[0] = 2;
console.log(num1,arguments[0]);//2 2
num1 = 10;
console.log(num1,arguments[0]);//10 10
}
test(1);
 
　　[注意]虽然命名参数和对应arguments对象的值相同，但并不是说读取两个值会访问相同的内存空间。它们的内存空间是独立的，但值是同步的 
 　　但在严格模式下，arguments对象的值和形参的值是独立的
 
function test(num1,num2){
'use strict';
console.log(num1,arguments[0]);//1 1
arguments[0] = 2;
console.log(num1,arguments[0]);//1 2
num1 = 10;
console.log(num1,arguments[0]);//10 2
}
test(1);
 
　　当形参并没有对应的实参时，arguments对象的值与形参的值并不对应
 
function test(num1,num2){
console.log(num1,arguments[0]);//undefined,undefined
num1 = 10;
arguments[0] = 5;
console.log(num1,arguments[0]);//10,5
}
test(); 
 
内部属性 
 【callee】 
 　　arguments对象有一个名为callee的属性，该属性是一个指针，指向拥有这个arguments对象的函数 
 　　下面是经典的阶乘函数
 
function factorial(num){
if(num <=1){
return 1;
}else{
return num* factorial(num-1);
}
} 
console.log(factorial(5));//120
 
　　但是，上面这个函数的执行与函数名紧紧耦合在了一起，可以使用arguments.callee可以消除函数解耦
 
function factorial(num){
if(num <=1){
return 1;
}else{
return num* arguments.callee(num-1);
}
} 
console.log(factorial(5));//120
 
　　但在严格模式下，访问这个属性会抛出TypeError错误
 
function factorial(num){
'use strict';
if(num <=1){
return 1;
}else{
return num* arguments.callee(num-1);
}
} 
//TypeError: 'caller', 'callee', and 'arguments' properties may not be accessed on strict mode functions or the arguments objects for calls to them
console.log(factorial(5));
 
　　这时，可以使用具名的函数表达式
 
var factorial = function fn(num){
if(num <=1){
return 1;
}else{
return num*fn(num-1);
}
}; 
console.log(factorial(5));//120
 
【caller】 
 　　实际上有两个caller属性 
 【1】函数的caller 
 　　函数的caller属性保存着调用当前函数的函数的引用，如果是在全局作用域中调用当前函数，它的值是null
 
function outer(){
inner();
}
function inner(){
console.log(inner.caller);//outer(){inner();}
}
outer(); 
function inner(){
console.log(inner.caller);//null
}
inner();
 
　　在严格模式下，访问这个属性会抛出TypeError错误
 
function inner(){
'use strict';
//TypeError: 'caller' and 'arguments' are restricted function properties and cannot be accessed in this context
console.log(inner.caller);
}
inner();
 
【2】arguments对象的caller 
 　　该属性始终是undefined，定义这个属性是为了分清arguments.caller和函数的caller属性
 
function inner(x){
console.log(arguments.caller);//undefined
}
inner(1);
 
　　同样地，在严格模式下，访问这个属性会抛出TypeError错误
 
function inner(x){
'use strict';
//TypeError: 'caller' and 'arguments' are restricted function properties and cannot be accessed in this context
console.log(arguments.caller);
}
inner(1);
 
函数重载 
 　　javascript函数不能像传统意义上那样实现重载。而在其他语言中，可以为一个函数编写两个定义，只要这两个定义的签名(接受的参数的类型和数量)不同即可 
 　　javascript函数没有签名，因为其参数是由包含0或多个值的数组来表示的。而没有函数签名，真正的重载是不可能做到的
 
//后面的声明覆盖了前面的声明
function addSomeNumber(num){
return num + 100;
}
function addSomeNumber(num){
return num + 200;
}
var result = addSomeNumber(100);//300
 
　　只能通过检查传入函数中参数的类型和数量并作出不同的反应，来模仿方法的重载
 
function doAdd(){
if(arguments.length == 1){
alert(arguments[0] + 10);
}else if(arguments.length == 2){
alert(arguments[0] + arguments[1]);
}
}
doAdd(10);//20
doAdd(30,20);//50
 
参数传递 
 　　javascript中所有函数的参数都是按值传递的。也就是说，把函数外部的值复制到函数内部的参数，就和把值从一个变量复制到另一个变量一样 
 【1】基本类型值 
 　　在向参数传递基本类型的值时，被传递的值会被复制给一个局部变量(命名参数或arguments对象的一个元素)
 
function addTen(num){
num += 10;
return num;
}
var count = 20;
var result = addTen(count);
console.log(count);//20，没有变化
console.log(result);//30
 
【2】引用类型值 
 　　在向参数传递引用类型的值时，会把这个值在内存中的地址复制给一个局部变量，因此这个局部变量的变化会反映在函数的外部
 
function setName(obj){
obj.name = 'test';
}
var person = new Object();
setName(person);
console.log(person.name);//'test'
 
　　当在函数内部重写引用类型的形参时，这个变量引用的就是一个局部对象了。而这个局部对象会在函数执行完毕后立即被销毁
 
function setName(obj){
obj.name = 'test';
console.log(person.name);//'test'
obj = new Object();
obj.name = 'white';
console.log(person.name);//'test'
}
var person = new Object();
console.log(person.name);//undefined
setName(person); 
console.log(person.name);//'test'