返回类型和 return 语句

return 语句终止当前正在执行的函数并将控制权返回到调用该函数的地方。return 语句有两种形式：

return;

return expression;

 不要返回局部对象的引用或指针：

函数完成后，它所占用的存储空间也随之被释放掉。因此函数终止意味着局部变量的引用和指针将指向不再有效的内存区域：

一种典型的错误就是将一个指向局部变量的指针作为函数的返回值。由于该数组是局部变量，因此在函数返回时其数组空间已经作废了，即指针应用一块无意义的地址空间，所以不会有返回值。如果得到正常的值，只能是幸运的退出函数的时候，系统只是修改了栈顶的指针，并没有清内存； 所以，是有可能正常访问到局部变量的内存的。 但因为栈是系统自动管理的，所以该内存可能会被分配给其他函数，这样，该内存的内容就会被覆盖；不再是原来的值了。

#include <iostream>
using namespace std;

const string &cmp(void){
    const string s1 = "hdfl", s2 = "jflds";
    return s1 > s2 ? s1 : s2;
}

int main(void){
    const string s = cmp();
    // cout << s << endl;//错误，cmp 返回是一个指向被释放的无效内存区的引用
    return 0;
}

如前所述，返回局部对象的引用是错误的，同样返回局部对象的指针也是错误的。一旦函数完成，局部对象被释放，指针将指向一个不存在的对象。

引用返回左值：

函数的返回类型决定函数调用是否是左值。调用一个返回引用的函数得到左值，其他返回类型得到右值。所以能为返回类型是非常量引用的函数的结果赋值：

#include <iostream>
using namespace std;

char &gel(string &str, size_t indx){
    return str[indx];
}

int main(void){
    string s("a value");
    cout << s << endl;//输出 a value
    gel(s, 0) = 'A';//将s[0]的值改成A
    cout << s << endl;//输出A value
    return 0;
}

当然，如果函数返回的是常量引用，自然是不能给调用结果赋值的。

列表初始化返回值：

c++11 规定，函数可以返回花括号包围的值的列表。类似于返回其他结果，此处的列表也用来对表示函数返回的临时变量进行初始化。如果列表为空，临时量执行值初始化，否则，返回的值由函数的返回类型决定：

#include <iostream>
#include <vector>
using namespace std;

vector<string> gel(void){
    return {"fjls", "fjsl", "gel", "yy"};
}

int main(void){
    vector<string> s = gel();
    for(auto indx : s){
        cout << indx << endl;
    }
    return 0;
}

如果函数返回的是内置类型，则花括号包围的列表中最多包含一个值，而且该值所占空间不应该大于目标类型的空间。如果函数返回的是类类型，由类本身定义初始值如何使用。

返回数组指针：

因为数组不能拷贝，所以函数不能返回数组。不过，函数可以返回数组的指针或引用：

#include <iostream>
using namespace std;

typedef int arrT[10];//arrT是一个类型别名，表示的类型是含有10个整数的数组
// using arrT = int[10];//arrT的等价声明
typedef int arry[10][10];

arrT* gel(arrT& x){//x是数组a的引用
    return &x;
}

arrT& lou(arry& x){
    return x[0];
}

int main(void){
    arrT a = {1, 2, 3};
    arrT *b = gel(a);//相当于b指向a
    for(auto indx : *b){//b是一个指针,需要解引用
        cout << indx << " ";
    }
    cout << endl;
    // 输出 1 2 3 0 0 0 0 0 0 0
    arry c = {{1, 2, 3}};
    arrT &d = lou(c);//返回c的第一个数组元素的引用
    for(auto indx : d){
        cout << indx << " ";
    }
    cout << endl;
    // 输出 1 2 3 0 0 0 0 0 0 0
    return 0;
}

当然，不使用类型别名也是可以的，但是要麻烦一些。其声明如下：

Type (*function(parameter_list))[dimension]

其中 Type 表示元素类型，dimension 表示数组的大小，类似于一般的数组指针声明。(*function(parameter_list)) 两端的括号必须存在，如果没有则函数的返回类型将是指针的数组。

#include <iostream>
using namespace std;

int (*gel(int (&a)[10]))[10]{//注意:返回指针不能是局部对象
    return &a;
}

int (&lou(int (&a)[10][10]))[10]{//注意:返回引用不能是局部对象
    return a[0];
}

int main(void){
    int a[10] = {1, 2, 3};
    int (*b)[10] = gel(a);
    for(auto indx : *b){
        cout << indx << " ";
    }
    cout << endl;
    //输出 1 2 3 0 0 0 0 0 0 0

    int c[10][10] = {{1, 2, 3}};
    int (&d)[10] = lou(c);
    for(auto indx : d){
        cout << indx << " ";
    }
    cout << endl;
    //输出 1 2 3 0 0 0 0 0 0 0
    return 0;
}

尾置返回类型：

在 c++11 中还有一种可以简化上述 gel 函数声明的方法，就是使用尾置返回类型。任何函数的定义都能使用尾置返回，但是这种形式对于返回类型比较复杂的函数最有效，比如返回类型是数组的指针或者数组的引用。尾置返回类型跟在形参列表后面并以一个 -> 符号开头。为了表示函数真正的返回类型，我们在本应该出现返回类型的地方放置一个 auto：

#include <iostream>
using namespace std;

auto gel(int (&x)[10]) -> int(*)[10]{//使用尾置返回类型返回数组指针
    return &x;
}

auto lou(int (&x)[10][10]) -> int(&)[10]{//使用尾置返回类型返回数组引用
    return x[0];
}

int main(void){
    int a[10] = {1, 2, 3};
    int (*b)[10] = gel(a);
    for(auto indx : *b){//b是指针,需要解引用
        cout << indx << " ";
    }
    cout << endl;
    //输出 1 2 3 0 0 0 0 0 0 0

    int c[10][10] = {{1,2 , 3}};
    int (&d)[10] = lou(c);
    for(auto indx : d){
        cout << indx << " ";
    }
    cout << endl;
    //输出 1 2 3 0 0 0 0 0 0 0
    return 0;
}

使用 decltype：

还有一种情况，如果我们知道函数返回的指针将指向哪个数组，就可以使用 decltype 关键字声明返回类型：

#include <iostream>
using namespace std;

int a[3];

decltype(a) *gel(int (&x)[3]){
    return &x;
}

decltype(a) &lou(int (&x)[10][3]){
    return x[0];
}

//注意:decltype(a)返回的只是一个数组,并不会将数组类型转化成指针或者引用类型，所以还要再加一个指针或引用声明符

int main(void){
    int b[] = {1, 2, 3};
    int (*c)[3] = gel(b);
    for(auto indx : *c){
        cout << indx << " ";
    }
    cout << endl;
    //输出1 2 3

    int d[10][3] = {{1, 2, 3}};
    int (&e)[3] = lou(d);
    for(auto indx : e){
        cout << indx << " ";
    }
    cout << endl;
    //输出1 2 3
    return 0;
}