C++语法学习_(2)

C7_function_parameter

函数的参数传递：形参和实参

#include <iostream>
using namespace std;
/* 
函数的形参a,b,c ...， func (int a, int b, int c...),
实参--赋值给行参  ，函数调用时，值传递 ，func (2, 3, 4...)
形参的默认值。 如果定义了默认值，这函数后面所有的参数（形参）都需要有默认值。
func (int a, int b=5, int c=55...),
错误的 func (int a, int b=5, int c...), c 也必须要有默认值

还有函数的形参赋予默认值 只可以出现一次，且在 函数的默认值 作用域 只在函数的调用处。
在给定的作用域中一个形参只能被赋予一次默认参数。换句话说，
函数的后续声明只能为之前那些没有默认值的形参添加默认值，
而且该形参右侧的所有形参必须都有默认值。

*/
void func(int a, float b, char c)
{
    cout<<a<<','<<b<<','<<c<<endl;

}
// void func1(int a, float b=3, char c) //错误
// {
//     cout<<a<<','<<b<<','<<c<<endl;

// }
void func1(int a, float b=3, char c='@') 
{
    cout<<a<<','<<b<<','<<c<<endl;

}
int d=3;
void func2(int a, int b=d+3)
{
    cout<<a<<','<<b<<endl;

}

int main(){

    func(1,2.1,'c');
    func1(2);//传递部分参数，使用默认参数值，
    func1(3,4.1,'$');    //赋值所有的参数
    func1(3,4.1);
    func2(4);
    return 0;
} 

C8_fucntion_overload 函数的重载

C++ 标准规定，在进行重载决议时编译器应该按照下面的优先级顺序来处理实参的类型：

优先级	包含的内容	举例说明
精确匹配	不做类型转换，直接匹配	（暂无说明）
	只是做微不足道的转换	从数组名到数组指针、从函数名到指向函数的指针、从非 const 类型到 const 类型。
类型提升后匹配	整型提升	从 bool、char、short 提升为 int，或者从 char16_t、char32_t、wchar_t 提升为 int、long、long long。
	小数提升	从 float 提升为 double。
使用自动类型转换后匹配	整型转换	从 char 到 long、short 到 long、int 到 short、long 到 char。
	小数转换	从 double 到 float。
	整数和小数转换	从 int 到 double、short 到 float、float 到 int、double 到 long。
	指针转换	从 int * 到 void *。

C++ 标准还规定，编译器应该按照从高到低的顺序来搜索重载函数，首先是精确匹配，然后是类型提升，最后才是类型转换；一旦在某个优先级中找到唯一的一个重载函数就匹配成功，不再继续往下搜索。

#include <iostream>
using namespace std;
/* 
overloading 重载。
1.同一个函数名，实现不同 (在C语音中，就需要定义多个函数名！C++不需要--重载实现)
2. 参数列表不同（参数个数，参数的数据类型，参数的顺序)，只有有一个不同，参数列表就不同
这样的话传递不同的参数，编译阶段会自动区分，选择合适的函数实现调用。
重点：编译如何区分/仲裁？
按照一定的优先级。 完全匹配的数据类型参数> 类型提升>类型转换
如果有>=2 个可用的函数。就是二义错误。需要避免
这个过程就是重载

函数的重载的规则：
函数名称必须相同。
参数列表必须不同（个数不同、类型不同、参数排列顺序不同等）。
函数的返回类型可以相同也可以不相同。
仅仅返回类型不同不足以成为函数的重载。
 */

//定义多个SWAP 函数，参数列表不同，观察调用情况
void SWAP(int a, int b){

    cout<<"int"<<endl;
}

void SWAP(char a, char b){

    cout<<"char"<<endl;
}

void SWAP(double a, double b){

    cout<<"double"<<endl;
}

//

int main(){
//精确匹配
    SWAP('A','B');
    SWAP(5,5);
    SWAP(5.5,5.5);
//仲裁
    SWAP(5,'c'); //提升char --int 大于 转换 int --char
    float b=5.0;  //提升float -->double 
    
    SWAP(b,b);
    short c=3.0;//提升short -->int
    SWAP(b,c);
    return 0;
}

如果在一个优先级中找到多个（两个以及以上）合适的重载函数，编译器就会陷入两难境地，不知道如何抉择，编译器会将这种模棱两可的函数调用视为一种错误，因为这些合适的重载函数同等“优秀”，没有一个脱颖而出，调用谁都一样。这就是函数重载过程中的二义性错误。