void Func(int a, int b = 20, int c = 30);  //right

void Func(int a = 20, int b = 30, int c);  //wrong

        若半缺省参数不能按照从右至左的顺序依次进行Func(int a = 20,int b = 30,int c)，那么对于传参时只能从左至右依次传递的情况Func(1,2)，函数的最后一个参数c是未被赋值的。

2、缺省参数不能在函数声明和定义中同时出现，否则会起冲突，且缺省值要在函数声明时提供（不做过多解释）

//a.h文件

void Func(int a = 10);

// a.cpp文件
void Func(int a = 20)
{

......

}

//wrong!!

3、缺省值必须是常量或全局变量（全局变量一般不用）

小应用

        在之前学习顺序表的时，当顺序表的空间不够用时我们就会申请整数倍的新空间，但是这样可能会造成空间的浪费，我们更希望的是一个萝卜一个坑，我们可以使用缺省参数实现这一效果，设置缺省的默认值为4，当有确定需要的空间大小时就按确定的空间大小来，如果没有就用默认值

#include <stdio.h>
#include <stdlib.h>

//顺序表的扩容
struct Stack
{
	int* a;
	int size;
	int capacity;
	//...
};

//顺序表的初始化
void StackInit(struct Stack* ps, int n = 4)//设置缺省参数n，并设置默认值为4
{
	ps->a = (int*)malloc(sizeof(int) * n); //扩容
}


int main()
{
	struct Stack st1;

	//1、确定要插入一百个数据
	StackInit(&st1, 100);

	//2、确定只插入十个数据
	StackInit(&st1, 10);

	//3、不知道要插入多少数据，那就直接用默认的缺省参数的4
	StackInit(&st1);
	return 0;
}

函数重载

基本概念：在同一个作用域内，可以定义多个具有相同名称但参数列表（参数的类型、参数的个数、参数类型的顺序）不同的函数

#include<iostream>
using namespace std;

// 1、参数类型不同
int Add(int left, int right)
    {
     cout << "int Add(int left, int right)" << endl;
     return left + right;
    }
double Add(double left, double right)
    {
     cout << "double Add(double left, double right)" << endl;
     return left + right;
    }

// 2、参数个数不同
void f()
    {
     cout << "f()" << endl;
    }

void f(int a)
    {
     cout << "f(int a)" << endl;
    }

// 3、参数类型顺序不同
void f(int a, char b)
    {
     cout << "f(int a,char b)" << endl;
    }

void f(char b, int a)
    {
     cout << "f(char b, int a)" << endl;
    }

int main()
{
     Add(10, 20);
     Add(10.1, 20.2);

     f();
     f(10);

     f(10, 'a');
     f('a', 10);

     return 0;
}

注意熟悉：C语言不允许同名函数

名字修饰

问题：为什么C++支持函数重载，而C语言不支持函数重载

        对于C语言而言，在代码执行的过程中会经过预处理、编译、汇编、链接四个阶段，下面我们

通过一个函数声明与定义分离的例子看一看代码在经过这四个阶段都会发生什么：

Stack.h文件

#pragma once
#include<stdlib.h>

struct Stack
{
	int* a;
	int size;
	int capacity;
	//...
};

void StackInit(struct Stack* ps, int n = 4);
void StackPush(struct Stack* ps, int x);

Stack.cpp文件（.cpp也行懒得改成.c了😘）

#include "Stack.h"

void StackInit(struct Stack* ps, int n)
{
	ps->a = (int*)malloc(sizeof(int) * n);
}

void StackPush(struct Stack* ps, int x)
{}

Test.cpp文件

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include"Stack.h"
using namespace std;

int main()
{
	struct Stack st1;

	// 1、确定要插入100个数据
	StackInit(&st1, 100);  // call StackInit(?)

	// 2、只插入10个数据
	struct Stack st2;
	StackInit(&st2, 10);   // call StackInit(?)

	// 3、不知道要插入多少个
	struct Stack st3;
	StackInit(&st3);

	return 0;
}

预处理阶段

        Stack.h文件会被展开并与Stcak.cpp的文件合并成新文件Stack.i，Test.cpp文件经预处理后

会变为Test.i文件

编译阶段

        检查完Stack.i和Test.i文件的语法无误后，会将它们生成由汇编指令组成的文件Stack.s和

Test.s，其中StackInit(&st1,100)对应的汇编指令是 ：

        我们注意到其中一条汇编指令是“call + 地址”，表示调用StackInit函数这段代码转变为汇编

指令后就是call这个函数的地址（从底层的角度来讲函数调用的本质就是call+函数的地址，从语法

的角度来讲函数名就是其对应的地址）而函数是一系列功能代码的集合，故从底层的角度来讲函数

就是这些功能代码转变成的汇编指令的集合，而函数的地址就是这些指令的第一句指令的地址（有

点像数组的地址，数组的地址就是它的第一个元素的地址），最后我们可以得到的结论是：调用函

数的本质就是call一个函数的地址，然后通过该地址找到函数的指令集中的第一句指令的地址，然

后将这些指令依次取出交给CPU去依次执行，依次执行完后该函数的功能就完成了（也跟数组相

似，各个元素之间地址的距离相似）。

        但是实际上在调试反汇编时，call的下一步会跳转到地址为0A001357的另一条汇编指令jmp处（相当于套了一个壳子，调用函数之前还要先把盒子jmp打开才行）关于这点作者能力有限就不过多解释，为了方便理解你也可以忽略这一步。