精华内容
下载资源
问答
  • c++ const函数返回值
    千次阅读
    2019-07-23 13:20:30

    c++中const可用于修饰方法

    1. 第一种情况:const位于方法参数列表后,如 void test() const;

        此种情况表明,此方法不会改变调用对象的状态,保证了调用对象的常量性

     

    2. 第二种情况:const 位于返回类型前

        此情况表明返回对象为常量,不可改变,例如以下代码:

        A& test(A& a) {

        return a;

        }

     

      如果不用const修饰,则我们可以写出这样的合法语句:

          test(a) = b;

         为了避免这种情况,我们声明为 const A& test(A& a); 在编译期杜绝

    转载于:https://www.cnblogs.com/tristansun/archive/2012/07/14/2591556.html

    更多相关内容
  • 函数返回值(包含const返回值解析)

    千次阅读 2019-04-01 11:16:08
    如何返回值 1.返回值非引用 primer说函数返回值用于初始化函数调用点的一个临时对象,所以返回值到临时对象是第一次拷贝,临时对象到接收值的变量是第二次拷贝。 string make_plural(size_t ctr, const string &...

    如何返回值

    1.返回值非引用

    primer说函数返回值用于初始化函数调用点的一个临时对象,所以返回值到临时对象是第一次拷贝,临时对象到接收值的变量是第二次拷贝

    string make_plural(size_t ctr, const string &word, const string &ending)
    {
        return (ctr > 1) ? word : word+ending;    //到临时对象有一次拷贝。
    } 

    如果把返回值设为引用,就省去了拷贝。

    问题:那个调用点的临时对象是const吗?

    2.返回值是引用

    如果是引用类型,中间不用发生任何拷贝

    3. 实例探究

    const非引用作用:

    不让其作为左值,在作为右值时和非const一样都是const属性。

    const引用作用:

    让返回值有const属性。但用于对其他对象进行拷贝时,是不是const都能进行。

    #include <iostream>
    #include <vector>
    #include <string>
    using namespace std;
    
    //1和2用于探究返回值是const非引用
    string shorterString1(string s1, string s2)
    {
        return s1.size()<=s2.size() ? s1:s2;
    }
    
    const string shorterString2(string s1, string s2)
    {
        return s1.size()<=s2.size() ? s1:s2;
    }
    
    //3和4用于探究返回值是const引用
    string &shorterString3(string &s1, string &s2)
    {
        return s1.size()<=s2.size() ? s1:s2;
    }
    
    const string &shorterString4(string &s1, string &s2)
    {
        return s1.size()<=s2.size() ? s1:s2;
    }
    
    
    int main() {
    
       string s1 = "123";
        string s2 = "456";
        string s3 = shorterString1(s1, s2);
        string s4 = shorterString2(s1, s2);
    
        shorterString1(s1, s2) = "456";
        shorterString2(s1, s2) = "456";    //xxx, 作为左值const有用了
    
        string &s3p = shorterString1(s1, s2); //xxx,cannot bind non-const lvalue reference to an rvalue of type 'const string',作为右值const没用啊
        string &s4p = shorterString2(s1, s2); //xxx,两者都不能绑定
        
        //=====================================
        string &s5= shorterString3(s1, s2);
        string &s6= shorterString4(s1, s2); //xxx, binding reference of type 'std::__cxx11::string&' {aka 'std::__cxx11::basic_string<char>&'} to 'const string' {aka 'const std::__cxx11::basic_string<char>'} discards qualifiers
    
        string s7= shorterString3(s1, s2); //这俩都是拷贝,和 是不是返回值const无关
        string s8= shorterString4(s1, s2);
        return 0;
    }

    不要返回局部变量的指针或引用

    局部变量在函数返回后会消亡,所以地址无效。

    下面是错误,其中建立一个const char[6]的数组,不能把非const绑定到const。

    string &manip()
    {
        return "Empty"; //xxx,cannot bind non-const lvalue reference of type 'std::__cxx11::string&' {aka 'std::__cxx11::basic_string<char>&'} to an rvalue of type 'std::__cxx11::string' {aka 'std::__cxx11::basic_string<char>'}
    }
    

    下面是警告,绑定到一个临时对象。

    const string &manip()
    {
        return "Empty";  // warning: returning reference to temporary
    }

    引用返回左值

    只有引用返回左值,其他返回右值。想引用不能修改,就加上const限定

    #include <iostream>
    #include <vector>
    #include <string>
    using namespace std;
    
    char &get_val1(string &s, string::size_type position)
    {
        return s[position];
    }
    
    char get_val2(string &s, string::size_type position)
    {
        return s[position];
    }
    
    const char &get_val3(string &s, string::size_type position)
    {
        return s[position];
    }
    
    int main() {
    
        string s ="123";
        get_val1(s, 0) = '1';
        get_val2(s, 0) = '1'; //xxx,函数是右值,人家要左值lvalue required as left operand of assignment
        get_val3(s, 0) = '1'; //xxx,const左值不能修改
        return 0;
    }

     

    展开全文
  • //编译错误,const返回值禁止作为左值调用.因为左值 把返回值作为变量会修改其返回值,const声明禁止这种修改。 返回的类型为const型不能被修改 对于int来说没有什么意义 返回值只能为右值本身就是const ...
    include <iostream>
    2 #include <string>
    3 using namespace std;
    4
    5 class person
    6 {
    7 private:
    8     int id;
    9     string name;
    10 public:
    11     person(int id, string name):id(id), name(name)
    12     {
    13         cout << “invoke con” << endl;
    14     }
    15     void show();
    16     ~person()
    17     {
    18         cout << “invoke decon ~” << endl;
    19     }
    20     string get_name()const
    21     {
    22         return name;
    23     }
    24     void set_name(string n)
    25     {
    26         name = n;
    27     }
    28
    29 };
    30
    31 void person::show()
    32 {
    33     cout << “id: ” << id << ” name: ” << name << endl;
    34 }
    35
    36 string format(person *ps)
    37 {
    38     return “[" + ps->get_name() + "]“;
    39 }
    40
    41 string format(const person &ps)
    42 {
    43     //成员函数get_name定义时如果没有末尾的const,将不能在此处调用。因为ps是const的引用
    44 //    ps.set_name(“m”);
    45     return “&” + ps.get_name() + “&”;
    46 }
    47
    48 int main(void)
    49 {
    50     person p(1, “a”);
    51     p.show();
    52
    53     cout << “format: ” << format(&p) << endl;
    55     cout << “format&: ” << format(p) << endl;
    56
    57
    58     return 0;
    59 }
    1. const在函数返回值前:
    返回const值,意思指返回的原函数里的变量的初值不能被修改,但是函数
    按值返回的这个变量被制成副本,能不能被修改就没有了意义,它可以被赋给任何
    的const或非const类型变量,完全不需要加上这个const关键字.但这只对于内部
    类型而言(因为内部类型返回的肯定是一个值,而不会返回一个变量,不会作为左
    值使用),对于用户自定义类型,返回值是常量是非常重要的,
    X Fuction1 () { return X(); }
    const X Fuction2 () { return X(); }
    如有上面的自定义类X,和函数Fuction1()和Fuction2(),我们进行如下操作时:
    Fuction1()=X(1); //没有问题,可以作为左值调用
    Fuction2()=X(1); //编译错误,const返回值禁止作为左值调用.因为左值
    把返回值作为变量会修改其返回值,const声明禁止这种修改。
    返回的类型为const型不能被修改
    对于int来说没有什么意义 返回值只能为右值本身就是const
    2. const在函数末尾:
    const 成员函数
    任何不会修改数据成员的函数都应该声明为const 类型。如果在编写const 成员函
    数时,不慎修改了数据成员,或者调用了其它非const 成员函数,编译器将指出错误,
    这无疑会提高程序的健壮性。
    以下程序中,类stack 的成员函数GetCount 仅用于计数,从逻辑上讲GetCount 应
    当为const 函数。编译器将指出GetCount 函数中的错误。
    class Stack
    {
    public:
    void Push(int elem);
    int Pop(void);
    int GetCount(void) const; // const 成员函数
    private:
    int m_num;
    int m_data[100];
    };
    int Stack::GetCount(void) const
    {
    ++ m_num; // 编译错误,企图修改数据成员m_num
    Pop(); // 编译错误,企图调用非const 函数
    return m_num;
    }
    const 成员函数的声明看起来怪怪的:const 关键字只能放在函数声明的尾部,大
    概是因为其它地方都已经被占用了。

     

    3.const修饰返回值:

    当返回值是自定义类型时,函数调用表达式是可以作为左值的

    person buildArlen()
    {
        person p(1, “arlen”);
        return p;
    }

    buildArlen() = person(11, “ii”);

    当然,如果返回值是内建类型如int这些,函数调用表达式是不可以作左值的,你可以试试。所以说,const如果修改返回内建类型是没有意义的。

    但修饰返回自定义类型的函数就有意义了,你猜对了,如果是const person buildArlen()这样的声明,在使用时把buildArlen()看作一个自定义类型的变量就可以了,这个变量不但已经有值而且这个变量还是const的。

    const person buildArlen()
    {
        person p(1, “arlen”);
        return p;
    }

    buildArlen() = person(11, “ii”); //报错!buildArlen() 是const的,不能再被赋值。

    要注意:以下代码是ok的:

    const person buildArlen(){…}

    person ps = p.buildArlen();
    ps.set_name(“xx”);  //这行是没有问题的。

    4. const修饰指针类型返回值:

    a. 定义:const person * buildArlen(){…}
        调用:const person *pt = buildArlen(); //必须在前面有const,无则报错

    b. 定义:person const * buildArlen(){…}
        调用:const person *pt = buildArlen(); //是的,跟a是一样的。你也可以把const放在紧挨*的左侧:person const *pt = buildArlen();一个意思。

    c. 定义:person * const buildArlen(){…}
        调用:
        person *pt= buildArlen();//前面加不加const都ok。

    小结:如果返回值是自定义类型的指针,就可以直接将整个函数调用看作一个变量。为什么上述a,b在接受返回值时要在前面加const?因为普通变量也是如此的:

    int i = 8;
    const int *pi = &i;
    const int *ptest = pi;//如果去掉前面的const则会报错。why?因为pi指向的变量值不能变,而ptest也是指向同一变量i的地址,所以ptest也必须用const修饰,否则i的值就可能会变。

    总结:
    返回自定义类型的函数调用可以作左值;作右值时类比普通变量。

    返回自定义类型的指针的函数调用不可以作左值;作右值时类比普通变量。

    返回内建类型或内建类型指针的函数调用不可以作左值;作右值类比普通变量。

    展开全文
  • 目录 1、C++中const用于函数重载 1、const int/ volatile int/ int 不构成重载 2、int*和int*const不构成...2、返回值为什么不能加入重载? 1、C++中const用于函数重载 1、const int/ volatile int/ int 不构成重

    目录

    1、C++中const用于函数重载

    1、const int/ volatile int/ int 不构成重载

    2、int*和int*const不构成重载

    3、const int&和int构成重载

    4、int&和int构成重载

    5、const int&和int& 构成重载

    6、int*和const int*构成重载

    2、返回值为什么不能加入重载?


    1、C++中const用于函数重载

    1、const int/ volatile int/ int 不构成重载

    void fun(const int)
    {
    	cout << "fun(const int)" << endl;
    }
    
    void fun(volatile int)
    {
    	cout << "fun(volatile int)" << endl;
    }
    
    void fun(int)
    {
    	cout << "fun(int)" << endl;
    }

    编译报错,这三个函数,不构成重载,原因是函数调用的时候,存在形实结合的过程,这三个函数的实参都是按值传递的,无论i是做为一个const/volatile参数或正常参数,都没有什么区别

    2、int*和int*const不构成重载

    void fun(int* p)
    {
    	cout << "fun(int*)" << endl;
    }
    
    void fun(int* const p)
    {
    	cout << "fun(const int*)" << endl;
    }

    因为指针p实参都是按值传递的,无论p是做为一个const指针参数或正常参数,都没有什么区别,都无法修改实参所指向地址,代码验证:

    int a;
    void fun(int* p)
    {
    	p = &a;    //改为fun(int* const p),编译报错
    	cout << "fun(int*)" << endl;
    }
    
    int main()
    {
    	int * const p = nullptr;
    	fun(p);
    	cout << (int)p << endl;        //输出0
    	getchar();
    	return 0;
    }

    3、const int&和int构成重载

    void fun(const int&)
    {
    	cout << "fun(const int&)" << endl;
    }
    
    void fun(int)
    {
    	cout << "fun(int)" << endl;
    }

     编译通过,这两个函数构成重载,调用:

    fun(1); //编译错误,函数匹配未决,实参是const int类型,可以匹配 int ,const int&

    4、int&和int构成重载

    void fun(int&)
    {
    	cout << "fun(const int&)" << endl;
    }
    
    void fun(int)
    {
    	cout << "fun(int)" << endl;
    }

    编译通过,这两个函数构成重载,看下调用:

    	fun(1);			//调用fun(int)
    	//fun(a);		//编译错误,调用未决,实参是int,可以匹配  fun(int&) fun(int)

    5、const int&和int& 构成重载

    void fun(const int&)
    {
    	cout << "fun(const int&)" << endl;
    }
    
    void fun(int&)
    {
    	cout << "fun(int&)" << endl;
    }

    编译通过,这两个函数构成重载,看下调用:

    	int a = 1;
    	const int& b = a;
    	fun(1);		//1是常量,调用fun(const int&)
    	fun(b);		//b是常量,调用fun(const int&)
    	fun(a);		//a是变量,调用fun(int&)

    6、int*和const int*构成重载

    void fun(int*)
    {
    	cout << "fun(int*)" << endl;
    }
    
    void fun(const int*)
    {
    	cout << "fun(const int*)" << endl;
    }

     编译通过,这两个函数构成重载,看下调用:

    	int a = 1;
    	const int& b = a;
    	fun(&a);		//调用fun(int*)
    	fun(&b);		//调用fun(const int*)

    2、返回值为什么不能加入重载?

    因为函数在调用时可以不将返回值赋值给一个对应的变量,这样就没有特征区分

    展开全文
  • const参数,const返回值与const函数

    千次阅读 2014-11-12 18:14:17
    在C++程序中,经常用const 来限制对一个对象的操作,例如,将一个变量定义为const 的:  const int n=3; 则这个变量的值不能被修改,即不能对变量赋值。  const 这个关键字经常出现在函数的定义中,而且...
  • const引用返回值

    2018-10-30 15:35:26
    一、引用 引用是别名 必须在定义引用时进行初始化。初始化是指明引用指向哪个对象的...const 引用是指向 const 对象的引用: const int ival = 1024; const int &amp;refVal = ival; // ok: both refere...
  • 一.const 简介 1.const 修饰变量 2.const 修饰指针 二.const 修饰在函数名前面 三.const 修饰在函数名后面 四.猜你喜欢 零基础 C/C++ 学习路线推荐 : C/C++ 学习目录 >> C 语言基础入门 一.const 简介 ...
  • const 修饰函数的参数和作为返回值

    千次阅读 多人点赞 2019-01-25 20:10:34
    const 更大的魅力是它可以修饰函数的参数、返回值,甚至函数的定义体。 const 是constant 的缩写,“恒定不变”的意思。被const 修饰的东西都受到强制保护,可以预防意外的变动,能提高程序的健壮性。所以很多C++...
  • c++中const的使用详解

    2021-05-26 03:04:57
    Const 是C++中常用的类型修饰符,常类型是指使用类型修饰符const说明的类型,常类型的变量或对象的值是不能被更新的。1、定义常量(1)const修饰变量,以下两种定义形式在本质上是一样的。它的含义是:const修饰的类型...
  • 对于 const 修饰函数参数可以分为三种情况。 A:值传递的 const 修饰传递,一般这种情况不需要 const 修饰,因为函数会自动产生临时变量复制实参值。 #include<iostream> using namespace std; void ...
  • const是一个C语言的关键字,它限定一个变量不允许被改变。使用const在一定程度上可以提高程序的安全性和可靠性。 const Date* const this; 第一个const表示指向空间的内容不能修改,第二个const表示指针本身的内容...
  • const int func() { int j = 8; return j; } int main() {int i = 5 ;i = func(); } 为什么可以翻译通过呢?
  • 编译正确代码:#include#include #includeusing namespace std;class T{public:T(string p){...}const char & operator [](int pos) const{return ptext[pos];}string ptext;};int main(){string s = "abcd";T t...
  • const 更大的魅力是它可以修饰函数的参数、返回值,甚至函数的定义体。 const 是constant 的缩写,“恒定不变”的意思。被const 修饰的东西都受到强制保护,可以预防意外的变动,能提高程序的健壮性。所以很多C++...
  • 看到const 关键字,C++程序员首先想到的可能是const 常量。这可不是良好的条件反射。如果只知道用const 定义常量,那么相当于...const 更大的魅力是它可以修饰函数的参数、返回值,甚至函数的定义体。 constconst
  • C++ 笔记 const关键字修饰函数返回值

    千次阅读 2020-02-28 17:19:36
    const 位于返回类型前,表明返回对象为常量,不可改变。 如果修饰指向常量的指针。 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 ...
  • Java如何实现const

    千次阅读 2021-02-12 11:16:04
    展开全部const是constant的缩写,“恒定不变”的意思。被const修饰的东西都受到强制保护,可以预防意外的变动,能提62616964757a686964616fe59b9ee7ad9431333337396235高程序的健壮性和高效性。1 用const修饰函数的...
  • 函数返回值const 指针,可以使得外部在得到这个指针后,不能修改其指向的内容。返回值const 引用同理。 class CString { private: char* str; public: const char* c_str() const; }; const char* CString:...
  • C++中const用法总结

    2021-05-23 11:50:33
    1.1.1. 定义普通常量使用#define来定义常量也是常用方法,但const也可以用来定义常量,在[Effective C++]中建议使用const代替#define来定义常量,因为const定义的常量具有类型信息,而宏没有,所以使用const定义的...
  • const深度总结(effective C++)

    千次阅读 2017-09-19 11:44:15
    1. const常见应用基础   如果const关键字不涉及到指针,我们很好理解,下面是涉及到指针的情况: int b = 500; const int* a = &b; [1] int const *a = &b; [2] int* const
  • C++为了增强代码的可读性引入了运算符重载,运算符重载是具有特殊函数名的函数,也具有其返回值类型,函数名字以及参数列表,其返回值类型与参数列表与普通的函数类似。 函数名字:关键字operator后面接需要重载的...
  • c++ 函数的返回类型,包括const 什么时候起作用呢? 函数返回值不想其立即修改的。  例子如下,这是一个简单的避免产生隐形返回变量的方法,abc 的函数返回是引用,main函数中第10行,++ 操作是基于 const int &...
  • 如果给以“指针传递”方式的函数返回值const 修饰,那么函数返回值(即指针)的内容不能被修改,该返回值只能被赋给加const 修饰的同类型指针。 例如函数: const char * GetString(void); 正确的用法是 const...
  • 首先我们有下面两个函数, 一个返回引用一个返回值。 int temp; // 全局变量 float fn1(float r){ temp = ... .... return temp; } float &fn2(float r){ //&说明返回的是temp的引用,换句话说就是...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 378,798
精华内容 151,519
关键字:

const 返回值

友情链接: WinCE.rar