函数在声明和定义时，可以不用写形参名字，直接写形参数据类型，但是为了代码的可读性和维护，建议在声明和定义函数时都要写形参名字。
- int func(int a,int b); 等价 int func(int,int); //函数声明
- int func(int a,int b)
- {
- return a+b;
- }
函数这种写法叫做“前置返回类型”，也就是说函数的返回类型位于函数声明和函数定义语句的开头。
C++11引入一种新的函数语法，叫做后置返回类型也就是在函数声明或定义中把 返回类型写在参数列表后面。
- auto func(int a,int b)->int; //函数声明中的后置返回类型写法
-
- auto func(int a,int b)->int //函数定义中的后置返回类型写法
- {
- return a+b;
- }
在.h头文件中，直接定义一个函数，不需要声明，然后在函数前面加inline关键字，这就是内联函数,如下：
- inline int func(int a,int b)
- {
- return a+b;
- }
在程序执行过程中，调用函数时需要进行压栈和出栈处理函数调用和返回的问题，这一过程需要系统开辟内存空间，但是如果函数本身内容很少，调用函数又频繁调用系统开辟内存，耗费系统资源和性能问题。
函数前面加inline内联函数效果如下：
（1）影响编译器，在编译阶段完成对 inline 函数的处理，系统尝试将调用该函数的动作替将换为函数的本体(不再进行函数调用) .通过这种方式，来提升程序执行性能。
（2）inline 关键字只是程序员〈开发者 )对编译器的一个建议，编译器可以尝试去做也可以不去做，这取决于编译器的诊断功能，也就是说决定权在编译器，无法人为去控制.
（3）inline 函数尽量简单 ，代码尽量少，尤其是各种复杂的循环、分支、递归调用等，尽量少出现在内联函数中，否则，编译器可能会因为这些代码的原因拒绝让这个函数成为内联函数.
（4）用函数本体取代函数调用，显然可以增加效率，但同时带来的问题是函数代码膨胀了. 所以内联函数商数体要尽可能短小，这样引人 inline 才有意义。
以下函数用法转载于: https://www.cnblogs.com/zzdbullet/p/9559371.html
函数的局部变量返回值
一般的来说，函数是可以返回局部变量的，但是要注意几种情况。 局部变量的作用域只在函数内部，在函数返回后，局部变量的内存已经释放了。因此，如果函数返回的是局部变量的值，不涉及地址，程序不会出错。但是如果返回的是局部变量的地址(指针)的话，程序运行后会出错。因为函数只是把指针复制后返回了，但是指针指向的内容已经被释放了，这样指针指向的内容就是不可预料的内容，调用就会出错。准确的来说，函数不能通过返回指向栈内存的指针(注意这里指的是栈，返回指向堆内存的指针是可以的)。
返回局部变量的值可以有以下几种情况：
(1)返回局部自动变量
- int function(void)
- {
- int temp = 100; // 返回局部自动变量的值
- return temp;
- }
-
- int main()
- {
- int data = function();//data接收function返回的值
- cout << data << endl;
- return 0;
- }
局部变量temp存储在栈中，函数返回时会自动复制一份temp的copy给调用者，没有问题。
(2)局部静态变量
- int function()
- {
- static int a = 100; // 返回局部静态变量的值
- return a;
- }
-
- int main()
- {
- int data = function();//data接收function返回的值
- cout << data << endl;
- return 0;
- }
局部变量a存储在静态(全局)存储区中，从初始化后一直有效直到程序结束，仅分配一次内存，并且函数返回后，变量不会销毁，没有问题。
(3)返回一个静态的局部变量的地址
- int* function()
- {
- static int temp = 100;
- return &temp;//局部变量temp存储在静态存储区，返回指向静态存储区变量的指针是可行的。
- }
-
- int main()
- {
- int data = function();//data接收function返回的值
- cout << data << endl;
- return 0;
- }
返回的静态的局部变量的地址是没有问题的，因为静态变量的生命周期是系统程序的结束。
但是如果返回的是局部变量的指针就出问题了，因为栈里的变量在超过其作用域后或者函数返回后就销毁了，不存在了，如下所示：
- int* function()
- {
- int temp = 100; // 返回局部变量的地址
- return &temp; //函数返回时将已销毁变量的地址返回给调用者，结果将是不可预知的。
- }
-
- int &function()
- {
- int temp = 100; // 返回局部变量的引用是不可行的，结果将不可预知；
- return temp;
- }
因为引用返回的是局部变量temp本身而不是copy的一份，所以结果是不可预知的！
引用的地址概念：指针指向一块内存，它的内容是所指内存的地址；而引用则是某块内存的别名。
对(1)、(2)和(3)情况的小结：局部变量也分为自动变量（auto）和静态变量，由于(1)返回的是一个局部变量的值是可以的，是copy的一份，而不是原先栈上的一份，但是不应该返回其地址和引用。因为函数结束后，该局部变量栈上的变量被释放抛弃，这个指针指向一个不存在的空间对象，是没有意义的。但是由于静态变量存储在静态存储区，生命周期是整个程序运行的过程，所以可以返回局部变量的值、引用或指针。
如果函数的返回值非要是一个局部变量的地址，那么该局部变量一定要申明为static类型。
(4)返回一个指向常量的字符串指针
- char* function()
- {
- char *p = "Hello world!";//常量
- return p; // 返回指向常量字符串的指针
- }
对于字符串的特殊情况，由于字符串p存储在常量存储区（不是静态存储区），因此函数返回一个指向常量的字符串指针是可行的，但是返回一个局部字符串的指针是不可行的！
- char* function()
- {
- char str[] = "Hello world!";
- return str; // 返回局部字符串的指针
- }
这种情况下，str被初始化为字符串局部变量，存放在局部变量的栈中，因此函数返回一个已销毁的局部变量是不可行的。解决办法就是将字符串str声明为static。
(5)返回一个堆地址空间
- char* function()
- {
- char buffer[20]="Hello world!";
- char *str = (char *)malloc(strlen(buffer)+1);
- memcpy(str, buffer);
- return str;
- }
-
- int main()
- {
- char *recv = function();
- free(recv);//malloc和free成对使用
- return 0;
- }
返回一个堆内存空间是可行的，因为堆内存的生命周期是程序员自己手动开辟的，但是一定要记得释放内存，不然造成内存的泄漏（memory leak）。使用非常灵活。
(6)返回一个局部的对象
- Person function()
- {
- Person p1;
- p1.name = "test";
- return p1; // 返回的也是值拷贝，出现一个临时对象，会调用Person类的拷贝构造函数，没有问题。
- }
-
- vector function()
- {
- vector v;
- v.push_back(0);
- return v;//返回的是v的值拷贝，临时对象，没有问题。
- }
(7)返回一个静态数数组
- int* function( void )
- {
- static int array[10]; //静态数组；
- ........
- return array;
- }
-
- char *returnStr()
- {
- static char p[]="hello world!"; //静态字符串数组
- return p;
- }
由于一般的自动数组是不能作为函数的返回值的，原因是因为编译器把数组名认为是局部变量（数组）的地址，返回一个数组一般是返回这个数组的首地址，用一个指针代替，而且这个指针是栈上的一个局部变量，当函数结束后就自动释放了，这样就相当于返回了一个无效的指针。所以要返回一个局部数组需要将该数组定义为static类型，因为静态存储期是程序从对象定义到程序结束。或者是全局的数组也行。
const int abc = 12; //不能改变abc的值
（1）const char *p;
- char str[]=“jinxueHou”;
-
- char *p;
- p = str;
- *p=’J’;
- p++;//p可以指向遍历不同的位置，只要这些位置的内存归我们管即可
如果将p的定义修改为：
const char *p;
则表示p指向的内容不能通过p来修改 (p 所指向的目标，那个目标中的内容不能通过p来改变) 。因此 ，有人把p称为常量指针 (p 指向的内容不能通过p来修改) 。如下用p来修改p指向的内容是错的：
p[0]=’J’; //这种写法是错误的
当然，通过str本身修改自身的内存的内容是没有问题的：
str[0]=’J’; //正确
（2）char const *p;等价于:const char *p;这里就不讲char const *p;的使用。
（3）char *const p;
看看如下例子，密切注意注释中的内容：
- char str[]=”jinxueHou”;
- char *const p= str; //定义的时候必须初始化
- p++;//不可以这样用，p指向str首地址后，p指针不能再往后偏移，但是p可以改变它str的内容。
- p[0] = 'H';
- p[1] = 'o';
- p[2] = 'u';
- p[3] = 'j';
- p[4] = 'i';
- p[5] = 'n';
- p[6] = 'x';
- p[7] = 'u';
- p[8] = 'e';
- for (auto &i:str)
- {
- cout << i << endl;
- }
因此，有人把p称为指针常常量(p不可以再指向其他内容)。
（4）const char *const p = str;或char const *const p = str;
结合了(1)-(3) ，表示p的指向不能改变，p指向的内容不能通过p来改变。
（5）还有一些引用类型的const用法读者也应该熟悉起来 。
看看如下例子:
- int i = 100;
- const int &a = i;//表示a代表的内容不能修改，所以 a=200 非法
-
- const int &b = 165;//正常，但是int&b=165就是错误的，右值必须是变量而不是常量
- b = 200;//错误，这里b被看成常量，值不能修改。
- struct student
- {
- int num;
- };
-
- void fs(student &stu)
- {
- stu. num=1010;
- }
-
- student abc;
- abc.num=100;
- fs(abc);
- cout << abc.num<< endl; //1010
上面这段代码，可以注意到,在fs()函数中可以修改stu里的num 成员，修改后 会被带回到主调函数中，也就是说，fs()函数中对形参修改实际就是对实参abc的修改，因为这里形参采用的是引用类型。如果不希望在函数fs中修改参数stu里的值，建议形参最好使用常量引用(这种习惯在写代码中经常被用到)。
- void fs(const student &stu)
- {
- stu.num = 1010;//这里这种用法错误，不能修改stu中的内容
- }
- void fs(const int i)//实参可以是正常的int,形参可以用const int接
- {
- i = 100; //不能修改i的值，表示不能给常量赋值
- }
这种把形参写成const形式的习惯有许多好处：
（1）可以防止无意中修改了形参值，导致实参值被无意修改掉；
（2）实参类型可以更加灵活。
我们来看一下以下例子：
- struct student
- {
- int num;
- };
-
- void fs(student &stu)
- {
-
- }
那如下在主函数 main 中的调用就是错误的：
- int main()
- {
- student abc;
- abc.num = 100;
- const student &def = abc;
- fs(def); //这样不正确，因为def类型是const&，fs的形参不带const
- return 0;
- }
但是如下像下面这样修改fs函数的形参：
- void fs(const student &stu)
- {
-
- }
可以看到，const student&这种类型的形参可以接受的实参类型更多样性（程序代码更灵活），可以接收普通引用作为实参，也可以接收常量引用作为实参。那么，看如下代码：
fs(def); //正确
fs(abc); //形参加了const，不影响从实参中接收普通对象
再继续看代码：
- void fun2(int &a)//定义函数func2
- {
-
- }
那么，如果这样调用func2函数，是不可以的：
func2(123); //这种调用是错误的，必须传递一个变量，不能是一个常数
但是，如果像下面这样修改func2的定义：
- void func2(const int &a)
- {
-
- }
这样再调用func2如下传参就没有问题：
func2(123); //正常，可以用常量123作为实参传参
2022.06.25结。