一、函数前置与后置返回类型
函数在声明和定义时，可以不用写形参名字，直接写形参数据类型，但是为了代码的可读性和维护，建议在声明和定义函数时都要写形参名字。
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 char*、char const*、char*const三者的区别
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被看成常量，值不能修改。
五、函数形参中带const
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结。
