精华内容
下载资源
问答
  • #include<iostream> #include<iomanip> using namespace std; class R{ public: R(int r1, int r2):r1(r1),r2(r2){ } void print();... //成员函数 private: in...
    #include<iostream>
    #include<iomanip>
    
    using namespace std;
    
    class R{
    public:
        R(int r1, int r2):r1(r1),r2(r2){
    
        }
        void print();
        void print() const; //常成员函数 
    
    private:
        int r1,r2;
    };
    
    void R::print()
    {
    cout << r1 << ","<< r2<<endl;
    }
    void R::print() const //常成员函数的实现 
    {
    cout << r1<<"," <<  r2<<endl;
    }
    int main(){
    R a(5,4);
    a.print();
    R const b(3,4); // 是常对象,不能被更新 
    b.print();//调用常成员函数 
    return 0;
    } 
    
    展开全文
  • 常对象常对象必须在定义对象时就指定对象为常对象。常对象中的数据成员为常变量且必须要有初始值,如Time const t1(12,34,36);...定义常对象的一般形式为类名 const 对象名(实参列表);也可以把const写在最左面const...

    常对象

    常对象必须在定义对象时就指定对象为常对象。

    常对象中的数据成员为常变量且必须要有初始值,如

    Time const t1(12,34,36); //定义t1为常对象

    这样的话,在所有的场合中,对象t1中的所有数据成员的值都不能被修改。凡希望保证数据成员不被改变的对象,可以声明为常对象。

    定义常对象的一般形式为

    类名    const    对象名(实参列表);

    也可以把const写在最左面

    const    类名    对象名(实参列表);

    二者等价

    如果一个对象被声明为常对象,则不能调用该对象的非const型的成员函数(除了由系统自动调用的隐式构造函数和析构函数)。

    否则就会报错

    aa29b5d2ba6635f86faaf4e8b6d95e01.png

    这样做是为了方式非const型的成员函数修改常对象中的数据成员的值,因为const型的成员函数是不可以修改对象中的数据成员的值的(这个后面还会说到)。

    那么,怎样才能引用常变量中的数据成员呢?很简单,我们只需要将该成员函数声明称const型的成员函数(常成员函数)即可。

    void Print() const;

    常成员函数可以访问常对象中的数据成员,但仍然不允许修改常对象中数据成员的值。

    有时在编程时有要求,一定要修改常对象成员中的某个数据成员的值(例如类中有一个用于计数的变量count,其值应当不能变化),

    对该数据成员声明为mutable,如

    mutable int count;//定义一个在常对象中可以被改变的数据成员

    把count声明为可变的数据成员,这样就可以用声明为const的成员函数来修改它的值。

    =========================一个简单的示例程序1.1====================================

    #include

    using namespace std;

    class Student

    {

     public:

      Student(int n,float s):num(n),score(s){}

      void change(int n,float s) const{num=n;score=s;}

      void display() const{cout<

     private:

      mutable int num;

      mutable float score;

    } ;

    int main()

    {

     Student const stud(101,78.5);

     stud.display();

     stud.change(101,80.5);

     stud.display();

     return 0;

    };

    3d7e7d09b37a9068d158f4c645e123a3.png

    我们定义了常对象stud,然后分别调用了两个常函数display()和change(),但是在change函数中要修改常对象中的num和score的值,所以我们将num和score定义为mutable.

    常对象成员

    1.常数据成员其作用和用法与一般常变量相似,用关键字const来声明常数据成员。常数据成员的值是不能改变的。

    只能通过构造函数的参数初始化表对常数据成员进行初始化。

    在类体中声明常数据成员

    const int num;//声明hour为常数据成员

    在类外定义构造函数

    Student::Student(int n,float s):num(n),score(s){} //通过参数初始化表对常数据成员num和score初始化

    在类体中声明了某一个数据成员为常数据成员后,该类所有对象中的该数据成员的值都是不能改变的,但不同对象中该变量成员的值可以是不同的(分别在初始化时指定)。

    2.常成员函数

    如果将成员函数声明为常成员函数,则只能引用本类中的数据成员,而不能修改它们。

    注意:常对象只能引用常成员函数

    常成员函数的定义形式:

    void Print() const;//注意const的位置在函数名和括号之后

    const是函数类型的一部分,在声明函数和定义函数都要有const关键字,在调用时不必加const。

    常成员函数可以const数据成员,也可以引用非const数据成员,但是都不能修改他们;

    不是常成员函数的函数可以调用const数据成员,但是不能修改它们,也可以调用非const数据成员,并且可以修改它们。

    具体情况,如图1:

    39748b6d6f9975cb10046b13553404d4.png

    还要注意一下三点:1.不要误认为常对象中的成员函数都是常成员函数,常对象只保证其所有数据成员的值不被修改。

    2.如果在常对象中的成员函数未加const声明,则编译系统会把它当最非const成员函数处理。

    3.还要注意,常成员函数不能调用另外一个非cosnt成员函数。

    展开全文
  • 定义常对象的一般形式为 类名 const 对象名(实参列表); 也可以把const写在最左面 const 类名 对象名(实参列表); 二者等价 如果一个对象被声明为常对象,则不能调用该对象的非const型的成员函数(除了由系统自动...
  • **1,常对象** 在定义对象时加关键字...//等价说明:(1)如果一个对象被声明为常对象,则通过该对象只能调用它的常成员函数,而不能调用该对象的普通成员函数(出了由系统自动调用的隐式的构造函数和析构函数)。常

    **

    1,常对象

    **
    在定义对象时加关键字const,指定对象为常对象,常对象必须要有初值,定义后就不可修改。

    Time const t1(10, 20, 30);//定义t1是常对象
    const Time t1(10, 20, 30);//等价

    说明:(1)如果一个对象被声明为常对象,则通过该对象只能调用它的常成员函数,而不能调用该对象的普通成员函数(出了由系统自动调用的隐式的构造函数和析构函数)。常成员呢函数是常对象唯一的对外接口。
    (2)常成员函数可以访问常对象中的数据成员,但仍然不允许修改对象中数据成员的值。
    (关于常成员函数会在下文中介绍)

    2,常对象成员

    可以将类的对象的成员声明为const,包括常数据成员和常成员函数
    1,常数据成员
    常数据成员的值不能改变,只能通过构造函数的参数初始化列表对常数据成员进行初始化,任何其他函数都不能对常数据成员赋值。

    class Time
    {
    public:
        Time(int h)
            :hour(h)//通过构造函数初始化列表初始化常数据成员
        {
            //hour = h;//非法,不能对其赋值
        }
    private:
        const int hour;//定义常数据成员
    };

    2,常成员函数
    如果将成员函数声明为常成员函数,则只能引用本类中的数据成员,而不能修改它们

    void get_time()const;//注意const的位置在函数名和括号之后
    class Time
    {
    public:
        void gettime()const
        {
            _year = 2016;//报错
        }
    private:
        int _year;
    };
    
    class Time
    {
    public:
        void Funtest()
        {
            gettime();//通过
        }
    
        void gettime()const
        {
            Funtest();//报错,常成员函数不能调用非常成员函数
        }
    };
    

    下面用一张表来说明常成员函数的用法
    这里写图片描述
    注意:常对象只保证其数据成员是常数据成员,其值不被修改,如果在常对象中的成员函数未加const声明,编译系统把它作为非const成员函数处理。
    有时在编程时有要求,一定要修改常对象中某个数据成员的值,则可将该数据成员声明为mutable,如:

    mutable int count

    **

    3,指向对象的常指针

    **
    将指针变量声明为const型,这样指针变量始终保持为初值,不能改变,即其指向不变,如:

    class Date
    {
    public:
        Date();
        Date(int y, int m, int d)
        :_year(y), _month(m), _day(d){}
        int _year;
        int _month;
        int _day;
    };
    
    int main()
    {
        Date d1(2017, 3, 20), d2;
        Date *const ptr = &d1;//ptr指向对象d1,伺候不能再改变指向
        ptr = &d2;//错误
    }

    往往用常指针作为函数的形参,目的是不允许函数在执行过程中改变指针变量的值,使其始终指向原来的对象
    (1),如果一个对象已被声明为常对象,只能用指向常对象的指针变量指向它,而不能用非const的指针变量指向它。
    (2),如果定义了一个指向常对象的指针变量,并使它指向一个非const的对象,则其指向的对象时不能通过该指针变量来改变的。如:

    int main()
    {
        Date d(2017, 3, 25);
        const Date *p = &d;
        d._year = 2016;//合法
        //(*p)._year = 2016;//非法
    }
    
    int main()
    {
        void fun(const Date *);
        Date d(2016, 2, 22);
        fun(&d);
        return 0;
    }

    (3),指向常对象的指针最常用于函数的形参,目的是在保护形参指针所指向的对象,使它在函数执行过程中不被修改

    void fun(const Date *p)//形参的性质不允许改变p所指向的对象的值
    {
        //p->_year = 2015;//错误
        cout << p->_year << endl;
    }

    下面用一张表说明指针变量做形参使形参和实参的对应关系
    这里写图片描述

    **

    4,对象的常引用

    **

    class Time
    {
    public:
        Time(int h, int m, int s)
            :hour(h), minute(m), sec(s){}
        int hour;
        int minute;
        int sec;
    };
    
    void Fun(const Time &t)//形参为const则不能修改
    {
        t.hour = 18;//报错
    }
    
    int main()
    {
        Time t1(10, 13, 56);
        Fun(t1);
        cout << t1.hour << endl;
        system("pause\n");
        return 0;
    }
    
    

    下面用表格来小结有关const的知识
    这里写图片描述

    展开全文
  • 常对象 常对象必须在定义对象时就指定对象为常对象。 常对象中的数据成员为常变量且必须要有初始值,如 Time const t1(12,34,36);...定义常对象的一般形式为 类名 const 对象名(实参列表); 也可以把const写在最左面 ...

    常对象
    常对象必须在定义对象时就指定对象为常对象。

    常对象中的数据成员为常变量且必须要有初始值,如

    Time const t1(12,34,36); //定义t1为常对象

    这样的话,在所有的场合中,对象t1中的所有数据成员的值都不能被修改。凡希望保证数据成员不被改变的对象,可以声明为常对象。

    定义常对象的一般形式为

    类名 const 对象名(实参列表);

    也可以把const写在最左面

    const 类名 对象名(实参列表);

    二者等价

    如果一个对象被声明为常对象,则不能调用该对象的非const型的成员函数(除了由系统自动调用的隐式构造函数和析构函数)。

    否则就会报错

    这样做是为了方式非const型的成员函数修改常对象中的数据成员的值,因为const型的成员函数是不可以修改对象中的数据成员的值的(这个后面还会说到)。

    那么,怎样才能引用常变量中的数据成员呢?很简单,我们只需要将该成员函数声明称const型的成员函数(常成员函数)即可。

    void Print() const;

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

    对该数据成员声明为mutable,如

    mutable int count;//定义一个在常对象中可以被改变的数据成员
    把count声明为可变的数据成员,这样就可以用声明为const的成员函数来修改它的值。
    =一个简单的示例程序1.1============

    #include
    using namespace std;
    class Student
    {
    public:
    Student(int n,float s):num(n),score(s){}
    void change(int n,float s) const{num=n;score=s;}
    void display() const{cout<<num<<"\t"<<score<<endl;}
    private:
    mutable int num;
    mutable float score;
    } ;
    int main()
    {
    Student const stud(101,78.5);
    stud.display();
    stud.change(101,80.5);
    stud.display();
    return 0;
    }

    我们定义了常对象stud,然后分别调用了两个常函数display()和change(),但是在change函数中要修改常对象中的num和score的值,所以我们将num和score定义为mutable.

    常对象成员

    1.常数据成员
    其作用和用法与一般常变量相似,用关键字const来声明常数据成员。常数据成员的值是不能改变的。
    只能通过构造函数的参数初始化表对常数据成员进行初始化。

    在类体中声明常数据成员
    const int num;//声明hour为常数据成员

    在类外定义构造函数
    Student::Student(int n,float s):num(n),score(s){} //通过参数初始化表对常数据成员num和score初始化

    在类体中声明了某一个数据成员为常数据成员后,该类所有对象中的该数据成员的值都是不能改变的,但不同对象中该变量成员的值可以是不同的(分别在初始化时指定)。

    2.常成员函数

    如果将成员函数声明为常成员函数,则只能引用本类中的数据成员,而不能修改它们。
    注意:常对象只能引用常成员函数

    常成员函数的定义形式:
    void Print() const;//注意const的位置在函数名和括号之后
    const是函数类型的一部分,在声明函数和定义函数都要有const关键字,在调用时不必加const。
    常成员函数可以const数据成员,也可以引用非const数据成员,但是都不能修改他们;
    不是常成员函数的函数可以调用const数据成员,但是不能修改它们,也可以调用非const数据成员,并且可以修改它们。
    具体情况,如图1:

    还要注意一下三点:
    1.不要误认为常对象中的成员函数都是常成员函数,常对象只保证其所有数据成员的值不被修改。
    2.如果在常对象中的成员函数未加const声明,则编译系统会把它当作非const成员函数处理。
    3.还要注意,常成员函数不能调用另外一个非cosnt成员函数。

    展开全文
  • 即:定义普通对象前 + const注意: 常对象属性是不允许直接修改因此, 常对象不能访问类中普通成员函数(以免其值被直接修改)  只能访问常函数*********************************************************...
  • 定义指向对象的常指针的一般形式为 类名 * const 指针变量=对象地址; 注意应该在定义指针变量时使之初始化 指向对象的常指针变量的值不能被改变,即始终指向同一个对象,但可以改变其所指向对象中的数据成员(非...
  • 在 C++ 中,const 也可以用来修饰对象,称为常对象。...定义常对象的语法和定义常量的语法类似:const class object(params);class const object(params);当然你也可以定义 const 指针:const class *p = n...
  • 常对象

    千次阅读 2018-11-03 19:51:49
    常对象是指对象的数据成员不能被修改。常对象必须在定义的同时进行初始化,且不能改变。不能通过常对象去调用非const型的普通成员函数,但是可以通过普通对象去调用const函数。 定义方式: const 类名 对象名(实参...
  • 常对象:在定义对象时加关键字const。 定义形式: 类名 const 对象名【(实参表)】 ...如果一个对象被声明为常对象,则通过该对象只能调用它的常成员函数,而不能调用该对象的普通成员函数。 ...
  • 《C++面向对象程序设计(第2版)》P92“const数据成员可以被非const...常对象只能保证其数据成员是常数据成员,其值不被改变”,这样看来常对象是否等于把对象中数据成员都定义为const?? 分析: 虽然从理解上
  • 定义指向对象的常指针的一般形式为 类名    *    const    指针变量=对象地址; 注意应该在定义指针变量时使之初始化 指向对象的常指针变量的值不能被改变,即始终指向同一个对象,...
  • 2.常对象不能调用该对象的非const型的成员函数(系统主动调用的构造析构函数除外); 3.常成员函数的声明方法,后面加个const即可: void get_time() const; 4.常对象不能修改对象内的数据成员,如果要修改,只能...
  • 常对象与常成员

    2019-05-13 18:45:46
    (1)不允许常对象调用任何类成员函数,而且常对象一旦定义,在其生存期内不允许修改,否则导致编译错误。 (2)只有类常成员函数才能访问该类的常对象,const成员函数依然不允许修改常对象。 (3)const对象...
  • 在高级语言源程序中, 需要用户定义的标识符为程序中的对象命名,常见命名对象有() A、关键字 B、变量 C、函数 D、数据类型 E、注释 一个一个分析: 关键字 :虽然很多关键字都可以用过define重新命名, 但...
  • C++复杂对象之常对象

    千次阅读 2015-03-07 22:02:01
    这种对象算是复杂对象中简单的一个  常对象是指常类型对象,即对象常量。定义的格式为: ... 在C++编程中,常使用指向常对象的指针或常对象的引用作为函数的参数。这样做既利用了指针或引用作为函数参数
  • c++-常对象

    2018-01-01 22:26:10
    定义对象时指定对象为常对象常对象中的数据成员为常变量并且必须要有初值 Time const t1(12,34,46); 这样ti中所有数据成员的值都不能修改 如果一个对象声明为常对象,那么则不能调用该对象的非const型成员...
  • const关键字: 用const修饰的定义对象称为常对象; 用const修饰的声明成员函数称为常成员函数;...常对象的声明如下: const <类名> <对象名><类名> const <对象名> 两种声明完全一样没有任何区别。1
  • 1、对象数组 ...在定义对象数组时应当怎样实现初始化呢?在花括号中分别写出构造函数并指定实参。如果构造函数有3个参数,分别代表学号、年龄、成绩。则可以这样定义对象数组: StudentStud[3]={//...
  • 指向常对象的常指针

    2017-05-14 20:43:00
    //将指针变量声明为const型,这样指针值始终保持为其初值,不能改变。如 Time t1(10,12,15), t2;... //const位置在指针变量名前面,规定ptr1值是值, ptr1指向对象t1,此后不能再改变指向 ptr1=&t...
  • 1、指向对象的常指针    把指向对象的指针变量声明为const型并将之初始化,这样指针始终保持为初值,不能改变,也就是说它的指向始终不会改变。    定义指向对象指针格式: 类名  * const 指针变量名 = &对象...
  • 均为保护数据信息,不允许修改某些...且常对象不能调用普通成员函数(只能调用后加const常函数) 常成员函数 int area() const { } 1、声明和定义都要写const(关键词const在后面)其他和普通函数定义声明无区...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,733
精华内容 1,093
关键字:

常对象的定义