补充函数

补充函数.txt遇事潇洒一点，看世糊涂一点。

相亲是经销，恋爱叫直销，抛绣球招亲则为围标。

没有准备请不要开始，没有能力请不要承诺。

爱情这东西，没得到可能是缺憾，不表白就会有遗憾，可是如果自不量力，就只能抱憾了。

一、内联函数
定义函数时加inline关键字，表示所定义的是内联函数。

内联函数是把函数代码直接插入到函数调用处，相当于顺序结构执行，省去了调用、传参数、返回等过程，能够提高程序效率。

内联函数一般是比较小和经常被调用的函数。

例：
inline int f1(int a)
{
return a*2;
}
main()
{
int x=3,y=4;
x=f1(x);
y=f1(x+y);
cout<<y;
}
相当于：
main()
{
int x=3,y=4;
x=x*2;
y=(x+y)*2;
cout<<y;
}
二、默认形参
函数定义中，可以给形式参数设定默认值，函数调用时可以不给实参，形参的值取默认值。

例：
int f1(int a=5)
{
return a*2;
}
main()
{
int x;
x=f1(4);
x=f1(); //没给参数，相当于f1(5)
cout<<x;
}
注意：
a. 既有声明又有定义时，默认参数只能在声明中设定。

b. 多个参数时，默认参数从右向左的顺序设定。

右边的参数没有默认值的话，左边的参数也不能有。

c. 默认参数值可以是变量和表达式。

例：
int f1(int x,int y=3,int z=4);
int f1(int x,int y,int z)
{
return x*y*z;
}
三、函数重载
C++中可以按照不同的参数情况，多次定义同一函数名，叫做函数重载。

重载的多个函数参数表各不相同，系统根据调用时的参数情况，选择正确的重载函数来执行。

例：
int sum(int a,int b);
int sum(int a,int b,int c);
float sum(float a,float b);
main()
{
int a;
float b;
a=sum(1,2,3);
b=sum(4.5,5.5);
cout<<a<<b;
}
int sum(int a,int b)
{ return a+b; }
int sum(int a,int b,int c)
{ return a+b+c; }
float sum(float a,float b)
{ return a+b; }
注：
a. 重载函数的参数表不同，和返回值类型无关。

参数要么类型不同，要么个数不同，不出现二义性即可重载。

b. 注意有默认参数时的二义性情况。

例：
int sum(int a,int b);
int sum(int a,int b=4,int c=5);
语句 a=sum(3,5) 出现二义性，不能重载
四、变量作用域和生存期
C++程序主要由，多个函数和函数外的说明语句构成。

在函数外部没有可执行的语句，只有编译预处理和一些声明，定义等。

按照可以访问的范围和存在的时间，变量主要分以下三种：
1. 全局变量
在函数外的公有说明部分定义的变量，从定义处向下的整个程序文件中都可以访问。

在程序一开始运行时就产生，整个程序运行结束时注销。

注意，全局变量的作用范围是从定义它的语句向下直到文件结束，所以全局变量的定义一般放在最上面。

2. 局部变量
在某个函数内部定义的变量，从定义处向下，在它所在的花括号“{}”内可以访问。

一般作用域就是它所在的那个函数内。

在它所在的函数被调用时产生，函数调用结束时注销。

函数形参也是局部变量。

3. 静态变量
加static关键字，在某个函数内部定义的变量，作用范围同局部变量。

在它所在的函数被调用时产生，在整个程序结束时才注销。

注意：
当在程序的某个位置，可以访问作用范围不同的两个同名变量时，系统默认访问作用范围小的变量。

如果一定要访问全局变量，加作用域符“::”。

例：
int x;
int f1()
{
static int s;
s++;
return s;
}
int f2()
{
int a;
a=2;
{
int a;
a=5;
}
x++;
return a;
}
main()
{
int x;
x=4;
::x=2;
cout<<f1();
cout<<f1();
cout<<f2();
cout<<f2();
::x++;
cout<<x<<::x;
}
五、引用
1. 引用是一个自定义标识符，定义引用的本质是，为一个已有的内存空间绑定标识符。

指针表示的是某个地址，通过“*”可以找到指针所指的空间；标识符本身代表的就是某个空间，实际上在编译之前，标识符存储的也是地址，但是不用加“*”就代表所指的空间；引用就是指向同一目标的另一个标识符，所以可以理解为引用和标识符就是自带“*”的指针。

用“&”符号定义引用，定义时必须马上用“=”与内存空间绑定。

定义引用不会新开辟内存空间。

例：
int x;
int *p=&x;
int y[5];
int &a=x;
int &b=*p;
int &c=a;
int &d=y[2];
以上方法都可以定义引用。

引用“a”“b”“c”与变量“x”代表同一个内存空间，相当于一个变量很多名字。

2. 定义引用时也可以加“const”修饰。

例：
int x;
const int &a=x;
const int &b=5;
x=b; //正确
a=7; //错误
“a”和“x”表示同一个内存空间，但是“a”只能做右值。

“b”和直接常量5的内存空间绑定，相当于“b”就是常量5。

3. 参数引用传递
void swap(int &x,int &y);
void main()
{
int a=5,b=8;
swap(a,b);
cout<<a<<' '<<b;
}
void swap(int &x,int &y)
{
int t;
t=x;
x=y;
y=t;
}
形参定义成引用，函数调用时形参就相当于实参的别名，此时实参必须是一个变量。

这种方法比传指针高效。

4. 函数返回引用
注意，不能返回一个局部变量的引用，因为函数运行结束后局部变量会注销。

例：
int &max(int &a,int &b)
{
if(a>b)return a;
return b;
}
void main()
{
int x=6,y=9;
max(x,y)*=1000;
cout<<x+y;
}
此时函数返回的是一个变量，可以对函数返回值赋值。