C++基础学习笔记----第三课（内联函数、默认参数、占位参数）

主要说明从C到C++函数的一些变化，内联函数主要说了内联函数的产生和编译器的编译等，默认参数和占位参数是C++为了开发者的方便而产生的，这部分知识整体来说理解起来不是很困难，但是比较琐碎，而且需要记住的东西比较多。

内联函数

1.问题的提出：

在C++中const定义的常量可以知道，const定义的常量的作用基本取代了宏，而且比宏拥有更多的好处，可以进行类型检查等，而且避开了比较单一的预编译期。但是在C语言中宏还是有不可替代的作用的，那就是宏可以当做一个函数来使用，而且使用起来十分方便，在C++中同样可以这样使用，但是为了避免宏的副作用，C++产生了一种新的函数，这种函数就叫做内联函数。 在C++中开发者是推荐使用内联函数来代替宏代码片的。

2.内联函数的声明方式

声明内联函数使用到一个关键字inline， inline关键字是C++的标准关键字。主要的声明格式如下所示：

#include <stdio.h>

inline int func(int a, int b, int c)
{
	return a + b + c;
}

int main()
{
	int d = 0;
	d = func(1, 2, 3);
	printf ("d = %d\n",d);
	return 0;
}

注意：内联函数声明时inline关键字必须和函数定义结合在一起，否则编译器将会忽略内联的请求。这里的要求在小程序中我们没法感觉到，尤其我们平时练习的程序都比较短，所以可能感觉不到。

#include <stdio.h>
inline int func(int a, int b, int c);

int main()
{
	int d = 0;
	d = func(1, 2, 3);
	printf ("d = %d\n",d);
	return 0;
}

int func(int a, int b, int c)
{
	return a + b + c;
}

上述程序func（）实际上并没有实现内联。

3.内联函数的原理以及注意事项

内联函数最终生成的代码是没有定义的，C++直接将函数体插入到函数调用的地方。之所以这样做的原因是可以节省函数调用时候的额外开销，这些额外开销也就是函数调用的标准开销，主要包括压栈，跳转，返回等。 如果C++编译器接受了函数的内联请求以后会将这个内联函数直接插入调用它的地方进行替换。也就是说内联函数没有函数调用时候的标准开销，压栈，跳转，返回。但是我们并不能够将每个函数调用的时候都声明为内联，因为C++编译器并不一定会允许我们请求的函数成为内联函数，如果C++编译器发现这个函数不能进行内联编译，那么我们申请内联的函数将会变成普通函数。
虽然内联函数具有各种各样的性质，但是它仍然是一个函数， 它拥有普通函数的特征，包括参数的检查，返回值的类型等。之所以成为内联函数，是因为这个函数是我们主动向编译器进行请求内联的， 内联函数是由编译器进行处理的，而宏只是简单的文本替换，是由预编译器进行处理的。

C++是一门现代化的变成语言，所以C++的编译器可以对我们的程序进行优化， 即使一些函数没有申明为内联函数，也有可能被编译器进行内联编译。 另外，一些现代 C++ 编译器提供了扩展语法，能够对函数进行强制内联. 如： g++ 中的 __attribute__(( always_inline )) 属性。例程如下：

#include <stdio.h>

inline int f_inline(int a, int b) __attribute__((always_inline));
int g_no_inline(int a, int b);

int main(int argc, char *argv[])
{
    int r1 = f_inline(1, 2);
    int r2 = g_no_inline(1, 2);
    
    printf("Press enter to continue ...");
    getchar();	
    return 0;
}

int f_inline(int a, int b)
{
	return a < b ? a : b;
}

int g_no_inline(int a, int b)
{
	return a < b ? a : b;
}

这里其实存在一个疑问的，前面说内联函数的关键字声明inline必须和函数的定义放在一起，但是加上那个固有的属性以后就不用放在一起了？这里索性认为是编译器造成的吧。

虽然内联函数可以节省开销，有比较多的好处，但是并不是所有的函数都可以成为内联函数的，这个是一个整体的比较以后C++的编译器才会确定是否将申请的函数或者没有申请的函数内联的。主要的几个标准如下：

①内联函数函数不存任何形式的循环语句。

②内联函数不能存在过多的条件判断语句。

③函数体不能过于庞大（很笼统的说，因为正常变成的函数体也不会超过100行，所以我们内联的时候还是仔细想想吧）

④不能对函数进行取址操作（进行取址操作的时间应该远大于函数调用过程的开销，没有必要再进行内联）

⑤函数内联声明必须在调用语句之前（编译器的识别顺序问题，要不然编译器无法发现该函数是内联函数）

编译器对内联函数的限制并不是绝对的，内联函数相对于普通函数只是省去了函数调用时候的压栈，跳转和返回的时间，因此当函数的执行开销远大于以上几种开销的时候也没有必要对函数进行内联了。

4.内联函数的实现机制

内联函数的实现再一次涉及到了C++编译器的符号表，这个符号表只是C++编译器的一种实现机制，并不是程序运行过程中的一些机制。通过符号表我们可以发现，当一个函数被申请为内联函数以后，编译器便将函数的内容以及参数和返回值等存储在符号表中，当程序再一次发现该函数的时候便会从符号表中取出相应的数值来进行替换，这期间也同时包括函数参数的检查等。所以 当我们进行汇编编译的过程中，我们会发现我们原来定义的函数已经不存在了，而函数的实现已经真正的嵌入到需要内联的地方去了。

C++函数默认参数

1.默认参数的基本概念

在声明函数的时候可以为函数的参数提供一个默认值，当函数调用时没有指定这个参数的值，编译器会自动为默认值代替。

基本定义形式如下：

#include <stdio.h>
int func(int a = 0)
{
	return a;
}

int main()
{
	printf ("func() = %d",func());
}

2.默认参数的基本规则

函数的默认参数，函数的默认参数这里其实隐约的可以看见顺序点的问题，也就是说我们在调用函数的时候向函数传递的参数和函数默认参数的对应是从前向后对应的，假如我们传递的参数是两个，而调用的函数的参数后两个是默认参数，那么我们传递的参数是从调用函数的第一个参数开始对应的，而不能都从后两个开始对应。这也是函数的默认参数必须是函数参数后半部分才可以开始默认的一个原因。

基本程序如下：

#include <stdio.h>

int func(int a, int b = 1, int c = 2)
{
	return a + b + c;
}

int main()
{
	int a = 0;
	a = func(2,3);
	printf ("a = %d", a);
}

同时，一旦一个函数调用中开始使用默认参数，那么这个参数后的所有参数都必须使用默认参数。
例程如下：

#include <stdio.h>
int func(int a, int b = 1, int c = 1)
{
	return a + b + c;
}

int main()
{
	printf ("func() = %d",func(1));
}

程序打印结果是func()= 3

#include <stdio.h>
int func(int a = 0, int b, int c = 1)
{
	return a + b + c;
}

int main()
{
	printf ("func() = %d",func(1));
}

程序无法编译通过。

#include <stdio.h>
int func(int a , int b, int c = 1)
{
	return a + b + c;
}

int main()
{
	printf ("func() = %d",func(1,2));
}

程序打印结果是func()=4

C++的占位参数

1.占位参数的基本概念

占位参数只有参数类型声明，而没有参数名的声明。 一般的情况下，在函数体的内部无法使用占位参数。

#include <stdio.h>
int func(int a , int b, int)
{
	return a + b;
}

int main()
{
	printf ("func() = %d",func(1,2,3));
}

上述程序的打印结果是3，假如我们在调用func（）函数的过程中传递的是两个参数，那么程序将不能够编译通过。这就是占位参数的一个重要作用。然而在上述程序中占位参数并没有起到实质性的作用。仅仅是起到了单纯的占位作用。

2.占位参数的意义

占位参数的意义主要有两点，一点是为了以后程序的扩展留下线索，另一点重要作用就是兼容C语言中不规范的写法。 例程：（将占位参数与默认参数结合起来使用！）

#include <stdio.h>

int func()
{
    return 1;
}

int main(int argc, char *argv[])
{
    printf("func() = %d\n", func());
    printf("func(1) = %d\n", func(1));
    
    printf("Press enter to continue ...");
    getchar();	
    return 0;
}

在上述程序中，假如原来这个程序来自于C语言的编写，所以两次函数调用都是合法的。但是这样的参数传递在C++中是绝对不合法的，假如我们有大量的这样的代码存在，那么一个工程的修改量将会大大加大。这个时候我们就需要启用占位参数。修改后的程序如下所示：

#include <stdio.h>

int func(int = 0)
{
    return 1;
}

int main(int argc, char *argv[])
{
    printf("func() = %d\n", func());
    printf("func(1) = %d\n", func(1));
    
    printf("Press enter to continue ...");
    getchar();	
    return 0;
}