函数可以通过return语句，终止函数的执行并“返回”函数调用的地方；并且可以给定返回值。返回值的类型由函数声明时的“返回类型”决定。
return语句可以有两种形式：
return;// 直接返回，无返回值
return 表达式; // 返回表达式的值
1. 无返回值
当函数返回类型为void时，表示函数没有返回值。可以在函数中需要返回时直接执行 return语句，也可以不写。由于返回类型为void的函数执行完最后一句，会自动加上return返回。
例如，可以将之前“两元素值互换”的代码，包装成一个函数。可以先做一个判定，假如两者相等就直接返回，这样可以进步运行效率。
// 元素互换
void swap(int& x, int& y)
{
if (x == y)
return; // 不需要交换，直接返回
int temp = x;
x = y;
y = temp;
}
这里判定假如元素相等就直接返回，有些类似于流程控制中的break。最后一句代码后面省略了return。
2. 有返回值
假如函数返回类型不为void，那么函数必需执行return，并且每条return必需返回一个值。返回值的类型应该跟函数返回类型一致，或者可以隐式转换为一致。
（1）函数返回值的原理
函数在调用点会创建一个“临时量”，用来留存函数调用的结果。当使用return语句返回时，就会用返回值去初始化这个临时量。所以返回值的相关规则，跟变量或者形参的初始化是一致的。
之前写过一个“比较字符串长度”的isLonger函数，我们可以稍作修改，让它可以返回较长的那个字符串：
// 字符串比较长度，返回较长的
string longerStr(const string& str1, const string& str2)
{
return str1.size() > str2.size() ? str1 : str2;
}
int main()
{
string str1 = "hello world!", str2 = "c++ is interesting!";
cout << longerStr(str1, str2) << endl;
}
调用这个函数，经由判定发现str2较长，这时执行return将返回str2。因为返回类型是string，所以将用str2对一个string临时量做初始化，执行的是值拷贝。终极返回的值，是str2的一个副本。
（2）返回引用类型
对于string对象，显然做值拷贝并不高效。所以我们依然可以鉴戒之前的经验，使用引用类型来做返回值的传递，这样就可以避免值拷贝。
// 返回一个string常量对象的引用，不做值拷贝
const string & longerStr(const string& str1, const string& str2)
{
return str1.size() > str2.size() ? str1 : str2;
}
这里我们同样把返回值定义成了常量引用，方式和作用跟形参完全一样。
上面函数返回的是形参str1或者str2的引用；而函数中的形参本身又是引用类型，所以终极是实参对象的引用。
而假如返回的是一个函数内局部变量的引用，好比：
const string & f()
{
string str = "test";
return str;
}
这样做是不安全的：由于str是函数内部的局部对象，函数执行完成后就销毁了；而返回值是它的引用，相当于引用了一个不存在的对象，这可能会导致无法预料的问题。
所以，函数返回引用类型时，不能返回局部对象的引用；同样道理，也不应该返回指向局部对象的指针。
（3）返回类对象后连续调用
假如函数返回一个类的对象，那么我们可以继承调用这个对象的成员函数，这样就形成了“链式调用”。例如：
longerStr(str1, str2).size();
调用运算符，和访问对象成员的点运算符优先级相同，并且满意左结合律。所以链式调用就是从左向右依次调用，代码可读性会更高。
3. 主函数的返回值
主函数main是一个特殊函数，它是我们执行程序的进口。所以C++中对主函数的返回值也有特殊的划定：即使返回类型不是void，主函数也可以省略return语句。假如主函数执行到结尾都没有return语句，编译器就会自动插入一条：
return 0;
主函数的返回值可以看做程序运行的状态指示器：返回0表示运行成功；返回非0值则表示失败。非0值详细的含义依靠机器决定。
这也是为什么之前我们在主函数中都可以不写return。
4. 返回数组指针
与形参的讨论类似，因为数组“不能拷贝”的特点，函数也无法直接返回一个数组。同样的，我们可以使用指针或者引用来实现返回数组的目标；通常会返回一个数组指针。
int arr[5] = { 1,2,3,4,5 };
int* pa[5]; // 指针数组，pa是包含5个int指针的数组
int(*ap)[5] = &arr; // 数组指针，ap是一个指针，指向长度为5的int数组
int(*fun(int x))[5]; // 函数声明，fun返回值类型为数组指针
这里对于函数fun的声明，我们可以进行层层解析：
l fun(int x) ：函数名为fun，形参为int类型的x；
l ( * fun(int x) )：函数返回的结果，可以执行解引用操纵，说明是一个指针；
l ( * fun(int x) )[5]：函数返回结果解引用之后是一个长度为5的数组，说明返回类型是数组指针；
l int ( * fun(int x) )[5]：数组中元素类型为int
数组指针的定义比较繁琐，为了简化这个定义，我们可以使用关键字typedef来定义一个类型的别号：
typedef int arrayT[5]; // 类型别号，arrayT代表长度为5的int数组
arrayT* fun2(int x); // fun2的返回类型是指向arrayT的指针
C++ 11新尺度还提供了另一种简化方式，用一个->符号跟在形参列表后面，再把类型单独提出来放到最后。这种方式叫做“尾置返回类型”。
auto fun3(int x) -> int(*)[5]; // 尾置返回类型
由于返回类型放到了末尾，所以前面的类型用了自动推断的auto。
函数可以通过return语句，终止函数的执行并“返回”函数调用的地方；并且可以给定返回值。返回值的类型由函数声明时的“返回类型”决定。
return语句可以有两种形式：
return;// 直接返回，无返回值
return 表达式; // 返回表达式的值
1. 无返回值
当函数返回类型为void时，表示函数没有返回值。可以在函数中需要返回时直接执行 return语句，也可以不写。由于返回类型为void的函数执行完最后一句，会自动加上return返回。
例如，可以将之前“两元素值互换”的代码，包装成一个函数。可以先做一个判定，假如两者相等就直接返回，这样可以进步运行效率。
// 元素互换
void swap(int& x, int& y)
{
if (x == y)
return; // 不需要交换，直接返回
int temp = x;
x = y;
y = temp;
}
这里判定假如元素相等就直接返回，有些类似于流程控制中的break。最后一句代码后面省略了return。
2. 有返回值
假如函数返回类型不为void，那么函数必需执行return，并且每条return必需返回一个值。返回值的类型应该跟函数返回类型一致，或者可以隐式转换为一致。
（1）函数返回值的原理
函数在调用点会创建一个“临时量”，用来留存函数调用的结果。当使用return语句返回时，就会用返回值去初始化这个临时量。所以返回值的相关规则，跟变量或者形参的初始化是一致的。
之前写过一个“比较字符串长度”的isLonger函数，我们可以稍作修改，让它可以返回较长的那个字符串：
// 字符串比较长度，返回较长的
string longerStr(const string& str1, const string& str2)
{
return str1.size() > str2.size() ? str1 : str2;
}
int main()
{
string str1 = "hello world!", str2 = "c++ is interesting!";
cout << longerStr(str1, str2) << endl;
}
调用这个函数，经由判定发现str2较长，这时执行return将返回str2。因为返回类型是string，所以将用str2对一个string临时量做初始化，执行的是值拷贝。终极返回的值，是str2的一个副本。
（2）返回引用类型
对于string对象，显然做值拷贝并不高效。所以我们依然可以鉴戒之前的经验，使用引用类型来做返回值的传递，这样就可以避免值拷贝。
// 返回一个string常量对象的引用，不做值拷贝
const string & longerStr(const string& str1, const string& str2)
{
return str1.size() > str2.size() ? str1 : str2;
}
这里我们同样把返回值定义成了常量引用，方式和作用跟形参完全一样。
上面函数返回的是形参str1或者str2的引用；而函数中的形参本身又是引用类型，所以终极是实参对象的引用。
而假如返回的是一个函数内局部变量的引用，好比：
const string & f()
{
string str = "test";
return str;
}
这样做是不安全的：由于str是函数内部的局部对象，函数执行完成后就销毁了；而返回值是它的引用，相当于引用了一个不存在的对象，这可能会导致无法预料的问题。
所以，函数返回引用类型时，不能返回局部对象的引用；同样道理，也不应该返回指向局部对象的指针。
（3）返回类对象后连续调用
假如函数返回一个类的对象，那么我们可以继承调用这个对象的成员函数，这样就形成了“链式调用”。例如：
longerStr(str1, str2).size();
调用运算符，和访问对象成员的点运算符优先级相同，并且满意左结合律。所以链式调用就是从左向右依次调用，代码可读性会更高。
3. 主函数的返回值
主函数main是一个特殊函数，它是我们执行程序的进口。所以C++中对主函数的返回值也有特殊的划定：即使返回类型不是void，主函数也可以省略return语句。假如主函数执行到结尾都没有return语句，编译器就会自动插入一条：
return 0;
主函数的返回值可以看做程序运行的状态指示器：返回0表示运行成功；返回非0值则表示失败。非0值详细的含义依靠机器决定。
这也是为什么之前我们在主函数中都可以不写return。
4. 返回数组指针
与形参的讨论类似，因为数组“不能拷贝”的特点，函数也无法直接返回一个数组。同样的，我们可以使用指针或者引用来实现返回数组的目标；通常会返回一个数组指针。
int arr[5] = { 1,2,3,4,5 };
int* pa[5]; // 指针数组，pa是包含5个int指针的数组
int(*ap)[5] = &arr; // 数组指针，ap是一个指针，指向长度为5的int数组
int(*fun(int x))[5]; // 函数声明，fun返回值类型为数组指针
这里对于函数fun的声明，我们可以进行层层解析：
l fun(int x) ：函数名为fun，形参为int类型的x；
l ( * fun(int x) )：函数返回的结果，可以执行解引用操纵，说明是一个指针；
l ( * fun(int x) )[5]：函数返回结果解引用之后是一个长度为5的数组，说明返回类型是数组指针；
l int ( * fun(int x) )[5]：数组中元素类型为int
数组指针的定义比较繁琐，为了简化这个定义，我们可以使用关键字typedef来定义一个类型的别号：
typedef int arrayT[5]; // 类型别号，arrayT代表长度为5的int数组
arrayT* fun2(int x); // fun2的返回类型是指向arrayT的指针
C++ 11新尺度还提供了另一种简化方式，用一个->符号跟在形参列表后面，再把类型单独提出来放到最后。这种方式叫做“尾置返回类型”。
auto fun3(int x) -> int(*)[5]; // 尾置返回类型
由于返回类型放到了末尾，所以前面的类型用了自动推断的auto。
函数可以通过return语句，终止函数的执行并“返回”函数调用的地方；并且可以给定返回值。返回值的类型由函数声明时的“返回类型”决定。
return语句可以有两种形式：
return;// 直接返回，无返回值
return 表达式; // 返回表达式的值
1. 无返回值
当函数返回类型为void时，表示函数没有返回值。可以在函数中需要返回时直接执行 return语句，也可以不写。由于返回类型为void的函数执行完最后一句，会自动加上return返回。
例如，可以将之前“两元素值互换”的代码，包装成一个函数。可以先做一个判定，假如两者相等就直接返回，这样可以进步运行效率。
// 元素互换
void swap(int& x, int& y)
{
if (x == y)
return; // 不需要交换，直接返回
int temp = x;
x = y;
y = temp;
}
这里判定假如元素相等就直接返回，有些类似于流程控制中的break。最后一句代码后面省略了return。
2. 有返回值
假如函数返回类型不为void，那么函数必需执行return，并且每条return必需返回一个值。返回值的类型应该跟函数返回类型一致，或者可以隐式转换为一致。
（1）函数返回值的原理
函数在调用点会创建一个“临时量”，用来留存函数调用的结果。当使用return语句返回时，就会用返回值去初始化这个临时量。所以返回值的相关规则，跟变量或者形参的初始化是一致的。
之前写过一个“比较字符串长度”的isLonger函数，我们可以稍作修改，让它可以返回较长的那个字符串：
// 字符串比较长度，返回较长的
string longerStr(const string& str1, const string& str2)
{
return str1.size() > str2.size() ? str1 : str2;
}
int main()
{
string str1 = "hello world!", str2 = "c++ is interesting!";
cout << longerStr(str1, str2) << endl;
}
调用这个函数，经由判定发现str2较长，这时执行return将返回str2。因为返回类型是string，所以将用str2对一个string临时量做初始化，执行的是值拷贝。终极返回的值，是str2的一个副本。
（2）返回引用类型
对于string对象，显然做值拷贝并不高效。所以我们依然可以鉴戒之前的经验，使用引用类型来做返回值的传递，这样就可以避免值拷贝。
// 返回一个string常量对象的引用，不做值拷贝
const string & longerStr(const string& str1, const string& str2)
{
return str1.size() > str2.size() ? str1 : str2;
}
这里我们同样把返回值定义成了常量引用，方式和作用跟形参完全一样。
上面函数返回的是形参str1或者str2的引用；而函数中的形参本身又是引用类型，所以终极是实参对象的引用。
而假如返回的是一个函数内局部变量的引用，好比：
const string & f()
{
string str = "test";
return str;
}
这样做是不安全的：由于str是函数内部的局部对象，函数执行完成后就销毁了；而返回值是它的引用，相当于引用了一个不存在的对象，这可能会导致无法预料的问题。
所以，函数返回引用类型时，不能返回局部对象的引用；同样道理，也不应该返回指向局部对象的指针。
（3）返回类对象后连续调用
假如函数返回一个类的对象，那么我们可以继承调用这个对象的成员函数，这样就形成了“链式调用”。例如：
longerStr(str1, str2).size();
调用运算符，和访问对象成员的点运算符优先级相同，并且满意左结合律。所以链式调用就是从左向右依次调用，代码可读性会更高。
3. 主函数的返回值
主函数main是一个特殊函数，它是我们执行程序的进口。所以C++中对主函数的返回值也有特殊的划定：即使返回类型不是void，主函数也可以省略return语句。假如主函数执行到结尾都没有return语句，编译器就会自动插入一条：
return 0;
主函数的返回值可以看做程序运行的状态指示器：返回0表示运行成功；返回非0值则表示失败。非0值详细的含义依靠机器决定。
这也是为什么之前我们在主函数中都可以不写return。
4. 返回数组指针
与形参的讨论类似，因为数组“不能拷贝”的特点，函数也无法直接返回一个数组。同样的，我们可以使用指针或者引用来实现返回数组的目标；通常会返回一个数组指针。
int arr[5] = { 1,2,3,4,5 };
int* pa[5]; // 指针数组，pa是包含5个int指针的数组
int(*ap)[5] = &arr; // 数组指针，ap是一个指针，指向长度为5的int数组
int(*fun(int x))[5]; // 函数声明，fun返回值类型为数组指针
这里对于函数fun的声明，我们可以进行层层解析：
l fun(int x) ：函数名为fun，形参为int类型的x；
l ( * fun(int x) )：函数返回的结果，可以执行解引用操纵，说明是一个指针；
l ( * fun(int x) )[5]：函数返回结果解引用之后是一个长度为5的数组，说明返回类型是数组指针；
l int ( * fun(int x) )[5]：数组中元素类型为int
数组指针的定义比较繁琐，为了简化这个定义，我们可以使用关键字typedef来定义一个类型的别号：
typedef int arrayT[5]; // 类型别号，arrayT代表长度为5的int数组
arrayT* fun2(int x); // fun2的返回类型是指向arrayT的指针
C++ 11新尺度还提供了另一种简化方式，用一个->符号跟在形参列表后面，再把类型单独提出来放到最后。这种方式叫做“尾置返回类型”。
auto fun3(int x) -> int(*)[5]; // 尾置返回类型
由于返回类型放到了末尾，所以前面的类型用了自动推断的auto。
函数可以通过return语句，终止函数的执行并“返回”函数调用的地方；并且可以给定返回值。返回值的类型由函数声明时的“返回类型”决定。
return语句可以有两种形式：
return;// 直接返回，无返回值
return 表达式; // 返回表达式的值
1. 无返回值
当函数返回类型为void时，表示函数没有返回值。可以在函数中需要返回时直接执行 return语句，也可以不写。由于返回类型为void的函数执行完最后一句，会自动加上return返回。
例如，可以将之前“两元素值互换”的代码，包装成一个函数。可以先做一个判定，假如两者相等就直接返回，这样可以进步运行效率。
// 元素互换
void swap(int& x, int& y)
{
if (x == y)
return; // 不需要交换，直接返回
int temp = x;
x = y;
y = temp;
}
这里判定假如元素相等就直接返回，有些类似于流程控制中的break。最后一句代码后面省略了return。
2. 有返回值
假如函数返回类型不为void，那么函数必需执行return，并且每条return必需返回一个值。返回值的类型应该跟函数返回类型一致，或者可以隐式转换为一致。
（1）函数返回值的原理
函数在调用点会创建一个“临时量”，用来留存函数调用的结果。当使用return语句返回时，就会用返回值去初始化这个临时量。所以返回值的相关规则，跟变量或者形参的初始化是一致的。
之前写过一个“比较字符串长度”的isLonger函数，我们可以稍作修改，让它可以返回较长的那个字符串：
// 字符串比较长度，返回较长的
string longerStr(const string& str1, const string& str2)
{
return str1.size() > str2.size() ? str1 : str2;
}
int main()
{
string str1 = "hello world!", str2 = "c++ is interesting!";
cout << longerStr(str1, str2) << endl;
}
调用这个函数，经由判定发现str2较长，这时执行return将返回str2。因为返回类型是string，所以将用str2对一个string临时量做初始化，执行的是值拷贝。终极返回的值，是str2的一个副本。
（2）返回引用类型
对于string对象，显然做值拷贝并不高效。所以我们依然可以鉴戒之前的经验，使用引用类型来做返回值的传递，这样就可以避免值拷贝。
// 返回一个string常量对象的引用，不做值拷贝
const string & longerStr(const string& str1, const string& str2)
{
return str1.size() > str2.size() ? str1 : str2;
}
这里我们同样把返回值定义成了常量引用，方式和作用跟形参完全一样。
上面函数返回的是形参str1或者str2的引用；而函数中的形参本身又是引用类型，所以终极是实参对象的引用。
而假如返回的是一个函数内局部变量的引用，好比：
const string & f()
{
string str = "test";
return str;
}
这样做是不安全的：由于str是函数内部的局部对象，函数执行完成后就销毁了；而返回值是它的引用，相当于引用了一个不存在的对象，这可能会导致无法预料的问题。
所以，函数返回引用类型时，不能返回局部对象的引用；同样道理，也不应该返回指向局部对象的指针。
（3）返回类对象后连续调用
假如函数返回一个类的对象，那么我们可以继承调用这个对象的成员函数，这样就形成了“链式调用”。例如：
longerStr(str1, str2).size();
调用运算符，和访问对象成员的点运算符优先级相同，并且满意左结合律。所以链式调用就是从左向右依次调用，代码可读性会更高。
3. 主函数的返回值
主函数main是一个特殊函数，它是我们执行程序的进口。所以C++中对主函数的返回值也有特殊的划定：即使返回类型不是void，主函数也可以省略return语句。假如主函数执行到结尾都没有return语句，编译器就会自动插入一条：
return 0;
主函数的返回值可以看做程序运行的状态指示器：返回0表示运行成功；返回非0值则表示失败。非0值详细的含义依靠机器决定。
这也是为什么之前我们在主函数中都可以不写return。
4. 返回数组指针
与形参的讨论类似，因为数组“不能拷贝”的特点，函数也无法直接返回一个数组。同样的，我们可以使用指针或者引用来实现返回数组的目标；通常会返回一个数组指针。
int arr[5] = { 1,2,3,4,5 };
int* pa[5]; // 指针数组，pa是包含5个int指针的数组
int(*ap)[5] = &arr; // 数组指针，ap是一个指针，指向长度为5的int数组
int(*fun(int x))[5]; // 函数声明，fun返回值类型为数组指针
这里对于函数fun的声明，我们可以进行层层解析：
l fun(int x) ：函数名为fun，形参为int类型的x；
l ( * fun(int x) )：函数返回的结果，可以执行解引用操纵，说明是一个指针；
l ( * fun(int x) )[5]：函数返回结果解引用之后是一个长度为5的数组，说明返回类型是数组指针；
l int ( * fun(int x) )[5]：数组中元素类型为int
数组指针的定义比较繁琐，为了简化这个定义，我们可以使用关键字typedef来定义一个类型的别号：
typedef int arrayT[5]; // 类型别号，arrayT代表长度为5的int数组
arrayT* fun2(int x); // fun2的返回类型是指向arrayT的指针
C++ 11新尺度还提供了另一种简化方式，用一个->符号跟在形参列表后面，再把类型单独提出来放到最后。这种方式叫做“尾置返回类型”。
auto fun3(int x) -> int(*)[5]; // 尾置返回类型
由于返回类型放到了末尾，所以前面的类型用了自动推断的auto。
函数可以通过return语句，终止函数的执行并“返回”函数调用的地方；并且可以给定返回值。返回值的类型由函数声明时的“返回类型”决定。
return语句可以有两种形式：
return;// 直接返回，无返回值
return 表达式; // 返回表达式的值
1. 无返回值
当函数返回类型为void时，表示函数没有返回值。可以在函数中需要返回时直接执行 return语句，也可以不写。由于返回类型为void的函数执行完最后一句，会自动加上return返回。
例如，可以将之前“两元素值互换”的代码，包装成一个函数。可以先做一个判定，假如两者相等就直接返回，这样可以进步运行效率。
// 元素互换
void swap(int& x, int& y)
{
if (x == y)
return; // 不需要交换，直接返回
int temp = x;
x = y;
y = temp;
}
这里判定假如元素相等就直接返回，有些类似于流程控制中的break。最后一句代码后面省略了return。
2. 有返回值
假如函数返回类型不为void，那么函数必需执行return，并且每条return必需返回一个值。返回值的类型应该跟函数返回类型一致，或者可以隐式转换为一致。
（1）函数返回值的原理
函数在调用点会创建一个“临时量”，用来留存函数调用的结果。当使用return语句返回时，就会用返回值去初始化这个临时量。所以返回值的相关规则，跟变量或者形参的初始化是一致的。
之前写过一个“比较字符串长度”的isLonger函数，我们可以稍作修改，让它可以返回较长的那个字符串：
// 字符串比较长度，返回较长的
string longerStr(const string& str1, const string& str2)
{
return str1.size() > str2.size() ? str1 : str2;
}
int main()
{
string str1 = "hello world!", str2 = "c++ is interesting!";
cout << longerStr(str1, str2) << endl;
}
调用这个函数，经由判定发现str2较长，这时执行return将返回str2。因为返回类型是string，所以将用str2对一个string临时量做初始化，执行的是值拷贝。终极返回的值，是str2的一个副本。
（2）返回引用类型
对于string对象，显然做值拷贝并不高效。所以我们依然可以鉴戒之前的经验，使用引用类型来做返回值的传递，这样就可以避免值拷贝。
// 返回一个string常量对象的引用，不做值拷贝
const string & longerStr(const string& str1, const string& str2)
{
return str1.size() > str2.size() ? str1 : str2;
}
这里我们同样把返回值定义成了常量引用，方式和作用跟形参完全一样。
上面函数返回的是形参str1或者str2的引用；而函数中的形参本身又是引用类型，所以终极是实参对象的引用。
而假如返回的是一个函数内局部变量的引用，好比：
const string & f()
{
string str = "test";
return str;
}
这样做是不安全的：由于str是函数内部的局部对象，函数执行完成后就销毁了；而返回值是它的引用，相当于引用了一个不存在的对象，这可能会导致无法预料的问题。
所以，函数返回引用类型时，不能返回局部对象的引用；同样道理，也不应该返回指向局部对象的指针。
（3）返回类对象后连续调用
假如函数返回一个类的对象，那么我们可以继承调用这个对象的成员函数，这样就形成了“链式调用”。例如：
longerStr(str1, str2).size();
调用运算符，和访问对象成员的点运算符优先级相同，并且满意左结合律。所以链式调用就是从左向右依次调用，代码可读性会更高。
3. 主函数的返回值
主函数main是一个特殊函数，它是我们执行程序的进口。所以C++中对主函数的返回值也有特殊的划定：即使返回类型不是void，主函数也可以省略return语句。假如主函数执行到结尾都没有return语句，编译器就会自动插入一条：
return 0;
主函数的返回值可以看做程序运行的状态指示器：返回0表示运行成功；返回非0值则表示失败。非0值详细的含义依靠机器决定。
这也是为什么之前我们在主函数中都可以不写return。
4. 返回数组指针
与形参的讨论类似，因为数组“不能拷贝”的特点，函数也无法直接返回一个数组。同样的，我们可以使用指针或者引用来实现返回数组的目标；通常会返回一个数组指针。
int arr[5] = { 1,2,3,4,5 };
int* pa[5]; // 指针数组，pa是包含5个int指针的数组
int(*ap)[5] = &arr; // 数组指针，ap是一个指针，指向长度为5的int数组
int(*fun(int x))[5]; // 函数声明，fun返回值类型为数组指针
这里对于函数fun的声明，我们可以进行层层解析：
l fun(int x) ：函数名为fun，形参为int类型的x；
l ( * fun(int x) )：函数返回的结果，可以执行解引用操纵，说明是一个指针；
l ( * fun(int x) )[5]：函数返回结果解引用之后是一个长度为5的数组，说明返回类型是数组指针；
l int ( * fun(int x) )[5]：数组中元素类型为int
数组指针的定义比较繁琐，为了简化这个定义，我们可以使用关键字typedef来定义一个类型的别号：
typedef int arrayT[5]; // 类型别号，arrayT代表长度为5的int数组
arrayT* fun2(int x); // fun2的返回类型是指向arrayT的指针
C++ 11新尺度还提供了另一种简化方式，用一个->符号跟在形参列表后面，再把类型单独提出来放到最后。这种方式叫做“尾置返回类型”。
auto fun3(int x) -> int(*)[5]; // 尾置返回类型
由于返回类型放到了末尾，所以前面的类型用了自动推断的auto。
