特殊用途语言特性(默认实参/内联函数/constexpr函数/assert预处理宏/NDEBUG预处理变量)

默认实参：

某些函数有这样一种形参，在函数的很多次调用中它们都被赋予一个相同的值，此时，我们把这个反复出现的值称为函数的默认实参。调用含有默认实参的函数时，可以包含该实参，也可以省略该实参。

需要特别注意的是：

1. 一旦某个形参被赋予了默认值，它后面的所有形参都必须有默认值。

2. 只能省略尾部的实参。

3. 实参会从形参列表的第一个形参开始匹配，若它们的类型能相互转换也能匹配成功。

4. 局部变量不能作为默认实参。除此之外，只要表达式的类型能转换成形参所需要的类型，该表达式就能作为默认实参。

#include <iostream>
using namespace std;

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

int ting(int a = 1, char b = 'a', string c = "fjslf"){
    return a;
}

int yy1 = 1, yy2 = 1;

int yu(int a = yy1, int b = yy2){//可以使用全局变量作默认实参
    return a + b;
}

// int lou(int a = 1, int b, int c){//错误:一旦某个形参有默认值,则其后面的所有形参都必须有默认值
//     ;
// }

int main(void){
    int cnt1 = gel();
    int cnt2 = gel(2);
    int cnt3 = gel(2, 2);
    int cnt4 = gel(2, 2, 2);
    cout << cnt1 << " " << cnt2 << " " << cnt3 << " " << cnt4 << endl;//输出 3 4 5 6

    int cc1 = ting(10, 'a', "fskl");
    // int cc2 = ting('a', "lsjf");//错误:只能省略尾部实参
    int cc3 = ting(2, 'b');
    int cc4 = ting('b');//注意'b'能转换成int类型,此时'b'是赋值给形参a的
    cout << cc1 << " " << cc3 << " " << cc4 << endl;//输出10 2 98
    return 0;
}

内联函数：

内联函数可以避免函数调用时的时间开销。将函数指定为内联函数，通常就是将它在调用点上“内联地”展开。相当于将该函数直接嵌入调用点。

定义一个比较两个 int 型的内联函数：

inline bool compre(const int a, const int b){
    return a > b;
}

内联说明只是向编译器发出的一个请求，编译器可以选择忽略这个请求。一般来说，内联机制用于优化规模比较小，流程直接，频繁调用的函数。很多编译器都不支持内联递归函数，而且一个 75 行的函数也不大可能在调用点内联地展开。

constexpr 函数：

constexpr 函数是指能用于常量表达式的函数。定义 constexpr 函数的方法与其他函数类型，不过要遵循几项约定：

1. 函数的返回类型以及所有的形参类型都得是字面值类型。

2. 函数体内必须有且只有一条 return 语句。

#include <iostream>
using namespace std;

constexpr int new_sz(int a){
    return a;
}

constexpr char new_char(char s){
    return s;
}

// constexpr string new_str(string s){//错误
//     return s;
// }

int main(void){
    const int foo = new_sz(10);
    cout << foo << endl;

    const char ch = new_char('h');
    cout << ch << endl;
    return 0;
}

指针和引用也是字面值类型：

#include <iostream>
using namespace std;

constexpr int* new_sz(int &a){
    return &a;
}

constexpr int* get(int *a){
    return a;
}

int main(void){
    int b = 1024;
    int *a = new_sz(b);
    cout << *a << endl;//输出1024

    int *c = get(&b);
    cout << *c << endl;//输出1024
    return 0;
}

执行初始化任务时，编译器把 constexpr 函数的调用替换成其结果值。为了能在编译过程中随时展开，constexpr 函数被隐式的指定为内联函数。

constexpr 函数体内也可以包含其他语句，只要这些语句在运行时不执行任何操作就行。例如：constexpr 函数中可以有空语句，类型别名以及 using 声明：

constexpr int new_sz(int a){
    // int b;错误:在constexpr函数中不能有执行操作的语句
    using ll = long long;//在constexpr函数中可以有using声明
    ;//在constexpr函数中可以有空语句
    typedef int in;//在constexpr函数中可以有命名类型别名
    return a;
}

和其他函数不一样，内联函数和 constexpr 函数可以在程序中多次定义。毕竟，编译器要想展开函数仅有声明是不够的，还需要函数的定义。不过，对于某个给定的内联函数或者 constexpr 函数来说，它的多个定义必须完全一致。基于这个原因，内联函数和 constexpr 函数通常定义在头文件中。

调试帮助

assert 预处理宏：

assert 是一种预处理宏。所谓预处理宏其实是一个预处理变量，它的行为有点类似于内联函数。assert 宏使用一个表达式作为它的条件：

assert(expr);

首先对 expr 求值，如果表达式为假，assert 输出信息并终止程序执行。如果表达式为真，assert 什么也不做。assert 宏定义在 cassert 头文件中。如我们所知，预处理名字由预处理器而非编译器管理，因此我们可以直接使用预处理名字而无需提供 using 声明。也就是说，我们应该使用 assert 而不是 std::assert，也不需要为 assert 提供 using 声明。

和预处理变量一样，宏名字在程序内必须唯一。含有 cassert 头文件的程序不能再定义为 assert 的变量，函数或者其他实体。在实际编程中，即使没有包含 cassert 头文件，也最好不要为了其他目的使用 assrert。因为其他头文件中也有可能包含了 cassert。

assert 宏常用于检查“不能发生”的条件。

NDEBUG 预处理变量：

 assert 的行为依赖于一个名为 NDEBUG 的预处理变量的状态。如果定义了 NDEBUG 则 assert 什么也不做。默认状态下没有定义 NDEBUG，此时 assert 将执行运行时检查。这些通过查看 assert.h 头文件里的源码可以发现：

/* 
 * assert.h
 * This file has no copyright assigned and is placed in the Public Domain.
 * This file is a part of the mingw-runtime package.
 * No warranty is given; refer to the file DISCLAIMER within the package.
 *
 * Define the assert macro for debug output.
 *
 */

/* We should be able to include this file multiple times to allow the assert
   macro to be enabled/disabled for different parts of code.  So don't add a
   header guard.  */ 

#ifndef RC_INVOKED

/* All the headers include this file. */
#include <_mingw.h>

#undef assert

#ifdef    __cplusplus
extern "C" {
#endif

#ifdef NDEBUG
/*
 * If not debugging, assert does nothing.
 */
#define assert(x)    ((void)0)

#else /* debugging enabled */

/*
 * CRTDLL nicely supplies a function which does the actual output and
 * call to abort.
 */
_CRTIMP void __cdecl __MINGW_NOTHROW _assert (const char*, const char*, int) __MINGW_ATTRIB_NORETURN;

/*
 * Definition of the assert macro.
 */
#define assert(e)       ((e) ? (void)0 : _assert(#e, __FILE__, __LINE__))

#endif    /* NDEBUG */

#ifdef    __cplusplus
}
#endif

#endif /* Not RC_INVOKED */

用 NDEBUG 宏避免 assert 检查：

#include <iostream>
#define NDEBUG//注意NDEBUG宏一定要定义在cassert头文件引用前,不然#include <cassert>句执行的时候
// 就生成了在没有定义NDEBUG情况下的代码,后面定义的NDEBUG不会影响assert的行为
#include <cassert>
using namespace std;

int main(void){
    assert(0);
    cout << 1 << endl;
    return 0;
}

预处理器定义的几个对于程序调试很有用的名字：

__func__ // 存储当前函数的名字, 是 const char 的一个静态数组
__FILE__ // 存放当前文件名字符串字面值
__LINE__ // 存放当前行号的整型字面值
__TIME__ // 存放文件编译时间的字符串字面值(时分秒)
__DATE__ // 存放文件编译日期的字符串字面值(月日年)

#include <iostream>
using namespace std;

void gel(void){
    cout << __func__ << endl;
    cout << __FILE__ << endl;
    cout << __LINE__ << endl;
    cout << __TIME__ << endl;
    cout << __DATE__ << endl;
}

int main(void){
    gel();
    return 0;
}