精华内容
下载资源
问答
  • 常成员函数中,你不能改变数据成员的值,你也不能在常成员函数中调用非常量成员函数,因为你不确定你调用的那个非常量成员函数是否改变了数据成员的值,如果改变了,那就相当于在常成员函数里改变了数据成员,与...
    常成员函数,它的形式是在成员函数后面加上const修饰,它是为了防止特定函数改变本类对象的数据成员而产生的,目的就是保护数据成员。在常成员函数中,你不能改变数据成员的值,你也不能在常成员函数中调用非常量成员函数,因为你不确定你调用的那个非常量成员函数是否改变了数据成员的值,如果改变了,那就相当于在常成员函数里改变了数据成员,与本身的const修饰相违背。(这里说明一下,没有常全局函数之说,因为常函数的设计是为了保护数据成员的,所以只能用在可以封装成对象的结构里面。)
    对常成员函数的作用可谓是一目了然,很好理解,但是对返回值为常量的成员函数就不是那么好理解了。
    先谈谈返回值为常量的函数的形式吧,返回值为常量的函数分为返回值为常量的成员函数和返回值为常量的全局函数,两者形式相同,用法也相同,其形式就是在函数前加const修饰。有人可能会问,返回值为常量的函数是为了什么设计的,不是所有返回值都相当于是常量的吗?
    对一般的函数确实如此,但是对于重载的操作符就不一样了。请看如下代码:
    class constSample
    {
    public:
    	constSample()
    	{
    		m_data=-1;
    	}
    
    	constSample(int data)
    	{
    		m_data=data;
    	}
    
    	~constSample()
    	{
    		
    	}
    
    	int getData() const
    	{
    		return m_data;
    	}
    
    	constSample operator + (const constSample & lhs)
    	{
    		m_data+=lhs.m_data;
    
    		return *this;
    	}
    
    private:
    	int m_data;
    };
    这里我重载的+操作符返回值没有用const修饰,也就是返回值不为常量,那么下面的代码就成立了:
    int main()
    {
    	constSample sample1(3);
    	constSample sample2(3);
    	constSample sample3(5);
    
    	cout<<"运算前:"<<endl;
    	cout<<sample1.getData()<<" "<<sample2.getData()
    		<<" "<<sample3.getData()<<endl;
    
    	sample1+sample2=sample3;
    
    	cout<<"运算后:"<<endl;
    	cout<<sample1.getData()<<" "<<sample2.getData()
    		<<" "<<sample3.getData()<<endl;
    
    	return 0;
    }

    下面是运行结果:

    运算前:
    3 3 5
    运算后:
    6 3 5

    最后sample1的数据成员的值是6,而不是我们期待的5,这是因为+的优先级比=要高,所以先计算sample1+sample2的值,结果是保存到sample1里面,为5,然后进行赋值操作,将sample3的值赋给sample1,结果就是sample3的值。这里,我们看出来了+的结果被覆盖了,所以这么做毫无意义。
    试想,如果你在C++中用如下代码编译能通过吗:

    int main()
    {
         int a=1,b=2,c=3;
         a+b=c;
        
         cout<<a<<" "<<b<<" "<<c<<endl;
         return 0;
    }

    结果是显然的,赋值号左边的表达式必须是可修改的左值,而我们上面自己定义的类能编译通过,而且还能得到结果,就是因为我们的返回值没有加const修饰,当加上const修饰之后,+操作符返回的*this就相当于一个常量,自然不能放在赋值号左边,编译器就会提示错误了。
    总结一下,常成员函数的设计是为了保护数据成员,而返回值为常量的函数的设计是为了防止返回值作为左值时出现的不可预料的结果。这里说明一下,一般用const修饰返回值为对象本身(非引用和指针)的情况多用于二目操作符重载函数并产生新对象的时候。


    展开全文
  • 常成员函数

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

      1.如果将成员函数声明为常成员函数,则只能引用本类中的数据成员,而不能修改它们。例如:void get_time()const;//const的位置在函数和括号之后

       const是函数类型的一部分,在声明函数和定义函数的时候都要用const关键字,在调用时不必加const.常成员函数可以应用const数据成员,也可以应用非const的数据成员。const数据成员可以被const成员函数引用,也可以被非const成员函数引用。

     2.怎样引用常成员函数?

     (1).如果在一个类中,有些数据成员的值允许改变,另一些数据成员的值不允许改变,则可以将一部分数据成员声明为const,以保证其值不被改变。非const成员函数可以引用这部分数据成员,并可以修改非const数据成员。

     (2).如果要求所以的数据成员的值都不允许改变,这可以将所有的数据成员声明为const,或将对象声明为const(常对象),然后用const成员函数引用数据成员,这可以起到“双保险”的作用,切实保证了数据成员不被修改。

    (3).如果定义了一个常对象,只能调用const成员函数,而不能调用非const成员函数。

     

    展开全文
  • c++成员函数作用

    千次阅读 2018-06-27 16:54:38
    初学c++,尤其是从c语言转过来学习c++的人,比如我,刚开始始终没弄懂成员函数作用。比如下面的例子就很好的解释了成员函数作用。#include&lt;iostream&gt; using namespace std;//c++的命名空间 class ...

    初学c++,尤其是从c语言转过来学习c++的人,比如我,刚开始始终没弄懂成员函数的作用。比如下面的例子就很好的解释了成员函数的作用。


    #include<iostream>
    using namespace std;//c++的命名空间
    class circle
    {
    public:
    	double r;
    	double pi = 3.1415926;
    	double area = pi*r*r;
    };
    
    // 2010编译不通过 但是在2013编译器能编译通过
    int main()
    {
    	circle c1;
    	cout << "please input your r" << endl;
    	cin >> c1.r;
    
    	cout << c1.area << endl;	//乱码
    
    	system("pause");
    	return 0;
    }
    一看,没什么问题,但结果是个随机值。原因是刚开始  定义了一个类 c1;进行初始化,r和area 都是一个随机值。
    circle c1;

    随后输入 r; r已经得到了初始化,但是

    area = pi*r*r;  // 这句话并没有执行,所以,area 还是一个随机值。

    如果有成员函数,通过调用成员函数,就可以解决这样的问题。

    double getArea(double r)

    {

        area = pi*r*r;

        return area;  

    }



    展开全文
  • 类中的常成员函数的使用和定义

    千次阅读 2018-06-16 16:35:01
    如果只对对象进行读操作,则该成员函数可以设计成常成员函数。设计成常成员函数的好处是:让使用者一目了然地知道该成员函数不会改变对象的值。常成员函数的声明和定义在形式上必须一致,即在函数形参列表的右括号...

    如果只对对象进行读操作,则该成员函数可以设计成常成员函数。设计成常成员函数的好处是:让使用者一目了然地知道该成员函数不会改变对象的值

    常成员函数的声明和定义在形式上必须一致,即在函数形参列表的右括号后面加上const。

    //---------main.cpp------------  
    #include <iostream>  
      
    using namespace std;  
      
    class Date  
    {  
    public:  
        int year,month,day;  
    public:  
        void set(int y,int m ,int d)  
        {  
            year  = y;  
            month = m;  
            day   = d;  
        }  
        bool isLeapYeay()const;  
        void print()const;  
    };  
      
    bool Date::isLeapYeay()const  
    {  
        return (((year%4 == 0)&&(year%100 != 0))||(year%400 ==0));  
    }  
    inline void Date::print()const  
    {  
      
        std::cout<<year<<"/"<<month<<"/"<<day<<" is a leap year!"<<endl;  
    }  
      
    int main(int argc,char **argv)  
    {  
        //-----------------对象----------------  
        Date s;  
        s.set(2015,9,25);  
        if(s.isLeapYeay()) s.print();  
        else  
            std::cout<<s.year<<"/"<<s.month<<"/"<<s.day<<" is not a leap year!"<<endl;  
        return 0;  
    }  
    其中set成员函数因为要修改对象值,所以无法设计成const。这样,只有s.set(xxxx,xx,xx);的行为会改变对象的值,而s.isLeapYear()的操作肯定不会改变对象的值。否则编译不通过。
    展开全文
  • C++ 数据成员、常成员函数对象

    千次阅读 多人点赞 2019-01-04 23:54:51
    ① 首先,常成员函数内部不允许进行数据成员的修改,但是可以在函数内部输出const数据成员与非数据成员! ② 其次,还可以区分同名构造函数,举个例子(如下): #include using namespace std; class ...
  • 1. 对象只能调用常成员函数。 2. 普通对象可以调用全部成员函数。 3. 当对一个对象调用成员函数时,编译程序先将对象的地址赋给this指针,然后调用成员函数,每次成员函数存取数据成员时,由隐含使用this...
  • C# 成员变量和成员函数前加static的作用? 它们被称为成员变量和常成员函数,又称为类成员变量和类成员函数。 分别用来反映类的状态。 比如类成员变量可以用来统计类实例的数量,类成员函数 负责这种统计的动作。...
  • 怎样利用常成员函数

    千次阅读 2010-06-22 16:26:00
    (2) 如果要求所有的数据成员的值都不允许改变,则可以将所有的数据成员声明为const,或将对象声明为const(对象),然后用const成员函数引用数据成员,这样起到“双保险”的作用,切实保证了数据成员不被修改...
  • c++静态成员函数作用

    千次阅读 2019-06-18 14:08:22
    静态成员函数主要为了调用方便,不需要生成对象就能调用。 比如: class X { public: void MethodA(); static void MethodB(); } 此时MethodB可以直接调用,X::MethodB(); MethodA必须先生成类对象才能调用...
  • 在类外定义成员函数 成员函数可以在类体中直接定义。也可以在类体中只写成员函数的声明,而在类的外面进行函数定义。如: class Student { public : void display( ); //公用成员函数原型声明 private : int num...
  • Const 修饰成员函数作用

    千次阅读 2008-08-06 09:47:00
    Const 修饰成员函数作用.黑月亮 发表于 2005-8-7 16:50:00 const成员函数 任何不会修改数据成员的函数都应该声明为const类型。如果在编写const成员函数时,不慎修改了数据成员,或者调用了其它非const成员函数,...
  • 作用域与成员函数

    千次阅读 2012-04-18 14:04:39
    作用域与成员函数 在基类和派生类中使用同一名字的成员函数,其行为与数据成员一样:在派生类作用域中派生类成员将屏蔽基类成员。即使函数原型不同,基类成员也会被屏蔽。 class Base { public: int Get(){ ...
  • 和静态数据成员一样,静态成员函数是类的一部分,而不是对象的一部分。如果要在类外调用公用的静态成员函数,要...静态成员函数作用是为了能处理静态数据成员。 可以说,静态成员函数与非静态成员函数的根本区别是:
  • 对象与常成员函数的关系

    千次阅读 2008-09-18 21:13:00
    (1) 对象用const修饰的对象叫对象常量,其格式如下:〈类名〉const 〈对象名〉 或者 const 〈类名〉〈对象名〉声明为对象的同时必须被初始化,并从此不能改写对象的数据成员。例:分析下列错误的地方,说明...
  • 使用类作用域操作符进行成员函数调用问题
  • 普通成员函数和静态成员函数

    千次阅读 2018-03-25 19:47:25
    类成员包括数据成员和成员函数。 两者区别 1分配内存的时间不同 静态成员属于类本身,不属于具体类对象,在类加载时分配内存空间,程序结束时才消失。可以类名直接访问。 普通成员属于类对象,在类对象创建...
  • 静态数据成员和静态成员函数

    万次阅读 多人点赞 2018-08-26 19:18:35
    c++中的static静态数据成员和静态成员函数应该是让大家比较头疼的东西,好像也是找工作公司面试中常常问到的东西。我自己也深有体会,在学习c++的过程中,总感觉static很烦人,但是又是一个必须懂的东西,所以今天就...
  • Python:普通成员函数、类成员函数、静态函数 Python 中的类也是一个普通对象,如果需要直接使用这个类,例如将类作为参数传递到其他函数中,又希望在实例化这个类之前就能提供某些功能,那么最简单的办法就是使用 ...
  • 成员函数指针

    千次阅读 2018-09-29 20:38:02
      函数指针中的函数都是全局作用域内的函数,而成员函数指针指向的函数往往都是某个类的非静态成员函数。使用如下代码,编译器会报非法转换的错误。报这个错有俩个原因 首先类内的函数是在类作用域中的,而函数...
  • **************************数据成员的初始化 *******************************************************************************************************************1、数据成员是否能在定义类的时候就初始化?...
  • 类的成员函数(简称类函数)是函数的一种,它的用法和作用和前面介绍过的函数基本上是一样的,它也有返回值和函数类型,它与一般函数的区别只是:它是属于一个类的成员,出现在类体中。它可以被指定为private(私有的...
  • 成员函数可以访问本类中任何成员(包括私有的和公用的),可以引用在本作用域中有效的数据。 一般的做法是将需要被外界调用的成员函数指定为public,它们是类的对外接口。但应注意,并非要求把所有成员函数都指定为...
  • 深入理解c++成员函数

    千次阅读 2018-03-31 21:29:00
    1、const成员函数: 在成员函数后面加const,const修饰this指针所指向的对象,也就是保证调用这个const成员函数的对象在函数内不会被改变 思考以下几种场景 1. const对象可以调用非const成员函数和const成员函数...
  • 引发原因: 由调用成员函数时隐式传入的当前对象的this指针引起。 1、 非const成员函数中的隐式参数:classA* this 2、 const成员函数中的隐式参数:const classA* this 根本原因: 1、 const对象的指针为const ...
  • C++静态成员函数

    千次阅读 2019-05-01 17:17:30
    与静态数据成员不同,静态成员函数作用不是为了对象之间的沟通,而是为了能处理静态数据成员。 静态成员函数没有this指针。既然它没有指向某一对象,也就无法对一个对象中的非静态成员进行默认访问(即在引用数据...
  • 非静态成员函数后面的const作用

    千次阅读 2012-10-02 15:51:13
    看下面的代码和gcc给出的报错...非静态成员函数后面的const作用其实就是限定了函数内部不可改变数据成员的值。 #include using namespace std; class A{ int data; public: A(int da=100):data(da) {} void
  • 在类外部定义的成员函数必须指明他们是在类的作用域中,将关键字const添加到函数形参后面,就可以将成员函数声明为常量: class PPAP::double pen() const; const成员不能改变其所操作的对象的数据成员。const必须...
  • 成员函数:无论静态函数还是非静态函数,都是属于类的(这一点与数据成员的静态非静态不同),对象并不拥有函数的拷贝.两者的区别在于:非静态的函数由类对象(加.或指针加-&gt;;)调用,这时将向函数传递this指针.而静态...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 432,381
精华内容 172,952
关键字:

常成员函数的作用