C++函数重载(overload)
函数重载：函数名相同，函数的参数个数，函数的参数类型，函数的参数顺序形成的这些函数，那么说这些函数构成 函数重载
判断是否构成函数重载 规则：
1. 函数名相同 --- 前提条件
2. 函数的参数类型不同 || 参数个数不同 || 参数类型的顺序不同,三选一即可，均可构成重载
3. 函数的返回值不是做为函数重载判断的依据
演示代码：
#include <iostream>
using namespace std;
/*
函数重载：函数名相同，函数的参数个数，函数的参数类型，函数的参数顺序形成的这些函数，那么说这些函数构成 函数重载
判断是否构成函数重载 规则：
1. 函数名相同 --- 前提条件
2. 函数的参数类型不同 || 参数个数不同 || 参数类型的顺序不同,三选一即可，均可构成重载
3. 函数的返回值不是做为函数重载判断的依据
*/
void func()
{
cout << void func()<<endl;
}
//函数名相同，参数个数不同 ---- 他们两个构成了函数重载
void func(int a)
{
cout << void func(int a)<<endl;
}
void test(string s,int age)
{
}
//函数名相同，参数顺序不同 ---- 他们两个可构成重载
void test(int age,string s)
{
}
void Func(string s,char* p)
{
}
//函数名相同,参数类型不同 ---- 他们两个可构成重载
void Func(string s,int p)
{
}
int main()
{
//函数重载调用
Func(zhang3,20);
test(10,li4);
return 0;
}C++是怎样来支持函数重载呢。而C语言不支持，原因在于C和c++，他们之间对源程序编译技术不一样，C++编译器编译源文件时通过底层倾轧(name mangling)技术，v--void ---int c -- char
底层倾轧(name mangling) ---- 将原有函数名 + 参数类型 ----> 在底层时，形成一个新的函数名，从底层，各个函数名还是不一样的。
比如：
void print(int data) ---> void print_i(int data)
void print(int data,int data2) ---> void print_ii(int data,int data2)
void print(char data) ---- void print_c(char data)
以上三个函数通过函数重载，实现了静态联编，从而让函数体现出了多种形态---也被称之为静态多态
---因为它的实现发生在程序编译期
默认参数和函数重载同时共存，他们在一起时，会出现一种现象：函数调用时的模糊性
//函数的参数个数不同实现默认参数与函数重载一起
QPushButton(const QIcon &icon, const QString &text, QWidget *parent = nullptr)
QPushButton(const QString &text, QWidget *parent = nullptr)
QPushButton(QWidget *parent = nullptr)1.使用函数重载实现初始化数组的函数，这个函数可以初始化int,double,char
函数名:init_array
#include <iostream>
using namespace std;
/*
1 使用函数重载实现初始化数组的函数，这个函数可以初始化int,double,char
函数名:init_array
要点：理解数组做为形参时变化，能力强的同学可以考虑使用数组指针引用
*/
void init_array(int* p,int len)
{
// cout << "void init_array(int* p,int len)"<<endl;
for(int i=0;i<len;i++)
{
p[i] = i+1;
}
}
void init_array(double* p,int len)
{
cout << "void init_array(int* p,int len)"<<endl;
for(int i=0;i<len;i++)
{
p[i] = double(i+1);
}
}
//void init_array(int*& p,int len)// int*
//{
// cout << "void init_array(int*& p,int len)"<<endl;
// for(int i=0;i<len;i++)
// {
// p[i] = i+1;
// }
//}
void print_array(int* p,int len)
{
for(int i=0;i<len;i++)
{
cout << p[i] << " ";
}
}
void init_array(int (*&p)[5],int len) //int (*&p)[5] --- 它就是一个数组指针的别名-int (*p)[5]--所以实参要求的一个数组的地址
{
cout << "void init_array(int (*&p)[5],int len)"<<endl;
for(int i=0;i<len;i++)
{
//p就是指向一个数组，要给数组的数据元素进行初始化，那么，就要找到数据元素的地地址 -- (*p)[i] 或者 *(*p+i)
//*p---指向数据的首元素，它就是首元素的地址 *p+i就是第i元素的地址
// (*p)[i] = i+1; ok
*(*p+i) = i+1;
}
}
int main()
{
int a[5];
double b[10];
//函数调用时，还会对参数进行严格匹配
init_array(a,sizeof (a)/sizeof(a[0]));
print_array(a,sizeof (a)/sizeof(a[0]));
init_array(b,sizeof (b)/sizeof (b[0]));
for(int i=0;i<10;i++)
{
cout << b[i] << " ";
}
int (*p)[5] = &a;
init_array(p,sizeof (a)/sizeof(a[0]));//如果是一个数组地址做为实参，那么，
//编译器不会自动进行隐式转换，所以要手动转换化，再做实参传递
print_array(a,sizeof (a)/sizeof(a[0]));
return 0;
}
2 编写函数，计算一个圆锥体(cone)的体积(volume)，并且在不指定高度时，默认高度按照1计算，底部半径没有默认值。
圆锥体积公式：V=1/3sh
s:底部圆面积
h:圆锥体高
利用函数重载设计两个计算圆锥体积函数
#include <iostream>
using namespace std;
/*
2 编写函数，计算一个圆锥体(cone)的体积(volume)，并且在不指定高度时，默认高度按照1计算，底部半径没有默认值。
圆锥体积公式：V=1/3sh
s:底部圆面积
h:圆锥体高
利用函数重载设计两个计算圆锥体积函数
*/
/**
* @brief calc_volume
* @param dir --- 底部圆的半径
* @param height --- 圆锥体高
* @return
*/
double calc_volume(int dir,int height=1)
{
return 1*1.0/3*dir*dir*3.14*height;
}
/**
* @brief calc_volume
* @param area --- 底部圆的面积
* @param height --- 圆锥体高
* @return
*/
double calc_volume(double area,int height=1)
{
return 1*1.0/3*area*height;
}
void calc_volume( double& volume,double area,int height=1)
{
volume = 1*1.0/3*area*height;
}
int main()
{
cout << calc_volume(5)<<endl;
cout << calc_volume(5,5)<<endl;
int dir = 10;
cout << calc_volume(dir*dir*3.14)<<endl;
double volume =0;
calc_volume(volume,dir*dir*3.14);
cout << volume<<endl;
return 0;
}