-
c++ 常类型 常对象常成员函数的定义和实现
2018-09-11 17:49:38#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; }
-
java 常对象_C++中的常对象与常对象成员详解
2021-03-01 10:32:59常对象常对象必须在定义对象时就指定对象为常对象。常对象中的数据成员为常变量且必须要有初始值,如Time const t1(12,34,36);...定义常对象的一般形式为类名 const 对象名(实参列表);也可以把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<
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成员函数。
-
C++中的常对象与常对象成员详解
2020-12-26 02:37:21定义常对象的一般形式为 类名 const 对象名(实参列表); 也可以把const写在最左面 const 类名 对象名(实参列表); 二者等价 如果一个对象被声明为常对象,则不能调用该对象的非const型的成员函数(除了由系统自动... -
常对象+常对象成员+指向对象的常指针+指向常对象的指针变量+对象的常引用
2017-04-06 00:59:32**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的知识
-
C++中的常对象和常对象成员
2020-03-20 11:35:47常对象 常对象必须在定义对象时就指定对象为常对象。 常对象中的数据成员为常变量且必须要有初始值,如 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成员函数。 -
不允许dllimport函数的定义_C++知识点 29:常对象和常函数
2020-12-05 19:18:48即:定义普通对象前 + const注意: 常对象内的属性是不允许直接修改的因此, 常对象不能访问类中的普通成员函数(以免其值被直接修改) 只能访问常函数*********************************************************... -
C++中指向对象的常指针与指向常对象的指针详解
2020-12-31 04:41:19定义指向对象的常指针的一般形式为 类名 * const 指针变量=对象地址; 注意应该在定义指针变量时使之初始化 指向对象的常指针变量的值不能被改变,即始终指向同一个对象,但可以改变其所指向对象中的数据成员(非... -
java 常对象_C++ const对象(常对象)
2021-03-01 10:32:56在 C++ 中,const 也可以用来修饰对象,称为常对象。...定义常对象的语法和定义常量的语法类似:const class object(params);class const object(params);当然你也可以定义 const 指针:const class *p = n... -
常对象
2018-11-03 19:51:49常对象是指对象的数据成员不能被修改。常对象必须在定义的同时进行初始化,且不能改变。不能通过常对象去调用非const型的普通成员函数,但是可以通过普通对象去调用const函数。 定义方式: const 类名 对象名(实参... -
C++:常对象与常对象成员
2019-09-20 23:25:56常对象:在定义对象时加关键字const。 定义形式: 类名 const 对象名【(实参表)】 ...如果一个对象被声明为常对象,则通过该对象只能调用它的常成员函数,而不能调用该对象的普通成员函数。 ... -
定义const对象而产生的常数据成员与直接定义const数据成员在编译器编译时候的区别
2017-01-13 15:57:34《C++面向对象程序设计(第2版)》P92“const数据成员可以被非const的...常对象只能保证其数据成员是常数据成员,其值不被改变”,这样看来常对象是否等于把对象中的数据成员都定义为const?? 分析: 虽然从理解上 -
C++中指向对象的常指针和指向常对象的指针
2020-07-05 15:05:37定义指向对象的常指针的一般形式为 类名 * const 指针变量=对象地址; 注意应该在定义指针变量时使之初始化 指向对象的常指针变量的值不能被改变,即始终指向同一个对象,... -
C++ 之常对象,常对象成员
2018-08-31 10:16:262.常对象不能调用该对象的非const型的成员函数(系统主动调用的构造析构函数除外); 3.常成员函数的声明方法,后面加个const即可: void get_time() const; 4.常对象不能修改对象内的数据成员,如果要修改,只能... -
常对象与常成员
2019-05-13 18:45:46(1)不允许常对象调用任何类的成员函数,而且常对象一旦定义,在其生存期内不允许修改,否则导致编译错误。 (2)只有类的常成员函数才能访问该类的常对象,const成员函数依然不允许修改常对象。 (3)const对象... -
【解析】在高级语言源程序中, 常需要用户定义的标识符为程序中的对象命名,常见的命名对象有()
2020-11-01 21:24:42在高级语言源程序中, 常需要用户定义的标识符为程序中的对象命名,常见的命名对象有() 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型成员... -
C++常对象精讲_const关键字的用法
2021-01-20 05:44:57const关键字: 用const修饰的定义对象称为常对象; 用const修饰的声明成员函数称为常成员函数;...常对象的声明如下: const <类名> <对象名><类名> const <对象名> 两种声明完全一样没有任何区别。1 -
16、对象数组,对象指针,常对象、对象的常引用
2020-02-10 16:34:271、对象数组 ...在定义对象数组时应当怎样实现初始化呢?在花括号中分别写出构造函数并指定实参。如果构造函数有3个参数,分别代表学号、年龄、成绩。则可以这样定义对象数组: StudentStud[3]={//... -
指向常对象的常指针
2017-05-14 20:43:00//将指针变量声明为const型,这样指针值始终保持为其初值,不能改变。如 Time t1(10,12,15), t2;... //const位置在指针变量名前面,规定ptr1的值是常值, ptr1指向对象t1,此后不能再改变指向 ptr1=&t... -
指向对象的常指针和指向常对象的指…
2013-12-02 15:34:121、指向对象的常指针 把指向对象的指针变量声明为const型并将之初始化,这样指针始终保持为初值,不能改变,也就是说它的指向始终不会改变。 定义指向对象常指针格式: 类名 * const 指针变量名 = &对象... -
类中的常对象,常数据成员,常成员函数,常指针,常引用
2019-12-21 11:48:21均为保护数据信息,不允许修改某些...且常对象不能调用普通成员函数(只能调用后加const的常函数) 常成员函数 int area() const { } 1、声明和定义都要写const(关键词const在后面)其他和普通函数定义声明无区...