const 作为函数返回类型

const 作为函数返回类型，最终目的是希望调用函数时将返回值作为常量处理。细分为三种情况。

返回字面常量

const int getval(void)
{
    return 100;
}

该函数返回值里的const其实是可有可无的。

返回指针且指向的内容不能被修改

const int* getptr(void)
{
    int *p = (int *)0xCC;
    return p;
}
int main()
{
    const int *p = getptr();//ok
    int *q = getptr();//error
    ...
    return 0;
}

函数返回为引用

函数返回为引用时，如果不想修改函数调用后的值，则用$const &$。 函数返回值引用常量表示不能将函数调用表达式作为左值使用。例如：

    int & min( int &　i, int &　j);

可以对min函数调用进行赋值,因为它返回的是左值。例如$min ( a , b )=4$或者$min(a,b)+=min(b,a)+5$，对大多数编译器都是合法的（但有些编译器会直接报错或者warning）。
但是，如果对函数的返回值限定为 const 的：$const int & min ( int & i, int &j )$,
那么，就不能对 min ( a, b ) 调用进行赋值了。

运算符重载时

运算符重载时，如果不想修改使用运算符后的表达式的值，就应该将重载函数返回值设为$const &$

struct B
{
B();
int m_data[10];
int & operator [] (int i){return m_data[i];}
}
void main()
{
B b;
b[0] = 1;//ok
b[1] = 2;//ok
}

struct B
{
B();
int m_data[10];
const int & operator [] (int i){return m_data[i];}
}
void main()
{
B b;
b[0] = 1;//error
b[1] = 2;//error
}

代码调试示例：

#include <iostream>
using namespace std;

//int & absum(int & a, int & b) //返回局部对象的引用,N
//const int & absum(int & a, int & b)//返回了a+b这个局部对象的引用，N
//int & absum(const int & a, const int & b)//返回了a+b这个局部对象的引用，N
//int absum(int & a, int & b) //返回局部对象的副本,并且不希望被当做左值调用，Y; 若absum(a,b) += 2, N
//int absum(const int & a, const int & b) //返回局部对象的副本,Y
//const int & absum(const int & a, const int & b)//返回局部对象的引用，且不希望被当做左值调用，warning(把引用符号去掉后就无warning); 若absum(a,b) += 2, error;
//const int & absum(const int & a, const int & b)//返回了a+b这个局部对象的引用，N
//const int absum(int & a, int & b)//地址传递, 返回局部对象的副本,Y
//const int absum(int a, int b)//值传递, 返回局部对象的副本,Y；
const int absum(const int & a, const int & b)//返回局部对象的副本，且不希望被当做左值调用，Y; effective c++中第二种情况：调用后不修改返回对象的值时，返回const; 若absum(a,b) += 2,不允许;
{
    return a+b;
}
const int & abmax(const int & a, const int & b) //effective c++中第一种情况：不修改参数时，返回const
{
    //return a; //Y
    //return a+b; //N
    /*
    int c = a+b;
    return c; 
    */ // N
    return a>b?a:b;
}
const int* getptr(void) //不修改指针指向的内容
{
    int *p = (int *)0xCC;
    return p;
}
class B
{
public:
    B()
    {
    };
    int m_data[10];

    int & operator [] (int i) // bb[0] = 2, Y
    //const int & operator [] (int i) // bb[0] = 2, N
    //int operator [] (int i) // bb[0] = 2, N;
    //const int operator [] (int i) // bb[0] = 2, N
    {
        return m_data[i];
    }
};
int main()
{
    int a = 1;
    int b = 2;
    //absum(a,b) += 1;
    int sum = absum(a, b);
    const int * p = getptr(); // Y
    //int * p = getptr(); // N
    B bb;
    cout<<bb[0]<<endl;
    bb[0] = 2; //若无此赋值，那四种重载方法都是可以的。
    cout<<bb[0]<<endl;
    cout<<a<<" "<<b<<" "<<sum<<" "<<abmax(a, b)<<" "<<p<<endl;
    return 0;
}