精华内容
下载资源
问答
  • 常对象需要引用常成员函数
    千次阅读
    2019-04-08 08:56:36

    1.常引用

    • 用const声明的引用就是常引用。常引用所引用的对象不能被更改。经常见到的是常引用作为函数的形参,这样不会发生对实参的误修改。常引用的声明形式为:const 类型说明符 &引用名。常引用作为函数形参的例子如下:
          #include "iostream"
      
          using namespace std;
      
      
          // 常引用作为函数形参,保证了不会对实参的值进行误修改,常引用的格式是: const 类型名 &引用名;
          void fun(const double &d);
      
      
          int main(){
              double d = 3.14;
              fun(d);
              return 0;
          }
      
          void fun(const double &d){
              // 常引用作形参,在函数中不能更新d所引用的对象
              double i = 6.66;
              // d = i;  此处将报错!!!
              cout << "d = " << d << endl;
          }
      
      

    2.常对象

    • 常对象是指数据成员在它的生存期内不会被改变。定义常对象时必须对其进行初始化,并且不能改变其数据成员的值。常对象的声明形式为:类名 const 对象名 或者 const 类名 对象名。常对象的例子如下:
          // 常对象
          class A{
              public:
                  A(int i, int j){
                      i = x;
                      j = y;
                  }
              private:
                  int x;
                  int y;
          };
          int main(){
              A const a(1, 2);  // 等价于const A a(1, 2);a是常对象,不能被更新!!!
              return 0;
          }
      
    • 如果程序中出现对常对象的数据成员试图进行修改的语句,编译器会报错。一般修改对象的数据成员有两种途径,一种是通过对象名访问公有数据成员并修改其值,而常对象的数据成员是不能被修改的;另一种是类的成员函数修改数据成员的值,而常对象不能调用普通的成员函数。可是这样的话,常对象就只剩数据,没有对外的接口了,这就需要为常对象专门定义的常成员函数了。

    3.类的常成员函数

    • 类中用const声明的成员函数就是常成员函数,常成员函数的声明形式为:类型说明符 函数名(参数表) const;。常成员函数需要注意的几点:
      • 常成员函数在声明和实现时都要带const关键字;
      • 常成员函数不能修改对象的数据成员,也不能访问类中没有用const声明的非常成员函数;
      • 常对象只能调用它的常成员函数,不能调用其他的普通成员函数;
      • const关键字可以被用于参与对重载函数的区分。比如,如果有两个这样声明的函数:void fun(); void fun() const;,则它们是重载函数。
    • 常成员函数实例如下:
          // 常成员函数
          class R{
              public:
                  R(int i1, int i2){
                      R1 = i1;
                      R2 = i2;
                  }
                  void Print();
                  void Print() const;   // 常成员函数
              private:
                  int R1;
                  int R2;
          };
      
          void R::Print(){
              cout << "R1 = " << R1 << " , R2 = " << R2 << endl;
          }
      
          void R::Print() const{
              cout << "R1 = " << R1 << " , R2 = " << R2 << endl;
          }
          
          int main(){
              R r(5, 4);
              r.Print();  // 调用的是普通成员函数void Print()
              R const rr(20, 45);  // rr是一个常对象
              rr.Print();  // 常对象只能调用常成员函数,所以此处调用的是void Print() const;
              return 0;
          }
      

    4.常数据成员

    • 类的数据成员也可以是常量和常引用,用const声明的数据成员就是常数据成员。在任何函数中都不能对常数据成员赋值。构造函数对常数据成员初始化,只能通过初始化列表。常数据成员实例如下:
          // 常数据成员
          class B{
              public:
                  B(int i);
                  void Print();
                  const int &r;   // 常引用r是对变量a的引用
              private:
                  const int a;   // 常数据成员
                  static const int b;  // 静态常数据成员,必须在类外进行初始化!!!
          };
          // 静态常数据成员初始化
          const int B::b = 330;
          // 类外进行构造函数定义
          B::B(int i): a(i), r(a){
              cout << "B的对象的构造函数\n";
          }
      
          void B::Print(){
              cout << "a = " << a << " , b = " << b << " , r = " << r << endl;
          }
      
      
          int main(){
              //建立对象b1和b2,并以50和550作为初值,分别调用构造函数,通过构造函数的初始化列表给对象的常数据成员赋初值
              B b1(50);
              B b2(550);
              b1.Print();
              b2.Print();
              return 0;
          }
      

    5.参考博客

    更多相关内容
  • c++常对象常成员函数详解

    千次阅读 2017-07-15 21:52:19
    常对象常对象是指该对象在其生命周期内,其所有的数据成员的值都不能被改变;定义对象时加上关键字const,该对象就是...1. 常对象只能调用常成员函数,不能调用普通成员函数 (除了隐式调用析构函数和构造函数),成员

    常对象

    常对象是指该对象在其生命周期内,其所有的数据成员的值都不能被改变;定义对象时加上关键字const,该对象就是常对象,其一般形式如下:

    类名 const 对象名[(实参类别)];
    或者
    const 类名 对象名[(实参类别)];

    形如:const CComplex num;

    需要特别说明的是:

    1. 常对象只能调用常成员函数,不能调用普通成员函数
    (除了隐式调用析构函数和构造函数),常成员函数是常对象的唯一对外接口;
    2. 现在编译系统只检查函数的声明,只要发现调用了常对象的成员函数,而且该函数未被声明为const,编译阶段就报错
    3. 常对象在被定义时需要被初始化;

    类设计源码:

    class CComplex
    {
    public:
        //普通构造函数
        CComplex(int nReal, int nImag):m_nReal(nReal),m_nImag(nImag)
        {
            cout << "common constructor function" << endl;
        }
        int GetRealNum()
        {
            return m_nReal;
        }
    private:
        int m_nReal;
        int m_nImag;
    };
    //常对象
    const CComplex num1(1,1);
    //error:不能将“this”指针从“const CComplex”转换为“CComplex &”
    int nReal = num1.GetRealNum();

    编译错误的原因是,目前该函数还是普通函数,它可能会修改成员变量;为了常对象能调用GetRealNum函数,应该将该函数设计成常成员函数;

    形如int GetRealNum() const;

    常数据成员

    如果我们希望在创建对象后,该对象的某个数据成员就保持不变,我们可以将这个数据成员设置为常数据成员;常数据成员只能通过构造函数初始化列表进行初始化,其他形式的函数均不能进行数据的赋值;

    常成员函数

    若将成员函数设置为常成员函数,则只能引用本类中的数据成员,而不能修改它;常成员函数可以引用const数据成员,也可以引用非const的数据成员;常成员函数的一般形式为:

    类型名 函数名(形参列表) const

    这里的const关键字是函数类型的一部分,在函数声明和函数定义时都要带const关键字,否则被编译器认为是不同的两个函数,但是在函数调用的时候不必带const;

    形如:

    //声明和定义一起实现
    int GetRealNum() const
    {
       return m_nReal;
    }

    函数API设计总结

    (1) 若我们定义了一个常对象,则指向这个常对象的指针变量或者对象引用也需要是const类型的;一般形式如下:

    const 类型名* 指针变量名;
    const 类型名& 引用名;

    (2)常对象的唯一对外接口是常成员函数;
    (3)为了节约时间开销和时间开销,一般将函数形参定义为指针或者引用类型;
    (4)若不希望传入的实参对象被修改,应该将形参定义指向常对象的指针变量或者引用;

    根据以上几点知识,我们进行类设计时,最好遵循以下两点结论:

    1.将不涉及数据成员修改的函数定义为常成员函数

    形如: int GetRealNum() const

    2.当发生函数调用时,希望传入的实参对象不被修改,应当将形参定义为const类型的指针或者引用;这个实参可以是const类型的,也可以是非const类型的,函数接口兼容性更加,形如:

    static void TransByPointer(const CComplex* obj)
    {
        cout << "TransByPointer \n" << endl;
    }
    
    static void TransByRefence(const CComplex& obj)
    {
        cout << "TransByRefence \n" << endl;
    }

    下面给出const相关知识的具体调用说明:

    数据成员非const的普通成员函数const成员函数
    非const的普通数据成员可以引用,也可以改变值可以引用,但不可以改变值
    const数据成员可以引用,但不可以改变值可以引用,但不可以改变值
    const对象不允许可以引用,但不可以改变值
    展开全文
  • 01 常量对象 如果不希望某个对象的值被改变,则定义该对象的时候可以在前面加const关键字 class CTest ...在类的成员函数后面可以加const关键字,则该成员函数成为常量成员函数。 在常量成...

    01 常量对象

    如果不希望某个对象的值被改变,则定义该对象的时候可以在前面加const关键字

    class CTest
    {
    public:
        void SetValue() {}
    private:
        int m_value;
    };
    
    const CTest obj; // 常量对象
    

    02 常量成员函数

    在类的成员函数后面可以加const关键字,则该成员函数成为常量成员函数。

    • 在常量成员函数中不能修改成员变量的值(静态成员变量除外);
    • 也不能调用同类的 非 常量成员函数(静态成员函数除外)
    class Sample
    {
    public:
        void GetValue() const {} // 常量成员函数
        void func(){}
        int m_value;
    };
    
    void Sample::GetValue() const // 常量成员函数
    {
        value = 0; // 出错
        func();    // 出错
    }
    
    int main()
    {
        const Sample obj;
        obj.value = 100; // 出错,常量对象不可以被修改
        obj.func(); // 出错,常量对象上面不能执行 非 常量成员函数
        obj.GetValue // OK,常量对象上可以执行常量成员函数
        
        return 0;
    }
    

    03 常量成员函数的重载

    两个成员函数,名字和参数表都一样,但是一个是const,一个不是,那么是算是重载。

    class Sample
    {
    public:
        Sample() { m_value = 1; }
        int GetValue() const { return m_value; } // 常量成员函数
        int GetValue() { return 2*m_value; } // 普通成员函数
        int m_value;
    };
    
    int main()
    {
        const Sample obj1;
        std::cout << "常量成员函数 " << obj1.GetValue() << std::endl;
        
        Sample obj2;
        std::cout << "普通成员函数 " << obj2.GetValue() << std::endl;
    }
    

    执行结果:

    常量成员函数 1
    普通成员函数 2
    

    04 常引用

    引用前面可以加const关键字,成为常引用。不能通过常引用,修改其引用的变量的。

    const int & r = n;
    r = 5; // error
    n = 4; // ok!
    

    对象作为函数的参数时,生产该对象参数是需要调用复制构造函数的,这样效率就比较低。用指针作为参数,代码又不好看,如何解决呢?

    可以用对象的引用作为参数,防止引发复制构造函数,如:

    class Sample
    {
        ...  
    };
    
    void Func(Sample & o) // 对象的引用作为参数
    {
        ...
    }
    

    但是有个问题,对象引用作为函数的参数有一定的风险性,若函数中不小心修改了形参0,则实参也会跟着变,这可能不是我们想要的,如何避免呢?

    可以用对象的常引用作为参数,如:

    class Sample
    {
        ...  
    };
    
    void Func(const Sample & o) // 对象的常引用作为参数
    {
        ...
    }
    

    这样函数中就能确保不会出现无意中更改o值的语句了。

    展开全文
  • C++类成员函数返回对象及返回引用

    千次阅读 2021-11-22 15:54:40
    C++类函数返回类的对象及类的引用一、代码例题二、返回引用三、返回对象 一、代码例题 #include <iostream> using namespace std; class machine; ostream& operator<<(ostream& o,const ...

    C++类函数返回类的对象及类的引用


    一、代码例题

    #include <iostream>
    using namespace std;
    
    class machine;
    ostream& operator<<(ostream& o,const machine& m);
    class machine
    {
    private:
        int num;
    public:
        machine(){
            num = 0;
        }
        machine fun1() //返回类的对象
        {
            num++;
            return *this;
        }
        machine& fun2() //返回类的引用 
        {
            return *this;
        }
        friend ostream& operator<<(ostream& o,const machine& m);
    };
    
    ostream& operator<<(ostream& o,const machine& m)
    {
        o<<m.num;
        return o;
    };
    
    
    int main(int argc, char **argv)
    {
       machine  m;
       m.fun1();
       cout<<m<<endl;
    
       m.fun2();
       cout<<m<<endl;
    
       m.fun1().fun1();
       cout<<m<<endl;
    
       m.fun2().fun2();
       cout<<m<<endl;
    
       m.fun1().fun2();
       cout<<m<<endl;
    
       m.fun2().fun1();
       cout<<m<<endl;
    }
    

    输出结果为 :

    	1 
    	1
    	2
    	2
    	3
    	4
    

    二、返回引用

    返回引用是返回一个地址,且指向该类的引用可以直接调用成员函数来修改成员变量,如上面的fun2()函数,即返回该对象的引用,因此可以通过m.fun2().fun1()来修改m的成员变量。
    另外尽量不要返回局部对象的地址,因为当函数调用完成后,局部对象会被销毁,此时返回的地址不存在,进而导致后续产生错误。

    三、返回对象

    返回对象则是通过调用默认复制构造函数,来在另一地址重新生成了另一个对象,因此,上面程序想通过调用m.fun1().fun1()来修改两次m的成员变量,但在调用一次m.fun1()之后,m.fun1()所表示的则是通过调用复制构造函数来生成的新的对象,因此,第二次调用fun1()的时候,是针对新复制生成的对象而言得了。

    展开全文
  • 常引用 形式—— const 类型 &对象名或变量名 ②常对象 ...3.常对象可以调用静态成员函数常成员函数,其实也可以调友元函数 (但是这里不对每一个具体展开了,就只是为了更加明白常对象是不
  • 在基本数据类型中有常量,类比到类类型中就是常对象,其实常量也是常对象常对象的声明方式:const类名 对象名;。常对象的数据成员不能被改变,...但是普通对象也可以访问常成员函数,在访问过程中,普通对象会被视
  • 可知C++成员函数不占用对象的存储空间,而是在对象外的空间,而且所有对象共用一段成员函数代码,那在不同对象成员函数如何保证引用指定对象的数据成员呢? 关键秘籍——this指针 &nbsp; &nbsp; 每个成员...
  • 我们发现,在C++中,有些成员函数返回的是对象,而有些函数返回的又是引用。 返回对象和返回引用的最主要的区别就是函数原型和函数头。 Car run(const Car &amp;) //返回对象 Car &amp; run(const...
  • C++ 常函数常对象

    千次阅读 2020-02-12 14:33:20
    常对象(包括指针和常引用) 使用关键字mutable 总结 常函数不能对普通成员变量(除mutable修饰外)进行写操作 常函数可以被普通对象或者常对象调用 常对象不能调用所有普通函数 常对象只能调用常函数 ...
  • 常量对象、常量成员函数常引用

    千次阅读 2017-03-01 22:04:38
    本章内容均为coursera中C++程序设计课件的整理 常量对象 如果不希望某个对象的值被改变,则定义该对象的时候可以在前面加const关键字。 class Demo{ private : ...在类的成员函数说明后面可以加const关键
  • 引发原因: 由调用成员函数时隐式传入的当前对象的this指针引起。 1、 非const成员函数中的隐式参数:classA* this 2、 const成员函数中的隐式参数:const classA* this 根本原因: 1、 const对象的指针为const ...
  • 不能通过常对象调用普通成员函数,但是可以通过普通对象调用常成员函数常对象只能调用常成员函数常对象的声明如下: const   const  两种声明完全一样没有任何区别。 1、通过下面例子来理解常对象: A、请...
  • 1)const对象可以调用非const成员函数吗? 答:不能。const修饰的对象实则修饰的是该对象的this指针,并且const修饰的成员不能进行修改,如果使用const调用非const成员函数,可能会将const对象进行修改。 2)非...
  • C++中的常对象常对象成员

    千次阅读 2013-09-05 23:53:00
    常对象中的数据成员变量且必须要有初始值,如 Time const t1(12,34,36); //定义t1为常对象 这样的话,在所有的场合中,对象t1中的所有数据成员的值都不能被修改。凡希望保证数据成员不被改变的对象,可以声明...
  • C++常函数的用法详解

    千次阅读 2019-06-05 21:44:17
    常成员函数
  • const对象只能调用const成员函数

    千次阅读 2019-07-13 22:38:52
    常量成员函数 (const member ...const对象是不可以调用类中的非const成员函数。原因之后解释。 假设现在有如下代码: class test{  int i; public:  void print();  test(int i); }; test obj1(12); obj1.p...
  • c++ 常成员函数常对象

    千次阅读 2018-06-03 15:55:01
    常对象只能调用常成员函数。2. 普通对象可以调用全部成员函数。3. 当对一个对象调用成员函数时,编译程序先将对象的地址赋给this指针,然后调用成员函数,每次成员函数存取数据成员时,由隐含使用this指针。4. 当一...
  • 用const修饰的声明数据成员称为数据成员用const修饰的声明成员函数称为常成员函数用const修饰的定义对象称为常对象变量或对象被const修饰后其值不能被更新。因此被const修饰的变量或对象必须要进行初始化。(一)...
  • **1,常对象** 在定义对象时加关键字...//等价说明:(1)如果一个对象被声明为常对象,则通过该对象只能调用它的常成员函数,而不能调用该对象的普通成员函数(出了由系统自动调用的隐式的构造函数和析构函数)。
  • 常成员函数,它的形式是在成员函数后面加上const修饰,它是为了防止特定函数改变本类对象的数据成员而产生的,目的就是保护数据成员。在常成员函数中,你不能改变数据成员的值,你也不能在常成员函数中调用非常量...
  • C++类成员函数指针使用介绍

    万次阅读 多人点赞 2019-09-21 16:07:49
    在之前写过的博客中有介绍过函数指针和指针函数的区别和简单用法(文章在这里),当时的Demo非常简单,都是C语言的写法,但是当在C++中直接像C那样使用类成员函数指针时就会报错:reference to non-static member ...
  • 数据成员、常成员函数

    千次阅读 2020-05-16 15:40:34
    2、常对象,不能访问非常成员函数。 3、常对象,不能被更新。 4、数据成员,只能通过初始化列表来获得初值。 什么时候用常对象? 1、函数返回值,2、函数形参(常引用常成员函数 1、常成员函数,不能修改(更新...
  • c++返回函数局部对象引用

    千次阅读 2015-05-25 14:58:15
    函数千万不要返回局部对象引用或指针  局部变量在函数里面,当函数执行结束后将释放局部变量,如果返回引用或批针这个时候引用或指针指向所指向的内存空间已经释放。指针和引用将是垂悬指针。很危险! 但是如果...
  • 先看段程序: # include ...2、在子类外部,子类对象按照继承方式重新给父类成员函数赋予访问权限(上面是 public 继承),此时只有重新赋予的访问权限是 public 时,子类对象在类外部才能调用。
  • c++函数返回引用,并赋值给引用对象

    千次阅读 2020-06-23 14:45:04
    函数返回引用时,返回值不需要另外申请临时对象,直接返回引用本身,大大节省了程序执行效率. 但是函数返回引用后,直接赋值给引用对象和非引用对象也是很重要的一点,直接看下面例子: #include <iostream> #...
  • c++ 非静态成员引用必须与特定对象相对

    万次阅读 多人点赞 2019-08-07 14:39:51
    小白我在使用C++类成员时,遇到错误显示:非静态成员引用必须与特定对象相对 代码片段为: struct TreeNode { int val; TreeNode *left; TreeNode *right; TreeNode(int x) : val(x), left(NULL), right(NULL) {...
  • C++中对象常引用

    千次阅读 2013-09-06 12:35:01
    直接传递对象名 形参为对象引用 形参为对象常引用
  • 因为类的普通成员函数不能作为回调函数,所以我们经常将类中的回调函数设置为 静态成员函数。但是在静态成员函数中调用非静态成员函数也会报标题错误,对于这种场景,我们有两种解决方法: 将调用的非静
  • 函数参数有直接变量(如int、char、double等)类型、指针类型和引用类型。 如果参数是变量,传递方式是传值,就是将实参的值复制(复制,意味着空间消耗和时间消耗)到“栈”空间中。 如果参数是指针,传递方式是传址,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 440,232
精华内容 176,092
热门标签
关键字:

常对象需要引用常成员函数

友情链接: ImageBrowserEx.rar