精华内容
下载资源
问答
  • 常引用 形式—— const 类型 &对象名或变量名 ②常对象 ...3.常对象可以调用静态成员函数常成员函数,其实也可以调友元函数 (但是这里不对每一个具体展开了,就只是为了更加明白常对象是不

    ①常引用

    形式—— const 类型 &对象名或变量名

    ②常对象

    形式——const 类名 对象名

    1.常对象的数据成员不能被修改了,在定义的时候应该对其进行初始化

    2.常对象不能够调用普通成员函数——因为普通成员函数可能会修改对象的数据类型,这是不安全的。

    3.常对象可以调用静态成员函数,常成员函数,其实也可以调友元函数  (但是这里不对每一个具体展开了,就只是为了更加明白常对象是不能调用普通的成员函数的即可)

    ③常成员函数

    形式——返回值类型 方法名(参数表)

    1.常成员函数不能改变对象的值,也不能在函数体里面调非常成员函数。

    2.常对象可以调常成员函数和静态成员函数

    3.常成员函数实现的时候,函数头是应该和声明的函数头一致的,const也是函数类型的一个组成部分,而对于友元函数和静态成员函数是不用friend和static的

    4.非常对象也可以调用常成员函数,但是当常成员函数与非常成员函数同名的时候(可以视为函数重载),对于非常对象是会优先调用非常成员函数的。

    ④常数据成员

    形式——const 数据类型 变量名;

            (当同时还是静态数据成员的时候)static const 数据类型 变量名;

    1.常数据成员的初始化只能通过构造函数的列表来完成

    
    class CPoint
    {
    public:
    	CPoint(int xx, int yy,int zz);
    private:
    	int x,y;
    	const int z;
    };
    CPoint::CPoint(int xx, int yy, int zz) :z(zz)
    {
    	x = xx;
    	y = yy;
    	//z = zz;     这个是不被允许的,因为会报赋值号左侧必须是可修改的左值(可修改,有数据存储空间)
    }

    2.但是静态的常数据成员必须在类外进行初始化,不能在构造函数中进行,并且const不能省

    class CPoint
    {
    public:
    	CPoint(int xx, int yy,int zz);
    private:
    	int x,y;
    	static const int z;
    };
    const int z = 10;  //const不能省,也是类型的一部分
    3.如果类有多个重载构造函数,就应该在每一个重载构造函数的初始化列表中去初始化常数据成员,当然刚才说的2.除外。


    展开全文
  • 在基本数据类型中有常量,类比到类类型中就是常对象,其实常量也是常对象常对象的声明方式:const类名 对象名;。常对象的数据成员不能被改变,...但是普通对象也可以访问常成员函数,在访问过程中,普通对象会被视

    在基本数据类型中有常量,类比到类类型中就是常对象,其实常量也是常对象。

    常对象的声明方式:const类名 对象名;。常对象的数据成员不能被改变,而且不能访问普通的函数成员,那常对象有何用?这就提出了常函数成员。

    类的常函数成员的声明方式:类型说明符 函数名(形参)const;。常函数成员就是为常对象服务的,常对象只能访问常函数成员。但是普通对象也可以访问常成员函数,在访问过程中,普通对象会被视为常对象,在运行过程中,普通对象的数据成员也不会被改变。const 还能用来声明函数重载,当普通对象调用同名函数时,会选择最近的函数调用。

    常数据成员的声明方式:const类型说明符 变量名;。常数据成员的初始化在构造函数的初始化列表中进行。

    常引用的声明方式:const类型说明符 &变量名;。常引用也可做形参,常引用可以和常对象搭配,普通对象也可以和常引用搭配,在运行中,普通对象会被视为常对象,常引用做函数形参时和值传递很类似,但常引用有一个优点,在传递比较大的值时,用值传递耗时较长,而传递常引用可以显著提高效率。

    以上就是我对常对象,常成员函数,常数据成员和常引用的一些认识。

    展开全文
  • 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对象不允许可以引用,但不可以改变值
    展开全文
  • 常引用引用对象不能被更改。经常见到的是常引用作为函数的形参,这样不会发生对实参的误修改。常引用的声明形式为:const 类型说明符 &引用名。常引用作为函数形参的例子如下: #include "iostream" using...

    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++ 常成员函数常对象

    千次阅读 多人点赞 2014-06-17 13:30:17
    先明确几个概念: 1. 常对象只能调用常成员函数。 2. 普通对象可以调用全部成员函数
  • 常量对象、常量成员函数常引用

    千次阅读 2017-03-01 22:04:38
    本章内容均为coursera中C++程序设计课件的整理 常量对象 如果不希望某个对象的值被改变,则定义该对象的时候可以在前面加const关键字。 class Demo{ private : ...在类的成员函数说明后面可以加const关键
  • 不能通过常对象调用普通成员函数,但是可以通过普通对象调用常成员函数常对象只能调用常成员函数常对象的声明如下: const   const  两种声明完全一样没有任何区别。 1、通过下面例子来理解常对象: A、请...
  • C++成员函数返回对象引用

    千次阅读 2014-03-08 15:54:17
    但是在成员函数返回对该调用函数的对象引用时,会显示的使用this。 为什么要返回调用该函数的对象引用呢?C++ Primer 4里说用户希望能将几个操作连接成一个独立的表达式,例如下面: myScreen.move(4,0); ...
  • **1,常对象** 在定义对象时加关键字...//等价说明:(1)如果一个对象被声明为常对象,则通过该对象只能调用它的常成员函数,而不能调用该对象的普通成员函数(出了由系统自动调用的隐式的构造函数和析构函数)。
  • 用const修饰的声明数据成员称为数据成员用const修饰的声明成员函数称为常成员函数用const修饰的定义对象称为常对象变量或对象被const修饰后其值不能被更新。因此被const修饰的变量或对象必须要进行初始化。(一)...
  • · 用const修饰的声明成员函数称为常成员函数 · 用const修饰的定义对象称为常对象 变量或对象被const修饰后其值不能被更新。因此被const修饰的变量或对象必须要进行初始化。 (一)用const修饰的声明数据成员称为...
  • 我们发现,在C++中,有些成员函数返回的是对象,而有些函数返回的又是引用。 返回对象和返回引用的最主要的区别就是函数原型和函数头。 Car run(const Car &amp;) //返回对象 Car &amp; run(const...
  • 当我们定义的数据或对象不能改变时,我们就要将其声明为常量。主要有常引用常对象对象指针、常数组、指针等。 1、常引用 顾名思义。常引用引用对象不能更改。...常对象的数据成员在它的生存期内不会改变
  • 常对象常成员函数的关系

    千次阅读 2008-09-18 21:13:00
    (1) 常对象用const修饰的对象对象常量,其格式如下:〈类名〉const 〈对象名〉 或者 const 〈类名〉〈对象名〉声明为常对象的同时必须被初始化,并从此不能改写对象的数据成员。例:分析下列错误的地方,说明...
  • const类型参数的对象引用 在如下的类声明中: class C{ private: string name; public: C(){/*...*/} //default constructor C(int x){/*...*/} //convert constructor void setName(const string& n){name =...
  • C++中的常对象常对象成员

    千次阅读 2013-09-05 23:53:00
    常对象中的数据成员变量且必须要有初始值,如 Time const t1(12,34,36); //定义t1为常对象 这样的话,在所有的场合中,对象t1中的所有数据成员的值都不能被修改。凡希望保证数据成员不被改变的对象,可以声明...
  • 常成员函数,它的形式是在成员函数后面加上const修饰,它是为了防止特定函数改变本类对象的数据成员而产生的,目的就是保护数据成员。在常成员函数中,你不能改变数据成员的值,你也不能在常成员函数中调用非常量...
  • 引发原因: 由调用成员函数时隐式传入的当前对象的this指针引起。 1、 非const成员函数中的隐式参数:classA* this 2、 const成员函数中的隐式参数:const classA* this 根本原因: 1、 const对象的指针为const ...
  • C++只读成员函数、只读对象

    千次阅读 2017-07-09 22:47:38
    什么是只读成员函数? 只读成员是C++中结构体或类的成员函数,在函数括号... 只读成员函数存在的意义只有一个——为只读对象服务,后面会说到。先介绍一下只读成员函数的语法。class student //定义一个student类,有
  • //返回对象引用 #include using namespace std; class Base { public: Base():data(2){} ~Base(){} Base fun1() { cout; return *this; } Base& fun2() { cout<<"data
  • 静态成员函数引用非静态成员

    千次阅读 2013-08-27 09:25:04
    C++会区分两种类型的成员函数:静态成员函数和非静态成员函数。这两者之间的一个重大区别是,静态成员函数不接受隐含的this自变量。所以,它就无法访问自己类的非静态成员。       ...
  • c++返回函数局部对象引用

    千次阅读 2015-05-25 14:58:15
    函数千万不要返回局部对象引用或指针  局部变量在函数里面,当函数执行结束后将释放局部变量,如果返回引用或批针这个时候引用或指针指向所指向的内存空间已经释放。指针和引用将是垂悬指针。很危险! 但是如果...
  • 常成员函数

    千次阅读 2009-07-23 10:52:00
    1.如果将成员函数声明为常成员函数,则只能引用本类中的数据成员,而不能修改它们。例如:void get_time()const;//const的位置在函数和括号之后  const是函数类型的一部分,在声明函数和定义函数的时候都要用const...
  • C++常对象及其成员

    千次阅读 2014-12-11 13:38:38
    C++虽然采取了不少有效的措施(如设private保护)以增加数据的安全性,但是有些数据却往往是共享的,人们可以在不同的场合通过不同的途径访问同一个数据对象。...在定义对象时指定对象常对象常对象必须要有
  • C++中对象常引用

    千次阅读 2013-09-06 12:35:01
    直接传递对象名 形参为对象引用 形参为对象常引用
  • 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...
  • 常量对象与常量成员函数

    万次阅读 2012-03-01 23:53:59
    常量对象与常量成员函数 常量对象与常量成员函数来防止修改对象,实现最低权限原则。 可以用关键字const来指定对象是不可修改的,任何修改该对象的企图,都会导致编译错误。 例如:const Time noon(12,0,0); ...
  • C++类的数据成员和常成员函数

    千次阅读 2019-03-11 11:01:07
    一、数据成员 1、定义 用const修饰的数据成员 const int hour;//定义const为数据成员 ...不能采用在构造函数中对数据成员进行赋初值的方法,因为数据成员是不能被赋值的。...普通成员函数...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 395,316
精华内容 158,126
关键字:

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