C++函数重载/默认值/函数模板

太过爱你忘了你带给我的痛 2022-12-14 03:37 292阅读 0赞

# C++函数修饰符 #

*  **const** 修饰成员函数，该函数不能修改类的任意数据成员，也不能调用类的其他成员函数，除了那些也被声明为const的函数。
 *  **constexpr**，C++11特有的，编译器将把从函数的返回值十位编译时的常量。此函数必须正好有一个return语句。
 *  **explicit**，只修饰成员函数（具体来说是构造函数），使构造函数不提供隐式转换的功能。
 *  **final**，C++特有的，只修饰成员函数，适用于虚函数，防止该函数被派生类重载（该关键字通常运用于派生类内的虚函数，此派生类可能有自己的派生类，final的要点是防止对函数有进一步的重载）。
 *  **inline**，内联函数，修饰任意函数，此关键字是一个建议，他告诉编译器应该把此函数实现为内联函数。最先进的现代编译器是优化的编译器，它们自己决定要内联的对象，所以一度被认为很重要的关键字，现在只是一个对编译器的建议。  
    特点：以空间换时间，提高函数调用的效率。C++ 内联函数是通常与类一起使用。如果一个函数是内联的，那么在编译时，编译器会把该函数的代码副本放置在每个调用该函数的地方。对于**短函数**进行内联是非常有效的，这消除了函数调用的开销。**递归函数不能被内联**。
 *  **override**，C++11特有的，只修饰成员函数，该关键字指定该函数重载基类中声明的一个函数。
 *  **static**，当其应用于全局函数时，可使函数只在当前源文件中可见。在默认情况下，C++中的函数名具有外部链接，使每个模块用相同的名称声明的一个函数必须指向相同的函数（它必须只在一个模块中被定义）。当用于成员函数时，该函数变成类的一个静态函数，使得它不能访问类的其它 成员，除非它们也被声明为静态。通过 类名：：函数 语法来调用。

# 函数重载（函数多态） #

C++允许使用相同的名称定义多个函数，只要它们根据参数列表区分。重载函数可以有不同的返回类型。但是**参数列表必须不同**。

int test(int a）;
    double test(double a);
    double test(int a);//错误，参数列表相同

# 带有默认值的参数 #

如果一个函数有多个默认参数，但只传递了其中一些，编译器会按照顺序匹配它们

void test（int a = 0; int b = 10, c = 20）;
    //如果一个函数有多个默认参数，但只传递了其中一些，编译器会按照顺序匹配它们
    test();//a = 0,b = 10, c = 20
    test(100);//a = 100,b = 10, c = 20
    test(100,200);//a = 100,b = 200, c = 20

# 可变长参数列表 #

在C++中可以编写采用任意数量的参数的函数（如C语言中的printf()函数）。

# lambda匿名函数 #

# 内联函数（inline） #

普通函数调用过程：程序将在函数调用后立即存储该指令的内存地址，并将函数参数复制到堆栈中，跳到函数起点的内存单位，执行函数代码（也许还需将返回值放入寄存器中），然后跳回地址被保存的指令处（这与阅读文章时停下来看脚注，并在看完脚注后再返回以前阅读的地方类似），来回跳跃并记录跳跃位置需要一定的开销。  
**内联函数的核心就是：以空间换时间。**  
编译器将使用相应的函数代码替换函数调用。也就是说在函数调用的地方直接把函数的代码复制过来使用，这样就无需跳来跳去。内联函数的运行速度比常规函数块，但代价是需要占用更多的内存。如果程序在十个地方调用一个函数，则该程序将包含十个该函数代码的副本。  
有选择地使用：

*  如果函数执行的时间比函数调用的时间长，则节省的时间只占一小部分。
 *  需要从**函数代码所占内存**，函数在程序中的**调用次数**（在不同地方），**函数运行时间**来考虑。
 *  **内联函数不能递归**。  
    必须在函数声明和定义前加上inline

# 函数模板 #

使用泛型来定义函数，例如要交换两个变量的值，他们所使用的算法是一样的，但是变量类型不一样，这时可以使用模板。一套代码，多类型复用。

#include <iostream>
    using std::cout;
    using std::cin;
    using std::endl;
    //函数模板原型
    template <typename T>//或者class T
    void Swap(T &a, T &b);
    
    //模板函数重载
    template <typename T>//或者class T
    void Swap(T &a, T &b,int n);
    
    int main(void) {
        
    
    	using namespace std;
    	int i = 10, j = 20;
    	cout << "i = "<< i << endl;
    	cout << "j = " << j << endl;
    
    	Swap(i, j,66);
    	cout << "after swaping:" << endl;
    	cout << "i = " << i << endl;
    	cout << "j = " << j << endl;
    
    	double x = 9.9, y = 2.2;
    	Swap(x, y);
    	cout << "after swaping:" << endl;
    	cout << "x = " << x << endl;
    	cout << "y = " << y << endl;
    	char a = 'a', b = 'b';
    	Swap(a, b);
    	cout << "after swaping:" << endl;
    	cout << "a = " << a << endl;
    	cout << "b = " << b << endl;
    
    	return 0;
    }
    
    //模板函数定义
    template <typename T>
    void Swap(T &a, T &b) {
        
    	T temp;
    	temp = a;
    	a = b;
    	b = temp;
    }
    template <typename T>
    void Swap(T &a, T &b, int n) {
        
    	T temp;
    	temp = a;
    	a = b;
    	b = temp;
    	cout << "函数重载"<<n << endl;
    }
    //结果：
    /*
    i = 10
    j = 20
    函数重载66
    after swaping:
    i = 20
    j = 10
    after swaping:
    x = 2.2
    y = 9.9
    after swaping:
    a = b
    b = a
    */

## 模板函数的重载 ##

和常规函数一样，只要参数列表必须不同