1)const修饰成员变量:成员常量不能被修改初始化:
方法一:只能在构造函数的初始化列表中赋值----比较常用
- class A
- {
- private:
- const int n; //成员常量不能被修改
- public:
- A(int x): n(x) //只能在初始化列表中赋值
- { } ;
- }
class A
{
private:
const int n; //成员常量不能被修改
public:
A(int x): n(x) //只能在初始化列表中赋值
{ } ;
}
方法二:把变量static 和 const 并用,在外部初始化
- class A
- {
- public:
- A()
- {}
- private:
- static const int i; //注意必须是静态的!
- };
- const int A::i=3;
class A
{
public:
A()
{}
private:
static const int i; //注意必须是静态的!
};
const int A::i=3;
注意:为什么const成员不能在构造函数体中进行初始化?
原因:在构造函数中那叫赋值,因为定义在类中已经定义好了,之后只需要在构造函数赋值就可以了,这是定义和赋值时分开的。但是,const变量是必须在定义的时候初始
的,因此只能使用初始化列表中进行,表示是在定义时就能初始化。
2)const修饰成员函数:常函数,函数体为常量,不能改变其他非const成员的值
使用时间:任何不会修改数据成员(即函数中的变量)的函数都应该声明为const 类型
const位置:一般写在函数的尾部来const修饰的成员函数
主要作用:只能被const类对象、指针、引用调用
- class A
- {
- void function()const; //常成员函数, 它不改变对象的成员变量. 也不能调用类中任何非const成员函数。
- }
class A
{
void function()const; //常成员函数, 它不改变对象的成员变量. 也不能调用类中任何非const成员函数。
}
说明:
注意一:在const成员函数内部不允许修改数据成员。反过来,将修改数据成员的成员函数声明为const将导致编译错误。
注意二:const成员函数不允许调用非const成员函数,而只能使用const成员。
非const成员函数可以调用const成员函数。
注意三:可以对const成员函数进行非const版本的重载。
注意四:构造函数和析构函数不允许声明为const类型。构造函数既可以初始化const对象,也可以初始化非const对象。析构函数同理。
注意五:建议将不修改数据成员的成员函数都声明为const。当编写这种成员函数时,若不经意修改了数据成员,编译器将产生错误信息。
代码:
const重载
- #include<iostream>
- using namespace std;
- class A
- {
- private:
- int a;
- const int b;
- public:
- A(int i,int j):b(j)
- {
- a=i;
- }
- void print()
- {
- cout<<"非const函数"<<endl;
- cout<<a<<b<<endl;
- }
- void print ()const
- {
- cout<<"const函数"<<endl;
- cout<<a<<b<<endl;
- }
- };
- void main()
- {
- A a(1,2);
- a.print(); //a为普通的对象,会调用普通的成员函数
- const A aa(3,4);
- aa.print();//aa为常对象,会调用常成员函数
- system("pause");
- }
#include<iostream>
using namespace std;
class A
{
private:
int a;
const int b;
public:
A(int i,int j):b(j)
{
a=i;
}
void print()
{
cout<<"非const函数"<<endl;
cout<<a<<b<<endl;
}
void print ()const
{
cout<<"const函数"<<endl;
cout<<a<<b<<endl;
}
};
void main()
{
A a(1,2);
a.print(); //a为普通的对象,会调用普通的成员函数
const A aa(3,4);
aa.print();//aa为常对象,会调用常成员函数
system("pause");
}
注意四:同一成员函数名,若只有const型,则非const对象可以调用该成员函数,即调用const成员函数。 <见上面的例子const重载>
注意五:同一成员函数名,若既有非const型,又有const型(重载),则非const对象只调用非const成员函数。<见上面的例子const重载>
常对象和常成员函数的调用
- #include<iostream>
- using namespace std;
- class A
- {
- private:
- int a;
- const int b;
- public:
- A(int i,int j):b(j)
- {
- a=i;
- }
- void print ()const
- {
- // a=10;//错误,常函数中不能更新数据成员
- cout<<"const函数"<<endl;
- cout<<a<<b<<endl;
- }
- void set(int i,int j)
- {
- a=i;
- // b=j;//错误,const成员不能改变
- }
- };
- void main()
- {
- const A a(3,4);
- // a.set(5,6);//错误,常对象不能调用非常成员,常成员函数是常对象唯一对外出口
- a.print(); //正确,常对象只能调用常函数。
- system("pause");
- }
#include<iostream>
using namespace std;
class A
{
private:
int a;
const int b;
public:
A(int i,int j):b(j)
{
a=i;
}
void print ()const
{
// a=10;//错误,常函数中不能更新数据成员
cout<<"const函数"<<endl;
cout<<a<<b<<endl;
}
void set(int i,int j)
{
a=i;
// b=j;//错误,const成员不能改变
}
};
void main()
{
const A a(3,4);
// a.set(5,6);//错误,常对象不能调用非常成员,常成员函数是常对象唯一对外出口
a.print(); //正确,常对象只能调用常函数。
system("pause");
}
3)const修饰类对象、对象指针、对象引用:常量对象(对象指针和对象引用),任何成员都不能被修改,只能调用常成员函数。
注意一:const对象在定义后,其值不可被改变。
注意二:const对象不允许进行成员函数的调用,即使是不修改对象的成员函数也不行。除非成员函数本身也声明为const。
即:const对象只可调用const成员函数,不能调用任何非const成员函数(构造与析构函数除外)。
原因:任何非const成员函数会有修改成员变量的企图。
注意三:非const对象既可调用const成员函数,可调用非const成员函数。
注意四:同一成员函数名,若只有const型,则非const对象可以调用该成员函数,即调用const成员函数。 <见上面的例子const重载>
注意五:同一成员函数名,若既有非const型,又有const型(重载),则非const对象只调用非const成员函数。<见上面的例子const重载>
- class A
- {
- void func1();
- void func2() const;
- }
- const A aObj;
- aObj.func1(); //错误,常函数只能调用常成员函数
- aObj.func2(); 正确
- const A* aObj = new A();
- aObj-> func1();//错误,常指针只能调用常成员函数
- aObj-> func2(); 正确
class A
{
void func1();
void func2() const;
}
const A aObj;
aObj.func1(); //错误,常函数只能调用常成员函数
aObj.func2(); 正确
const A* aObj = new A();
aObj-> func1();//错误,常指针只能调用常成员函数
aObj-> func2(); 正确
注意:
1、const对象只能访问const成员函数, 非const对象可以访问任意的成员函数=const成员函数+非const成员函数.
2、const对象的成员是不可修改的,然而const对象通过指针维护的对象却是可以修改的.
3、常量指针被转化成非常量指针,并且仍然指向原来的对象;
常量引用被转换成非常量引用,并且仍然指向原来的对象;
常量对象被转换成非常量对象
4、将Const类型转化为非Const类型的方法 :略
const使用建议:
1、在参数中使用const应该使用引用或指针,而不是一般的对象实例;
2、const在成员函数中的三种用法(参数、返回值、函数)要很好的使用
1)参数:const A& a:只要函数体内是只读,不会修改参数,又想提高效率,则常常使用const &
2)返回值:不要轻易的将函数的返回值类型定为const,除了重载操作符外一般不要将返回值类型定为对某个对象的const引用;
3)常函数:任何不会修改数据成员的函数都应该声明为const 类型。