精华内容
下载资源
问答
  • 【C++】 对象、常数据成员常成员函数总结

    千次阅读 多人点赞 2019-03-24 15:07:25
     ◆ 常数据成员不能在声明时赋初始值(普通数据成员也是),数据成员必须在构造函数初始化列表进行初始化;普通数据成员在初始化列表和函数体中初始化均可。  ◆ PS:类的成员对象若要传入参数初始化,则必须在...
    常数据成员

     ◆ 常数据成员必须进行初始化,并且不能被更新。

     ◆ 常数据成员不能在声明时赋初始值(普通数据成员也是),常数据成员必须在构造函数初始化列表进行初始化;普通数据成员在初始化列表和函数体中初始化均可。

     ◆ PS:类的成员对象若要传入参数初始化,则必须在构造函数初始化列表进行;(成员对象:当一个类的成员是另一个类的对象时,这个对象就叫成员对象。)

    常对象

     ◆ ⭐常对象可以调用常成员函数,不能调用非const成员函数;非const对象,可以调用普通成员函数和常成员函数。

     ◆ 常对象的成员函数不一定都是常成员函数;同样的常对象的数据成员不一定都是常数据成员。

     ◆ 常对象一旦初始化,常对象的数据成员便不允许修改,而不是说常对象的数据成员都是常数据成员。

     ◆ PS:定义常对象有两种方法,1. Point const a; 2. const Point a;(同样的,定义变量或指针时,const放前放后意义一样,如:1. const double a; double const a; 2. const int *p; int const *p; 但是定义指针常量时,只能用 int * const p;)

    常成员函数

     ◆ 常成员函数不更新对象的数据成员。

     ◆ 常成员函数的const关键字可以被用于参与对重载函数的区分。

     ◆ ⭐通常非const成员函数需要定义一个const版本的重载函数,以方便定义常对象后调用常成员函数。
      ◈ 如果常对象调用的常成员函数返回的是指向当前对象的指针(或返回的是当前对象),那么此常成员函数的声明的返回类型要加const,例如:

        ◊ 成员函数返回指向当前对象的指针
          const *Point fun1();    //非const成员函数的类内声明;
          const *Point fun1() const; //习惯上要再声明一个常成员函数作重载函数,注意到此函数声明有两个const;

        ◊ 成员函数返回指向当前对象
          const Point fun1();    //非const成员函数的类内声明;
          const Point fun1() const; //习惯上要再声明一个常成员函数作重载函数,注意到此函数声明有两个const;

        ◊ ⭐注意,如果一个类中声明以下4个重载函数:
          ① Point fun1();
          ② const Point fun1();
          ③ Point fun1() const;
          ④ const Point fun1() const;
         【解析】①和②是冲突的,因为无法区分仅按返回类型区分的重载函数;③和④是冲突的,也是因为无法区分仅按返回类型区分的重载函数。
         所以正确的重载函数搭配有3种:

          ◊ ①和③搭配:
            Point fun1();             //函数返回非const对象
            Point fun1() const;          //函数返回非const对象
           [解析]适用于定义常对象后调用常成员函数,常成员函数返回类型是非const的Point类对象。

          ◊ ①和④搭配(这里把返回类型改为指针,因为常用):
            Point *fun1() {return this; };      //函数返回指向本对象的指针
            const Point *fun1() const { return this; };//函数返回指向本常对象的指针,第一个const说明返回的是指向常对象的指针,第二个const说明此函数是常函数

           [解析]适用于定义常对象后调用常成员函数,常成员函数返回类型是常Point类对象(如return *this;)。

          ◊ ②和④搭配:
            const Point fun1();          //函数返回常对象
            const Point fun1() const;       //函数返回常对象
           [解析]适用于定义常对象后调用常成员函数,常成员函数返回类型是常Point类对象。

           ②和③搭配:
            const Point fun1();
            Point fun1() const;
           [解析]虽然搭配合法,但是似乎不存在这种搭配。

    展开全文
  • 定义常数据成员: 类型 const 对象名;或者 const 类型 对象名; 例如:const clock c1(9,9,9)或者: ...1、常成员函数不能修改(更新)对象数据成员的值。 2、常成员函数不能调用该类中没有用con

    定义常数据成员:
    类型 const 对象名;或者 const 类型 对象名;
    例如:const clock c1(9,9,9)或者:
    clock const c2(10,10,10);

    常对象的几条特殊规则:
    1、常对象,不能被赋值。
    2、常对象,不能访问非常成员函数。
    3、常对象,不能被更新。
    4、常数据成员,只能通过初始化列表来获得初值。

    什么时候用常对象?
    1、函数返回值,2、函数形参(常引用)

    常成员函数
    1、常成员函数,不能修改(更新)对象数据成员的值。
    2、常成员函数,不能调用该类中没有用const修饰的成员函数。
    3、常对象,只能调用它的常成员函数,而不能调用其他成员函数。
    3、const关键字可以用于参与重载函数的区分。

    如何定义常成员函数?
    返回类型 成员函数名(参数表) const;

    综合例题:

    class date{
       privateint y,m,d;
       public:
           int year() const;
           int day() const;{return d;}
           int  month() const;
           int day(){return d++;}
           int addyear(int i)
           {return y+i;}
           };
    
    int date::month(){return m;}
    //错误,常成员函数实现不能缺少const
    int date::year()const{return y++}
    //错误:常成员函数不能更新类的数据成员
    date const d1;
    int j=d1.year;
    //正确,常对象可以调用常成员函数
    int j=d1.addyear(10);
    //错误,常对象不能调用非常成员函数
    date d2;
    int i=d2.year();
    //正确,非常对象可以调用常成员函数。
    d2.year()
    //正确,非常对象可以调用非常成员函数。
    展开全文
  • 先明确几个概念: 1. 对象只能调用常成员函数。 2. 普通对象可以调用全部成员函数。...在X类的const成员函数中,this指针的类型为:const X* const, 这说明this指针所指向的这种对象是修改的(即不能对这种
  • C++ 常数据成员常成员函数对象

    千次阅读 多人点赞 2019-01-04 23:54:51
    首先给出一个例子简单理解const修饰数据变量的基本工作原理: #include <stdio.h> int main() { const int a = 250; int *ptr = (int *)&a; *ptr = 360; printf("*ptr = %d\n&...

    首先给出一个例子简单理解const修饰数据变量的基本工作原理:

    #include <stdio.h>
    
    int main()
    {
    	const int a = 250;
    	int *ptr = (int *)&a;
    	*ptr = 360;
    	printf("*ptr = %d\n",*ptr); 
    	printf("ptr = %p\n",ptr); 
    	printf("a = %d\n",a);
    	printf("&a = %p\n",&a);
    	return 0;
    } 

    运行结果:

    从运行结果来看,显然我们队地址所指向内存的数据的修改并没有作用到a身上,这也就从另外一方面直接表明了对a的访问不是通过访问内存的方式。

    那么这里const对int a的修饰可以理解为#define a 250 ,但是使用const还可以保存相应的数据类型信息(a++==251)

     

    接下来主要讲到const对C++中类的成员以及对象的修饰:

    ************************************************************************************************************************************

     

    一:常数据成员

    1. 首先我们定义一个Point类:

    class Point
    {
    private:
    	int x, y;
    	const int e;
    	static int count;
    public:
    	Point(int xx, int yy,int ee):e(ee),x(xx),y(yy)
    	{
    		count++;
    	}
    	void Show_C()
    	{
    		cout << "C = " << c << endl;
    		//cout << "D = " << d << endl;  //这里就已经没有访问权限了
    	}
    	static int Show_Count()
    	{
    		return count;
    	}
    	int c = 250;
    	const int d = 360;    //可以直接在声明的时候赋值
    };

    ① 我们可以在定义const变量的时候直接对其进行赋值,赋值过后便无法再对它进行各种"计算"操作;

    ② 如果不在定义的时候赋值,那就需要在该类的构造函数中使用初始化列表进行赋值(初始化):

      

    在类的一般函数成员中依然可以访问const类型的数据成员。

    那常成员函数有什么用呢?

     

     

    二:常成员函数

    ① 首先,常成员函数内部不允许进行数据成员的修改,但是可以在函数内部输出const数据成员与非数据成员!

    ② 其次,还可以区分同名构造函数,举个例子(如下):

    #include <iostream>
    using namespace std;
    
    class Test
    {
    public:
    	void Show()const
    	{
    		cout << "Hello,Const!" << endl;
    	}
    	void Show()
    	{
    		cout << "Hello!" << endl;
    	}
    };
    
    int main()
    {
    	Test t1;
    	t1.Show();
    	Test const t2;
    	t2.Show();
    	return 0;
    }

     

     

    三:常对象

    在类的实例化同时,加上const进行修饰实例化出的对象即可:

    const修饰对象,直接限制了对象对其内部非const成员的访问,也就是说如果类中的数据成员与函数成员都没有被const修饰,

    那么实例化出的对象将无法对类进行操作;

    当然,const对象是可以直接操作const成员的(数据成员、函数成员),所以这就需要我们把成员函数声明为const型;

    #include <iostream>
    using namespace std;
    
    class Point
    {
    private:
    	int x, y;
    	const int e;
    	static int count;
    public:
    	Point(int xx, int yy,int ee):e(ee),x(xx),y(yy)
    	{
    		count++;
    	}
    	void Show_C()const   //常函数内部无法对数据进行修改
    	{
    		cout << "C = " << c << endl;
    		cout << "D = " << d << endl;
    	}
    	static int Show_Count()
    	{
    		return count;
    	}
    	int c = 250;
    	const int d = 360;    //可以直接在声明的时候赋值
    };
    
    int Point::count = 0;
    
    int main()
    {
    
    	Point const P1(1, 2, 3);    //这里的const直接限制了在外部对类中public中数据成员的修改
    
    	cout << P1.d << endl;    //const int d = 360;
    
    	P1.Show_C();
    
    	return 0;
    }

     

     

     

     

     

     

     

     

     

    展开全文
  • 1.对象的数据成员不能修改了,在定义的时候应该对其进行初始化 2.对象不能够调用普通成员函数——因为普通成员函数可能会修改对象的数据类型,这是不安全的。 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.除外。


    展开全文
  • C++类的常数据成员常成员函数

    千次阅读 2019-03-11 11:01:07
    不能采用在构造函数中对常数据成员进行赋初值的方法,因为常数据成员不能被赋值的。 构造函数只能用参数初始化列表对常数据成员进行初始化 Time ::Time (int h):hour(h){}//通过参数初始化表对常数据成员进行...
  • 静态数据成员和静态成员函数

    万次阅读 多人点赞 2018-08-26 19:18:35
    c++中的static静态数据成员和静态成员函数应该是让大家比较头疼的东西,好像也是找工作公司面试中常常问到的东西。我自己也深有体会,在学习c++的过程中,总感觉static很烦人,但是又是一个必须懂的东西,所以今天就...
  • 将const修饰的类成员函数称之为const成员函数,const修饰类成员函数,实际修饰该成员函数隐含的this指针,作用是在该成员函数不能对类的任何成员进行修改。 格式: 类型说明符 函数名(参数表)const; 例如:...
  • 常数据成员 常数据成员的初始化只能...常成员函数不可以调用普通函数,也不能改写对象数据 某个成员变量在const对象中可以被修改有两种方式 将const指针转化为非cosnt以修改非常成员数据 void MINO::display(void)
  • **************************数据成员的初始化 *******************************************************************************************************************1、数据成员是否在定义类的时候就初始化?...
  • 【C++】示例:常成员函数

    千次阅读 2019-09-11 20:26:43
    示例:常成员函数 #include<iostream> #include<stdio.h> #include<string.h> using namespace std; class MP3Player{ //“MP3播放器”类 char *type; //型号 char *color; //颜色 pub....
  • 如果一个成员函数不对对象的任何成员数据的进行修改(最常见的为打印成员信息的函数),那么我们可以将这个成员函数设置为const函数,以保护对象数据。如果在该函数里面修改对象的成员数据,则编译器就会报错。 3 ...
  • 静态数据成员和静态数据成员函数

    千次阅读 多人点赞 2016-12-27 15:25:29
    c++中的static静态数据成员和静态成员函数应该是让大家比较头疼的东西,好像也是找工作公司面试中常常问到的东西。我自己也深有体会,在学习c++的过程中,总感觉static很烦人,但是又是一个必须懂的东西,所以今天就...
  • mutable关键字的意思是可变的,可以在需要更改的数据的成员的前方使用该关键字进行修饰,就可以实现在const修饰的成员函数修改数据成员了。 如: class Screen { public: void TestFun() const;...
  • 遇到一个问题是:在类中有一个数据成员,是public的,在类的成员函数中进行修改,这个类的成员函数可能是要调用多次,想知道是不是每一次调用都有效 写了一个测试函数: #include <iostream> #include "cv...
  • 常成员函数,它就是在成员函数后面加一个const,用来修饰this指针所指的对象,使this指针所指的对象更改,保护它的数据安全。当常成员函数没有参数的时候修饰的是this指针,有参数的时候参数受影响,还是修饰...
  • c++对象和常成员函数详解

    千次阅读 2017-07-15 21:52:19
    对象对象是指该对象在其生命周期内,其所有的数据成员的值都不能被改变;定义对象时加上关键字const,该对象就是对象,其一般形式如下:类名 const 对象名[(实参类别)]; 或者 const 类名 对象名[(实参类别)...
  • 一般地,线程要读写类的私有成员变量,只有两种方法:将全局函数声明为类友元friend,或者使用静态的成员函数static。...本例就是自己的研究成果,使用非静态的成员函数作为线程函数,还能修改类的非静态的数据成员
  • 常成员函数的对象只是只读访问,允许修改对象的成员变量,所以不能调用非常成员函数,因为,这些成员函数可能修改成员变量。 而普通成员函数当然可以调用常成员函数 class people  { private: char *...
  • 什么是类的静态成员 静态成员变量和全局变量都存储在全局/静态区,它们都是在程序编译时创建,直到编译结束才被收回.所以全局变量和静态成员变量的功能差不多,只是创建的方式不同,类的静态成员创建在类中,全局变量...
  • /*小记:对于const声明的对象,针对哪个变哪个变得问题,实际上就是const后的整体不变 e.g.: const int *A; 或 int const *A; //const修饰指向的对象,A可变,A指向的对象可变 int *const A; //const修饰指针...
  • 1. 在C++中只有被声明为const的成员函数才能被一个const类对象调用。如果要声明一个const类型的类成员函数,只需要在成员函数列表后加上关键字const, 例如: class Screen { public: char get() const; };在类体...
  • 引发原因: 由调用成员函数时隐式传入的当前对象的this指针引起。...1、 const对象的指针为const classA* this,因此传入非const成员函数时编译器报错(类型匹配,无法从const 指针转换为非const指针);但传入co...
  • 包含常数据成员的类不能使用默认构造函数。 在对象被创建以后,其常数据成员的 值允许被修改。 类的常成员函数声明格式如下: 函数类型 成员函数名(参数列表) const; 修饰符 const要加在函数说明
  •  对象成员 和 常成员函数      看如下实例:    定义一个坐标类:Coordinate            要想正确的初始化,必须通过初始化列表来初始化,因为两个数据成员 都是由 const 来修饰的,是常数据...
  • 常数据成员 引言:类存在的目的之一就是为了实现封装性,但是实际上经常使用公有函数接口去修改数据成员,为了保证类中可以有一些数据...引言:为了实现这样一种函数:对于其调用的数据成员只能读取,而不能修改。...
  • # include <iostream> using namespace std; class Time { public: Time(int h = 10, int m = 30, int s = 59):hour(h), minter(m), sex(s){}; //void out_value();... //常成员函数可以引用非...
  • 常数据成员常数据成员是指在类中定义的不能修改其值的一些数据成员,类似于我们以前学过的变量,虽然是变量,也有自己的地址,但是一经赋初值,便不能再被修改。 适用于类中定义一些初始化之后希望被修改的变量...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 392,156
精华内容 156,862
关键字:

常成员函数不能修改任何数据成员