关于函数的相关问题

于 2023-05-06 14:33:13 发布
阅读量181 收藏
点赞数 3
文章标签： 数据结构 c++ 算法 学习方法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wppppppppp6/article/details/130524919
版权

内联函数

内联函数也称为内置函数、内嵌函数，原理就是：在编译时，编译系统将程序中的内联函数的调用表达式用对应的内联函数的“函数体”代码进行代替，这样可以免去由函数的主调到被调，再从被调到主调的来回转换，可以实现函数的高效调用，节省运行时间。

格式：1.inline 类型说明符 函数名（[形参表]）2.类型说明符 inline 函数名（[形参表】）

//求1到10中各个数的立方和
inline int cube_int(int n);
int main()
{
	for (int i = 1; i <= 10; i++)
	{
		int p = cube_int(i);
		cout << i << '*' << i << '*' << i << '=' << p << endl;
	}
	return 0;
}
int inline cube_int(int n) {
	return n * n * n;
}

结果：
1*1*1=1
2*2*2=8
3*3*3=27
4*4*4=64
5*5*5=125
6*6*6=216
7*7*7=343
8*8*8=512
9*9*9=729
10*10*10=1000

注：1.函数有原型声明，只需在函数声明处或函数定义处添加关键词inline即可

       2.内联函数体内不易出现循环语句和复杂的控制语句（如switch等）

       3.函数体不易过大，以1~5行为宜，否则将被转换为普通函数处理

       4.c++引入内联函数，只是对编译系统的建议，而不是指令性的，编译系统会根据具体情况决定是否采用。

函数带默认参数

函数调用时形参值从实参获得，因此实参和形参的数目必须得一致。但是，根据实际情况，有时可能要为某形参传递特定的值；有时需要用同一实参多次调用同一函数，为了简化函数的书写，就有了带默认参数的函数。                                                                                                                     函数带默认参数就是在定义时或声明函数时“给形参赋值”（形参初始化），调用时若没有显示指定参数，则用预先设定的“初始值”初始化形参，此时的形参就是默认参数

格式：类型说明符 函数名（…，类型说明符 形参名n-1=表达式n-1，类型说明符 形参名n=表达式n）

举例：
int fun1(int a = 1, int b = 2, int c = 3) { ... }
int fun2(int, int b = 2, int b = 3);
int fun3(int, int, int = 3);
int fun4(int a = 1, int b, int c = 3);	//错

注：1.当函数有多个形参时，可以给多个赋初始值，也可以给部分赋值。若给部分赋值时必须连续位于形参参数列表的最右侧，即有默认参数的形参右侧不能有无初始值的形参                                 2.有函数声明，函数的默认值一般放在函数原型声明语句中

举例：
fun1();		//形参值分别为：1、2、3
fun1(11);		//形参值分别为：11、2、3
fun1(11, 22);	//形参值分别为：11、22、3
fun1(11, 22, 33);	//形参值分别为：11、22、33
fun2();		//错
fun2(1);		//形参值分别为：1、2、3
fun2(1, 22);	//形参值分别为：1、22、3
fun2(1, 22, 33);	//形参值分别为：1、22、33
fun3(9, 99, 999);	//形参值分别为：9、99、999
fun3(9, 99);	//形参值分别为：9、99、3
/求圆的面积/
#include<iostream>
using namespace std;
const float PI = 3.14f;
void area(float r, float pi = PI) {
	cout << "面积=" << pi * r * r << endl;
}
int main() {
	area(3);
	area(3, 3.1415926f);
	return 0;
}
运行结果：
面积=28.26
面积=28.2743
#include<iostream>
using namespace std;
int fun(int n1, int n2, int base = 10);
int main() {
	int result;
	result = fun(1, 2);
	cout << result << endl;
	int fun(int, int, int = 100);
	result = fun(1, 2);
	cout << result << endl;
	return 0;
}
int fun(int n1, int n2, int base) {
	int sum;
	sum = base + n1 + n2;
	return sum;
}
结果：
13
103

函数的重载

函数的重载就是在同一作用域内同一个函数名重载着多个不同的功能，即多个函数使用同一个函数名。所谓重载，就是“一物多用”                                                                                                        重载函数在定义时必须保证形参的“数目”或对应形参的“类型”有所不同，否则重载失效。函数重载的本质就是允许功能相同、但参数数目或参数类型不同的函数采用同一个函数名，从而在编译。        

函数重载的定义
举例：
/*形参的“数目”不同*/
int max(int a, int b) { … }
int max(int a, int b, int c) { … }
/*对应形参的“类型”不同*/
int abs(int a) { … }
long abs(long a) { … }
double abs(double a) { … }
/*对应形参的“类型”不同*/
void fun(int a, float b) { … }
void fun(float a, int b) { … }
bool fun(char a, double b) { … }
char* fun(char* a, char* b) { … }
/*第4个函数重载失效*/
void Method(int a, float b) { … }
void Method(float a, int b) { … }
bool Method(char a, float b, double c) { … }
char Method(int a, float b) { … }// 错，函数类型不同不算重载
/*重载函数带默认参数，重载失败*/
void abc(int i, int j) { … }
void abc(int i, int j = 2, int k = 3) { … }
void abc(int i = 1, int j = 2, int k = 3) { … }
abc();
abc(11);		//无法确定被调函数：匹配第2个还是第3个？
abc(11, 22);	//无法确定被调函数：匹配第2个还是第3个？
abc(11, 22, 33);	//无法确定被调函数：匹配第2个还是第3个？

重载函数的调用是根据给定实参的“数目”或对应实参的“类型”来匹配的。重载函数的匹配按下列顺序查找，将函数调用中的实参与所有被调重载函数的形参一一对比。
S1）首先，严格匹配（精确匹配，含强制数据类型转换）查找，如果找到就调用;
S2）其次，通过自动数据类型转换（低类型向高类型转换）查找，如果找到就调用;
S3）最后，通过高类型向低类型及相容类型转换查找，如果找到就调用； 

函数重载的调用
举例：
void fun(int a) { … }
void fun(long a) { … }
void fun(double a) { … }
fun(99);		//匹配f(int)
fun(99L);		//匹配f(long)
fun(9.9);		//匹配f(double)
fun('*');		//匹配f(int)
fun((double)99);	//匹配f(double)
#include<iostream>
using namespace std;
int max(int a, int b) {
	if (a > b)
		return a;
	return b;
}
float max(float a, float b, float c) {
	float m = a;
	if (m < b)m = b;
	if (m < c)m = c;
	return m;
}
int main() {
	cout << "2个整数的最大值：" << max(3, 5) << endl;
	cout << "3个实数的最大值：" << max(12.6f, -6.12f, 1.26f) << endl;
	return 0;
}
结果：
2个整数的最大值：5
3个实数的最大值：12.6
#include<iostream>
using namespace std;
int min(int, int), min(int, int, int), min(int, int, int, int);
int main() {
	cout << "2个整数比较出最小值：" << min(67, 90) << endl;
	cout << "3个整数比较出最小值：" << min(65, 34, 51) << endl;
	cout << "4个整数比较出最小值：" << min(56, 93, 89, 37) << endl;
	return 0;
}
int min(int a, int b) {
	return a < b ? a : b;
}
int min(int a, int b, int c) {
	int m = min(a, b);
	return min(m, c);
}
int min(int a, int b, int c, int d) {
	int m = min(a, b, c);
	return min(m, d);
}
结果：
2个整数比较出最小值：67
3个整数比较出最小值：34
4个整数比较出最小值：37
#include<iostream>
using namespace std;
int add(int x, int y)//(1)
{
    cout << "(int,int)\t";
    return x + y;
}
double add(double x, double y)//(2)
{
    cout << "(double,double)\t";
    return x + y;
}
int main()
{
    cout << add(1, 2) << endl;//(1)
    cout << add((double)1, (double)2) << endl;//(2)
    cout << add(1.11, 2.22) << endl;//(2)
    cout << add((int)1.11, (int)2.22) << endl;//(1)
    cout << add(1.111f, 2.222) << endl;//(2)
    cout << add(1L, 2) << endl;//(1)
    return 0;
}
结果：
(int,int)       3
(double,double) 3
(double,double) 3.33
(int,int)       3
(double,double) 3.333
(int,int)       3

函数的模板

函数模板，实际上是建立一个“通用”功能的函数，其函数类型、形参类型，甚至函数体内其它实体的类型不具体指定，用一个“虚拟”的类型来代表。凡是函数体相同的函数都可以用这个模板来代替，从而不必定义多个函数。在函数调用时系统根据手动指定实参的类型或自动根据实参的类型取代模板中的虚拟类型，从而实现同一算法处理多种不同数据类型的功能，进一步简化重载函数的函数体，同时取代C语言中容易出错的带参宏。

格式：

1.template<typename T>
T add(T x, T y) {
    return x + y;
}
2.template<class R, int size>
R tow() {
    return 2 * size;
}

显示实例化：
add<int>(6, 8)        //将“T add(T x,T y)”实例化成“int add(int,int)”
add<double>(6.6, 8.8)    //将“T add(T x,T y)”实例化成“double add(double,double)”
add<double>(6, 8)        //将“T add(T x,T y)”实例化成“double add(double,double)”
add<int>(6.6, 8.8)        //将“T add(T x,T y)”实例化成“int add(int,int)”
tow<int, 10>()        //将“R tow()”实例化成“int tow()”，size获值10
tow<long, 1000>()        //将“R tow()”实例化成“long tow()”，size获值1000

隐式实例化：
add(512, 125)    //将“T add(T x,T y)”实例化成“int add(int,int)”
add(5.12f, 6.1f)    //将“T add(T x,T y)”实例化成“float add(float,float)”

#include<iostream>
using namespace std;
template<typename T>
T max(T a, T b, T c) {
	T m = a;
	if (b > m)m = b;
	if (c > m)m = c;
	return m;
}
int main() {
	int i1 = 199, i2 = -250, i3 = 198, i;
	long l1 = 9999, l2 = -9, l3 = 999, l;
	double d1 = 1.23, d2 = 12.3, d3 = -123, d;
	i = max(i1, i2, i3);
	l = max(l1, l2, l3);
	d = max(d1, d2, d3);
	cout << "   int_max=" << i << endl;
	cout << "  long_max=" << l << endl;
	cout << "double_max=" << d << endl;
	return 0;
}
结果：
   int_max=199
  long_max=9999
double_max=12.3

wppppppppp6
关注
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值