https://www.cnblogs.com/Azhu/p/4352613.html
c++ 函数的返回类型，包括const 什么时候起作用呢?
- 函数返回值不想其立即修改的。
例子如下，这是一个简单的避免产生隐形返回变量的方法，abc 的函数返回是引用，main函数中第10行，++ 操作是基于 const int & 类型，所以会出错，但以后对改引用的操作不会受到const 约束。
这样的好处是避免了函数返回值与操作符的逻辑错误结合，例如下面的例子中函数返回的++，对于main 函数是不直观的，进一步的应用是在操作符重载方面，见下一情况说明。
1 const int & abc(int a,int b,int &re)
2 {
3 re = a+b;
4 return re;
5 }
6
7 int main()
8 {
9 int a = 1,b =2,c;
10 abc(a,b,c)++; /////////////////////错误
11 c++; /////////////////////正确
12 cout<<c<<endl;
13 return 0;
14 }
- 重载运算符符合逻辑
一般变量赋值a=b=c，这是没有问题的，但是(a=b)=c 编译会出错，这是内置操作符的判断，如果对 = 操作符重载了，为了避免这样的逻辑错误，需要在返回类型上加上const 约束，下面例子中A类重载了运算符 +，如果第6行中返回类型没有const 约束，那么15行编译会通过，场景如果是：if(a+b==c) 误写为 if(a+b=c)。
+ 运算符重载加const 约束 对 a+b+c 这样的运算没有影响，因为a+b 运算的结果是const ，但对其只是只读操作，会创建一个新的 A 类返回。
1 class A
2 {
3 public:
4 int a;
5 A(int b):a(b){}
6 friend const A operator +(const A& lft,const A& rgt)
7 {
8 return A(lft.a + rgt.a);
9 }
10 };
11
12 int main()
13 {
14 A a(1),b(3),c(7);
15 a+b = c; /////////错误
16 return 0;
17 }
- 通过函数创建指向常量的指针
如果通过函数来创建常字符串，除了在main 函数中约束之外，也可以在函数返回类型中约束，第一行中左边的const 约束了返回的是常字符串的指针索引，因为它的存在12行必须声明为 const char *p，如果第一行左边const 不存在，那么12行可以加可以不加const，这样约束常字符串的效果只能在main 中反映，不能很好的表达调用函数的功能。
同时第一行中的第二个const 加了也无效，其约束的是一个由 char * p 转变为 char * const 的隐藏指针，该隐藏指针的指向值赋予给main 函数中的p，所以后者可以修改指向。（这时我的理解不确定正确与否）
1 const char * const helpFun()
2 {
3 char * p =new char[3];
4 p[0]='a';
5 p[1]='b';
6 p[2]='\0';
7 return p;
8 }
9
10 int main()
11 {
12 const char * p = helpFun();
13 p++;
14 cout<<p<<endl;
15 delete p;
16 return 0;
17 }
- 满足对const成员函数的调用
这个结合例子说明比较容易，这里主要有一个原因是：const类型的对象，不能调用自身的非const成员函数，但是可以调用自己的const成员函数。例如下面的例子，b 声明为const A，12行是可以编译成功的，13行缺会错误，根本原因或许是内部 this 指针转换（不确定）。
1 class A {
2 public:
3 A():num(2) { }
4 void setnum() { }
5 void getnum() const{ }
6 private:
7 int num;
8 };
9 int main()
10 {
11 const A b;
12 b.getnum();
13 b.setnum();///////////////////////错误
14 return 0;
15 }
基于上面的一个原因，下面例子便容易说明，A 类是B 类运算中产生的隐藏变量，为了调用A 类中的const 函数，B类生产A 类的函数返回类型需要加const。
1 class A
2 {
3 public:
4 A():num(2){}
5 void setnum(){ num = 10; }
6 void getnum() const{
7 printf("%d\\n",num);
8 }
9 private:
10 int num;
11 };
12
13 class B
14 {
15 public:
16 const A* get()
17 {
18 A *p = new A();
19 return p;
20 }
21 };
22
23 int main()
24 {
25 B b;
26 b.get()->getnum();
27 b.get()->setnum();
28 return 0;
29 }
- const 成员函数的返回类型是引用时候，需要加const 约束
int fun() const; int & fun() const;
成员函数中上面是合法的，下面缺不合法，具体例子如下，对于第5行 函数返回类型中的const 不能省略，不管第10行是否有const，这应该是内部value 对象类型的转换，GetValue 函数中的value 被转换成了 const int（第10行没有const 也会转换），但return 的如果是 int & 类型便出现了 const int -> int & 这种类型转换，这是禁止的，所以返回引用时必须加const，总结来说，如果GetValue 是const函数且返回类型是引用，那么返回类型中的const 和16行的const 不能省略。
1 class Test
2 {
3 public :
4 Test(int a):value(a){}
5 const int & GetValue()const
6 {
7 return value;
8 }
9 private:
10 const int value;
11 };
12
13 int main()
14 {
15 Test t(3);
16 const int &a = t.GetValue();
17 cout<<a<<endl;
18 return 0;
19 }
引申如果const 成员函数返回的值 指针呢？这与返回int 类型是一样是赋值给接受对象，而引用因为没有了复制所以必须有const，例如下面代码可以编译运行，同时发现绕开了类的private约束。第6行返回类型加const，其实便是第三种情况。如果第13行 是 const int * p，那么情况便不一样了，第6行和第19行都需要加const。
1 class Test
2 {
3 public :
4 Test(int a):value(a){ p = &value; }
5 void setValue(){value =10;}
6 int * GetValue()const
7 {
8 return p;
9 }
10 int getv(){return value;}
11 private:
12 int value;
13 int * p;
14 };
15
16 int main()
17 {
18 Test t(3);
19 int *a = t.GetValue();
20 cout<<*a<<endl;
21 *a = 5;
22 cout<<t.getv()<<endl;
23 delete a;
24 return 0;
25 }
参考资料：
http://www.docin.com/p-97354417.html
http://blog.chinaunix.net/uid-24922718-id-3480107.html
http://blog.sina.com.cn/s/blog_4366aa320100cknr.html
http://blog.csdn.net/zhjxin1800/article/details/7584375
http://www.cnblogs.com/lichkingct/archive/2009/04/21/1440848.html