函数形参

函数形参的定义方式：

位置形参
星号元组形参
命名关键字形参
双星字典形参

• 位置形参：
  
  • 语法：

def 函数名（形参名1，形参名2，...）：
    语句块

自己理解：按照位置顺序依次一对一接收的形参
* 星号元组形参
* 语法：

def 函数名（*元组形参名）：
    语句块

* 作用：收集多余的位置传参
* 说明：元组形参名一般命名为 'args'
* 自己理解：位置形参传递完后，将多余的位置形参打包形成元组传递给星号元组形参，元组形参名这个变量绑定的就是打包后的元组

示意：

def mysum(a, b, *args):
    pass
mysum(1, 2, 3, 4, 5, 6)
# 按位置把实参 1,2 传递给a和b ，剩下的3,4,5,6打包成一个元组（3,4,5,6）传递给*args 也就是 元组变量args 绑定了元组(3,4,5,6),就可以直接在函数调用中使用了。
mysum(1,2)
# 位置实参正好够用，没有多余位置实参，则args=空元组，采用len(args)判断
mysun(*[1,2])
# 在函数调用时采用星号，相当于将可迭代对象拆解成一个个元组，中间用逗号隔开而已，此处即是将列表拆开成1,2 然后按位置传递给a,b 即可

• 命名关键字形参：
  
  • 语法：

def 函数名（*, 命名关键字形参）：
    语句块

或

def 函数名（*args, 命名关键字形参）：
    语句块

* 作用：强制所有的参数都必须使用关键字传参或 字典关键字传参
* 注： * 分隔符, * 后边的形参必须使用关键字传参
*  *args 后边的形参必须使用关键字传参

* 双星字典形参：
* 语法：

def 函数名（**字典形参名）:
    语句块

* 作用：收集多余的关键字传参
* 说明：字典形参名一般命名为 kwargs
* 自己理解：函数调用处：** 将字典拆解成关键字实参，可以进行参数传递
* 自己理解: 函数定义处：** 将接收的多余的的关键字打包形成字典

示例：

def fun2(a, b, *args, c, d):
    pass
# *args 后边的形参c,d都必须是关键字形参
fun2(1, 2, 10, 11, 12, d=3, c=4)
fun2(1, 2, **{'c': 3, 'd': 4})  # **拆解字典进行关键字传参

** 函数参数说明：
位置形参，缺省参数，星号元组形参，双星号字典形参等可以混合使用

函数参数自左至右的顺序为：
    1. 位置形参
    2. 星号元组形参
    3. 命名关键字形参
    4. 双星号字典形参

示例：

def fn(a,b,*args, c, **kwargs):
    pass
fn(100, 200, 3, 4, 5, d='D', e='E',c='C')
# 100--> a   200-->b    (3,4,5)-->agrs
# 'C'-->c    {'d':'D', 'e':'E'}-->kwargs

• 缺省参数： 给定参数默认值 内部给定默认实参 函数定义时一次性给定

楼主刚从java转到c++，被这个指针搞得头疼，今天晚上碰到这个问题，想了好久，翻书也翻了很久，终于弄明白这其中的奥秘。

首先我们得明白c++中的函数参数传递一个重要规则X（姑且命名X,方便下面叙述）是：

每次调用一个函数，都会重新建立一个形参(类似于临时变量)，传入的实参作为初始化值拷贝给形参，一旦实参的值拷贝给形参后，形参和实参其实是两个不同的对象了（c++Prime原话，啃书！！！），就互不干涉了。这句话真的太重要！！！

接下来，通过一个简单的例子，来演示一下指针作为函数形参的两个容易混淆的问题。

1）可以改变指针指向的内容：

void test(int* s) {//指针作为形参

	//s = new int(2);//p指向2这块内存空间
	*s = 20;//指针指向的内容修改
    
}
int main() {
	int a = 1000;
	int* p = &a;
	cout << "调用前p的地址" << p << endl;//调用前p的地址004FFEC0

	cout << "调用前p指向的值" << *p << endl;//调用前p指向的值1000
	test(p);
	cout << "调用后p的地址" << p << endl;//调用后p的地址004FFEC0
	cout << "调用后p指向的值" << *p << endl;//调用后p指向的值20
}

如上面代码所示，main函数中的指针p原本是指向a的内存，且存的数是1000，输出为：

“调用前p的地址004FFEC0”

“调用前p指向的值1000”

 根据X规则，test()函数在调用时，形参s生成临时变量int* s，实参p用于s的初始化，所以s等于p，也可以理解s和p指向同一块内存，故通过*s对指针指向的内容进行修改：*s= 20，也就是等同于*p=20！所以调用后输出：

“调用前p的地址004FFEC0”

“调用前p指向的值20”

即地址没变，但是值修改了。

由这个例子其实可以看出来，地址没改变，改变了指针指向的内容

2) 不可以改变指针的地址：

void test(int* s) {//指针作为形参
	s = new int(2);//p指向2这块内存空间
    cout << "调用后s的地址" << s << endl;//调用后s的地址01034FC8
	//*s = 20;//指针指向的内容修改
}
int main() {
	int a = 1000;
	int* p = &a;
	cout << "调用前p的地址" << p << endl;//调用前p的地址010FF7BC

	cout << "调用前p指向的值" << *p << endl;//调用前p指向的值1000
	test(p);
	cout << "调用后p的地址" << p << endl;//调用后p的地址010FF7BC

	cout << "调用后p指向的值" << *p << endl;//调用后p指向的值1000
}

这个例子中我让test函数对指针的指向进行改变。main中的p仍然指向a，在调用后，根据输出语句的地址发现：指向的还是a，地址未发生改变。但是s的地址和p的地址不一样了，因为“一旦实参的值拷贝给形参后，形参和实参其实是两个不同的对象了，就互不干涉了。”注意！这个s和p不是一个东西了。

3）针对1）和2）的思考

为什么指针作为形参可以改变指针指向的内容，却不可以改变指针的指向？我觉得一定得从函数的参数传递本质着手，函数参数传递的规则是实参是形参的初始化，一旦实参的值拷贝给形参后，形参和实参其实是两个不同的对象了。这个一定好好理解一下！基于这个规则：

当一个函数将指针作为形参时，我们给这个形参传入一个实参（指针(非引用类型)），这个实参的值究竟是什么？其实是指针的地址值，这个地址值传给形参后，后续形参怎么折腾，跟这个实参无关的。如：1)中只是*s = 20,这个s其实就是p，因为s没有对指针指向进行修改（可以理解成s和p指向同一个内存，那么s修改了指针指向的内存保存的值，p指向的值当然也得变）。2)中 s = new int(2);就是把s指向了另一个内存，虽然test函数中s的地址变了；但是跟p没有半毛钱关系，所以main中输出的两个p的地址还是一样的。归根结底还是因为“一旦实参的值拷贝给形参后，形参和实参其实是两个不同的对象了，就互不干涉了”。 这句话理解了， 就啥都明白了。

形象一点的说就是：

我把我家的钥匙(实参)拷贝了一份给你(形参)，你可以用拷贝的钥匙开我家的门，拿我家的东西，完全没问题，但是你非要去开锁店把我家的钥匙改造成另一个样子，即使可能你可以用这个改造的钥匙去开别人家的门(改变指向)，但是你根本不会影响我自己手上这把钥匙继续开我家的门（不改变实参的指向）。

第一次写帖子，只是想分享今天学到的心得。可能总结的不好，不喜勿喷。如果有错的地方，希望大佬们给与指正！感谢！

学习了函数指针变量之后，我们可以把一个函数名设置给函数指针变量，再由函数指针变量来调用该函数名。那么，在定义函数的时候，函数的形参变量可以接收实参变量传递过来的数据。所以，函数指针变量是一种变量类型，也可以作为函数的形参变量。程序测试例子如下：

程序运行结果如下：

可以看到，函数func1的定义如下：

void func1(void (*pfunc)(int))

其中形参的定义是

void (*pfunc)(int)

此时，这个形参变量就是一个函数指针变量。那么，在调用func1函数的时候，必须给形参变量赋值一个函数地址。而且根据形参变量的定义，该函数指针的返回值类型是void，形参列表是接收一个int类型的变量。这个格式与func函数的定义格式一致，所以，可以把func函数设置给func1函数的形参变量。那么，调用func1函数的形式如下：

func1(func);

此时，把func函数名作为实参变量，传递给func1函数的形参pfunc函数指针变量，相当于：

pfunc = func;

所以，func1函数的形参函数指针变量pfunc就得到func函数名的值，指向func函数在内存块在首地址。那么，就可以通过pfunc函数指针变量调用它所指向的func函数。