内联函数inline：
引入内联函数的目的是为了解决程序中函数调用的效率问题，程序在编译器编译的时候，编译器将程序中出现的内联函数的调用表达式用内联函数的函数体进行替换，而对于其他的函数，都是在运行期才被替代。这其实就是个空间代价换时间的节省。所以内联函数一般都是1-5行的小函数。在使用内联函数时要注意：

  • 1.在内联函数内不允许使用循环语句和开关语句；
  • 2.内联函数的定义必须出现在内联函数第一次调用之前；
  • 3.在类定义中的定义的函数都是内联函数，即使没有使用 inline 说明符。 ```cpp

    include

using namespace std;

inline int Max(int x, int y) { return (x > y)? x : y; }

// 程序的主函数 int main( ) {

cout << “Max (20,10): “ << Max(20,10) << endl; cout << “Max (0,200): “ << Max(0,200) << endl; cout << “Max (100,1010): “ << Max(100,1010) << endl; return 0; }

  2. **constexpr函数：**<br />即可能在编译期执行，又可能在运行期执行，因此要保证可以在编译期就可以实现函数的执行，一些在运行期的操作加进去会发生报错，就是提高程序运行效率。
  3. ```cpp
  4. #include <iostream>
  6. constexpr int fun(int x) // 1 3
  7. {
  8.     int y = 100;
  9.     return x + 1;
  10. }
  12. int main()
  13. {
  15.     constexpr int x = fun(3);
  16.     return x;
  17. }

优化后的汇编代码：

  1. main:
  2.         mov     eax, 4
  3.         ret
  4. _GLOBAL__sub_I_main:
  5.         sub     rsp, 8
  6.         mov     edi, OFFSET FLAT:_ZStL8__ioinit                                              
  7.         call    std::ios_base::Init::Init() [complete object constructor]
  8.         mov     edx, OFFSET FLAT:__dso_handle
  9.         mov     esi, OFFSET FLAT:_ZStL8__ioinit
  10.         mov     edi, OFFSET FLAT:_ZNSt8ios_base4InitD1Ev
  11.         add     rsp, 8
  12.         jmp     __cxa_atexit

consteval函数
只能在编译期运行，有严格的限制

函数指针
函数类型:只能为函数引入声明，用法比较狭窄

  1. #include <iostream>
  3. using K = int(int);
  4. K fun;
  6. int main()
  7. {
  8.     fun(3);
  9. }

函数指针类型：

  1. #include <iostream>
  2. #include <algorithm>
  3. #include <vector>
  5. int inc(int a)
  6. {
  7.     return a + 1;
  8. }
  10. int dec(int a)
  11. {
  12.     return a - 1;
  13. }
  15. using K = int(int); // 命名别称
  17. int twice(K* fun,int x)
  18. {
  19.     int temp = (*fun)(x);
  20.     return temp * 2;
  21. }
  23. int main()
  24. {
  25.     std::vector<int> vec = {1,2,3,4,5};
  26.     std::transform(vec.begin(),vec.end(),vec.begin(),&dec); // 函数指针作为函数参数
  27.     for(auto i : vec){
  28.         std::cout << i << std::endl;
  29.     }
  30. }
  1. #include <iostream>
  3. int inc(int a)
  4. {
  5.     return a + 1;
  6. }
  8. int dec(int a)
  9. {
  10.     return a - 1;
  11. }
  13. auto func(bool flag) // 函数指针作为返回值
  14. {
  15.     if(flag){
  16.         return inc;
  17.     }
  18.     else{
  19.         return dec;
  20.     }
  21. }
  23. int main()
  24. {
  25.     std::cout << func(true)(100) << std::endl;
  26. }

Most_vexing_parse：

  1. struct Timer {};
  3. struct TimeKeeper {
  4.   explicit TimeKeeper(Timer t);
  5.   int get_time();
  6. };
  8. int main() {
  9.   TimeKeeper time_keeper(Timer());
  10.   return time_keeper.get_time();
  11. }

以这个代码为TimeKeeper time_keeper(Timer());例分析：
第一种理解：
TimeKeeper类的变量time_keeper的变量定义，用Timer类的匿名实例初始化
第二种理解：
一个函数time_keeper的函数声明，它返回一个TimeKeeper类型的对象，并且有一个单一的(未命名的)形参，其类型是一个(指向一个函数的指针)函数，不接受输入并返回Timer对象。
C++11引入的解决方案：

  1. TimeKeeper time_keeper(Timer{});
  2. TimeKeeper time_keeper{Timer()};
  3. TimeKeeper time_keeper{Timer{}};