const 作为函数返回类型返回字面常量返回指针且指向的内容不能被修改函数返回为引用运算符重载时

83 阅读 0 评论 55 点赞

我是靠谱客的博主壮观台灯，最近开发中收集的这篇文章主要介绍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;
}