精华内容
下载资源
问答
  • 修改常对象的数据成员
    千次阅读
    2020-12-07 15:24:37

    遇到一个问题是:在类中有一个数据成员,是public的,在类的成员函数中进行修改,这个类的成员函数可能是要调用多次,想知道是不是每一次调用都有效

    写了一个测试函数:

    #include <iostream>
    #include "cv.h"
    #include <vector>
    #include <string.h>
    #include <fstream>
    using namespace std;
    using namespace cv;
    class Detector{
         public:
            float first_white_pixel=0;
            int first_mark=1;
            int xiugaivules(){
                if (first_mark!=0)
                {
                    /* code for True */
                    xiugai2();
                    cout<<"B:first_mark"<<first_mark<<endl;
                }       
             }
            int xiugai2(){
                first_mark = first_mark +10;
            }
            Detector(){
               
                for(int i=0;i<10;i++){
                     xiugaivules();
                     cout<<i<<endl;            
                }                     
            }
            ~Detector(){
    
            }
    
    };
    int main()
    {
    	//写这个的目的是为了什么呢,是为了,测试类成员函数和类成员
            Detector detec;
    	cout<<"A:"<<detec.first_mark<<endl;
    	
    	return 0;
    }
     

    可能不规范,但是验证一条结论,就是成员函数每一次调用都是对类的数据变量进行了修改,且保留

    更多相关内容
  • 成员函数可以访问常对象中的数据成员,但仍然不允许修改常对象数据成员的值。有时在编程时有要求,一定要修改常对象成员中的某个数据成员的值(例如类中有一个用于计数的变量count,其值应当不能变化)
  • 【C++】 常对象常数据成员成员函数总结

    千次阅读 多人点赞 2019-03-24 15:07:25
    常数据成员  ◆ 常数据成员必须进行初始化,并且不能被更新。  ◆ 常数据成员不能在声明时赋初始值(普通数据成员也是),常数据成员必须在构造函数初始化列表进行初始化;普通数据成员在初始化列表和函数体中初始...
    常数据成员

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

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

     ◆ 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;
           [解析]虽然搭配合法,但是似乎不存在这种搭配。

    展开全文
  • C++ 常数据成员成员函数和常对象

    千次阅读 多人点赞 2019-01-04 23:54:51
    首先给出一个例子简单理解const修饰数据变量的基本工作原理: #include &lt;stdio.h&gt; int main() { const int a = 250; int *ptr = (int *)&amp;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;
    }

     

     

     

     

     

     

     

     

     

    展开全文
  • 数据成员 python的类数据成员是不需要用self修饰的。例如 class my_class(object): value_list=[1,2] class1=my_class() print(my_class.value_list) print(class1.value_list) print(id(my_class.value_list...

    类数据成员

    python的类数据成员是不需要用self修饰的。例如

    class my_class(object):
        value_list=[1,2]
        
    class1=my_class()
     
    print(my_class.value_list)
    print(class1.value_list)
    print(id(my_class.value_list))
    print(id(class1.value_list))

    通过上面的测试可以看出,定义的类my_class()中的数据成员为类成员可以通过类名和对象名调用,其中两种访问方式访问同一块内存区域的数据。
    注意:对于类成员我们要通过类名来访问,通过对象访问只是为了测试

    class my_class(object):
        value_list=[1,2]
        
    class1=my_class()
    class1.value_list=['i']
     
    print(my_class.value_list)
    print(class1.value_list)
    print(id(my_class.value_list))
    print(id(class1.value_list))

    经过对象class1通过赋值语句重新定义value_list变量后,对象class1中访问的value_list与类数据成员则保存在不同的内存区域中。这也是给对象动态定义数据成员的效果。

    对象数据成员

    通过初始化函数,经过self修饰的数据成员是与对象绑定的。每个对象都会分配自己的内存区域。

    class my_class(object):
        value_list=[1,2]
        def __init__(self):
            self.value=[]
        
    class1=my_class()
    class2=my_class()
    class1.value=['i']
    class2.value=[1,2]
     
    print(class1.value)
    print(class2.value)
    print(id(class1.value))
    print(id(class2.value))

    value数据成员是属于每个对象的,在类的初始化过程或者后续引用中修改,不会产生相互的干扰。
    类的数据成员可以在对象初始化后动态添加,不是必须在类模板中声明。
    猜想:对象定义与类数据成员同名的变量时,会给对象定义一个self修饰的对象数据成员
    声明:由于个人知识局限,所写的内容会存在错误,欢迎大家指出其中的问题,谢谢

    展开全文
  • 一旦声明可常对象那么常对象中的所有数据成员的值都不能被修改。所以希望保证数据成员的不被改变的对象,我们都可将其声明为常对象。 定义常对象的格式:类名 const 对象名(实参列表){}  或const 类名 对象名(实参...
  • C++中的常对象常对象成员

    千次阅读 2013-09-05 23:53:00
    常对象 ...这样的话,在所有的场合中,对象t1中的所有数据成员的值都不能被修改。凡希望保证数据成员不被改变的对象,可以声明为常对象。 定义常对象的一般形式为 类名 const 对象名(实参列表); 也可以把
  • c++常对象常成员函数详解

    千次阅读 2017-07-15 21:52:19
    常对象常对象是指该对象在其生命周期内,其所有的数据成员的值都不能被改变;定义对象时加上关键字const,该对象就是常对象,其一般形式如下:类名 const 对象名[(实参类别)]; 或者 const 类名 对象名[(实参类别)...
  • 引用所引用的对象不能被更改。经常见到的是引用作为函数的形参,这样不会发生对实参的误修改引用的声明形式为:const 类型说明符 &引用名。引用作为函数形参的例子如下: #include "iostream" using...
  • 2.对象不能够调用普通成员函数——因为普通成员函数可能会修改对象数据类型,这是不安全的。 3.对象可以调用静态成员函数,常成员函数,其实也可以调友元函数 (但是这里不对每一个具体展开了,就只是为了...
  • 共用数据的保护

    千次阅读 2022-03-10 21:19:52
    C++有不少措施保护数据的安全性,如private保护类的数据成员等。但对于一些共用的数据,如函数实参与形参等,我们可以在不同的场合通过不同的途径访问同一个数据对象。有时不经意的误操作会改变数据的值。 一、常对象...
  • 静态数据成员和静态成员函数

    万次阅读 多人点赞 2018-08-26 19:18:35
    c++中的static静态数据成员和静态成员函数应该是让大家比较头疼的东西,好像也是找工作公司面试中常常问到的东西。我自己也深有体会,在学习c++的过程中,总感觉static很烦人,但是又是一个必须懂的东西,所以今天就...
  • C++常对象及其成员

    千次阅读 2014-12-11 13:38:38
    C++虽然采取了不少有效的措施(如设private保护)以...既要使数据能在一定范围内共享,又要保证它不被任意修改,这时可以使用const,即把有关的数据定义为常量。 常对象 在定义对象时指定对象常对象常对象必须要有
  • **************************数据成员的初始化 *******************************************************************************************************************1、数据成员是否能在定义类的时候就初始化?...
  • C++类中的常数据成员和静态数据成员的区别

    千次阅读 多人点赞 2013-09-20 01:19:26
    刚开始学习C++的类和对象的部分,对类中的常数据成员和静态数据成员的概念和用法经常混淆,所以今天整理一下,顺便说一下,今天是我的生日,祝我生日快乐,呵呵。 常数据成员 常数据成员是指在类中定义的不能修改其...
  • 静态数据成员和静态函数成员(因为类的成员本身就分为两类,属性和行为,也就是数据和函数) 二:静态数据成员: 一:类中定义 二:类外初始化为什么要这样类外初始化呢?代码解释: #include<iostream> ...
  • 常数据成员成员函数

    千次阅读 2020-05-16 15:40:34
    定义数据成员: 类型 const 对象名;或者 const 类型 对象名; 例如:const clock c1(9,9,9)或者: ...1、成员函数,不能修改(更新)对象数据成员的值。 2、成员函数,不能调用该类中没有用con
  • 3、静态常成员变量(基本数据类型) 4、静态常成员变量(自定义数据类型) 二、常成员变量 C++中使用const关键字修饰的成员变量就是常成员变量,有两种定义方式: const int c; int const c; 需要注意的是:...
  • 众所周知,类的私有变量是无法在类外直接访问的,只能通过类的成员函数访问。 且看下面一段代码: class Stock { private: double total_val;//这是私有的哦~ public: Stock();//默认构造函数 Stock(const ...
  • 常对象说明:常对象是指对象数据成员的值在对象被调用时不能被改变。常对象必须进行初始化,且不能被更新。不能通过常对象调用普通成员函数,但是可以通过普通对象调用成员函数。常对象只能调用成员函数。...
  • 1. 在C++中只有被声明为const的成员函数才能被一个const类对象调用。如果要声明一个const类型的类成员函数,只需要在成员函数列表后加上关键字const, 例如: class Screen { public: char get() const; };在类体...
  • 一:对象:Time const t1...但如果一定要修改常对象数据成员的值,可以将该数据成员声明为mutable,如: mutable int count;//把count声明为可变的数据成员,这样就可以用生命为const的成员函数改变它的值。 二:
  • 静态成员函数访问非静态数据成员【C++】

    千次阅读 多人点赞 2021-05-11 10:33:56
    静态成员函数访问非静态数据...详解:静态数据成员必须在类外初始化,不可在类体内,因为:构造函数中,如果可以,则每次建立对象,都会对静态数据成员的值进行修改,这违背静态数据成员的使用目的;类内也不可以初始化
  • C++类的常数据成员成员函数

    千次阅读 2019-03-11 11:01:07
    一、常数据成员 1、定义 用const修饰的数据成员 const int hour;//定义const为常数据成员 2、初始化 不能采用在构造函数中对常数据成员进行赋初值的方法,因为常数据成员是不能被赋值的。 构造函数只能用...
  • 定义一个Circle类,有数据成员radius(半径),成员函数getArea(),计算圆的面积,构造一个Circle的对象进行测试。
  • 在定义对象时加关键字const,指定对象常对象常对象必须要有初值,定义后就不可修改。Time const t1(10, 20, 30);//定义t1是常对象 const Time t1(10, 20, 30);//等价说明:(1)如果一个对象被声明为常对象,则...
  • C++ 类中数据成员分布详解

    千次阅读 2018-12-22 23:39:13
    我们都知道类中包含着数据成员,但是数据成员在内存中是怎样分布的呢?继承之后数据又是怎样布局的呢?下面对这些问题进行整理。类的空间分布是编译器编译的结果,不同的编译器有可能会不一样,但是原理是一样的。 ...
  • 静态数据成员和静态数据成员函数

    千次阅读 多人点赞 2016-12-27 15:25:29
    c++中的static静态数据成员和静态成员函数应该是让大家比较头疼的东西,好像也是找工作公司面试中常常问到的东西。我自己也深有体会,在学习c++的过程中,总感觉static很烦人,但是又是一个必须懂的东西,所以今天就...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 472,035
精华内容 188,814
热门标签
关键字:

修改常对象的数据成员