C++入门教程 03

学习链接

三、函数调用传参内联重载模板

1. C++中函数调用的用法

C++中函数调用的方法与C语言并无区别，依旧是在调用函数中执行函数调用语句来实现函数调用

写一函数，使输入的一个字符串按反序存放，在主函数中输入并输出反序后的字符串（不包含空格）

#include <iostream>
#include <cstring>
using namespace std;

int Reverse(char a[], char b[]) {
    int i = 0;
    int n = strlen(a);
    
    while (a[i] != '\0') {
        b[n - 1 - i] = a[i];
        i++;
    }
    b[n] = '\0';
    return 0;
}

int main() {
    char str1[100];
    char str2[100];
    cin >> str1;
    Reverse(str1, str2);
    cout << str2 << endl;
    
    return 0;
}

2. 带默认形参值的函数

在C++中，允许在自定义函数的形参列表中，给形参一个默认的值，这样在调用的时候如果有实参，那么按照实参传递给形参的方法使用；若调用的时候没有指定对应的实参，则形参将使用默认值。

#include<iostream>
using namespace std;
int add(int a=3,int b=5)
{
    return a+b;
}
int main()
{
    cout<<add(10,20)<<endl;//将10和20分别给a和b
    cout<<add(30)<<endl;//将30给a，b为默认的5
    cout<<add()<<endl;//使用a、b的默认值3和5
    return 0;
}

需要注意的是，由于参数的传递顺序是从右至左入栈，所以有默认值的参数必须在放在形参列表的最右边！

另外，当函数需要提前声明时，若形参存在默认参数，则要在声明部分制定默认值，而后面的函数定义部分不能再制定默认值

3. C++函数重载

在实际的代码编写当中，有时候对于同一个功能函数，可能处理的对象类型不同，则需要重新实现一遍这个函数，这样下去就显得代码更加繁多，C++为了解决这一问题，而支持函数重载来解决这个问题。

比如一个算术求和的问题，需要自定义一个函数，用来接收传入数据的并求和，但作为独立的一个模块，如何知道调用方，传入什么类型的数据呢，可能是整型数据，当然也可能是浮点类型的数据，还可能是一个整数一个浮点型（还不知道哪一个是整型，哪一个是浮点型）
而周全的做法是各种类型的形参的函数都要定义一个，即：两个int类型的，两个double类型的，第一个int第二个double的，及第一个double第二个int的类型的，定义四个函数来实现：比如名字叫:Add_double_double()、Add_int_double()、Add_int_int()、Add_double_int()等等

这看起来能不混乱吗？

那么，C++中函数重载的出现，则很好的解决这个问题，函数重载即两个或以上的函数，函数名相同，但形参类型或个数不同，编译器根据调用方传入的参数的类型和个数，自动选择最适合的一个函数来进行绑定调用，自动实现选择。

#include<iostream>
using namespace std;
int add(int a,int b)
{
    cout<<"(int ,int)\t";
    return a+b;
}
double add(double a,double b)
{
    cout<<"(doble ,double)\t";
    return a+b;
}
double add(double a,int b)
{
    cout<<"(double ,int)\t";
    return a+b;
}
double add(int a,double b)
{
    cout<<"(int ,double)\t";
    return a+b;
}
int main()
{
    cout<<add(2,3)<<endl;
    cout<<add(2.9,15.3)<<endl;
    cout<<add(10,9.9)<<endl;
    cout<<add(11.5,5)<<endl;
    return 0;
}

4. 函数模板

刚刚学习了函数重载，可以处理多种数据类型，虽然是同一个名字，但仍然要分开定义，如果再能让代码精简一些，模板化，就再好不过了！

为此，C++提供函数模板这一机制，大大提高代码的可重用性。

函数模板，是可以创建一个通用的函数，可以支持多种形参。

用关键字template来定义，形式如下：

template<class 类型名1，class 类型名2…>
返回值 函数名（形参表列） 模板参数表
{
   函数体
}

注意：这个一般形式中，第一行的template<class 类型名1，class 类型名2…>是一句声明语句 ，template是定义模板函数的关键字，尖括号里可以有多个类型，前面都要用 class(或者typename来定义)。然后后面跟定义的函数模板，切记中间不可以加其他的语句，不然会报错！

#include<iostream>
using namespace std;
template<class T1,class T2>
T1 add(T1 x,T2 y)
{
    cout<<sizeof(T1)<<","<<sizeof(T2)<<"\t";
    return x+y;
}
int main()
{
    cout<<add(10,20)<<endl;;
    cout<<add(3.14,5.98)<<endl;
    cout<<add(10,3.2)<<endl;	// 发生隐式转换
    cout<<add('A',2)<<endl;
    return 0;
}

以上是一个加法函数的模板，大家可以看到我们定义了一个add的函数模板，里面的变量类型都用T1和T2代替。

在主函数中，实际调用时，我们调用了四次，分别四种不用的类型传入，模板函数中的T1和T2类型将根据实际传入的类型变成具体类型。这个化成就叫做模板的实例化。

5. inline内联函数

函数的调用，想必大家都用过，一个函数在被另一个函数调用的时候，才有生命，才会为其准备对应的内存空间，再调用完毕之后再清理释放结束。

可以看到，每一次的函数调用都会带来一些时间和空间上的花销。

而自定义函数的一个作用，也是为了提高代码的重用性，可以在需要的时候随时调用，提高开发效率。那么，一个代码本身就不多，又频繁被调用的函数，我们就该好好想想，这样做到底合算不合算了。

C++为我们提供了内联的机制，即仍然使用自定义函数，但在编译的时候，把函数代码插入到函数调用处，从而免去函数调用的一系列过程，像普通顺序执行的代码一样，来解决这个问题！

用法：只需要在函数定义的前面加上关键字inline声明就可以了

#include<iostream>
using namespace std;
  
inline int Max(int a,int b)
{
    return a>b?a:b;
}
int main()
{
    cout<<Max(3,5)<<endl;
    cout<<Max(7,9)<<endl;
    return 0;
}

注意：内联函数的定义要在调用之前出现，才可以让编译器在编译期间了解上下文，进行代码替换。

除此以外，内联函数与register变量类似，仅仅是我们提给编译器的一个请求，最终是否真正会实现内联，由编译器根据情况自行选择。