C++的const操作符

清疚 2022-07-20 16:23 146阅读 0赞

1.C语言中定义一个符号常量可以用宏定义实现  
  
  
如\# define MIN 5  
  
  
宏定义的缺陷是仅仅对常量做简单的替换，有时会出现预料之外的结果，如\# define MIN(x)  x\*x  将x设为（2+3）会得到13,而不是25  
  
  
C++中可以用const修饰符来定义常量，const比宏定义常量更加安全。  
  
  
下面的例子展示了宏定义和const的不同，  
  
  
int x=5;  
  
  
\# define T x+x  
  
  
\# define M T-T  
  
  
M的值将为10  
  
  
而用const定义常量const int T=x+x;const M=T-T;   
  
  
M的值将为0。  
  
  
2.const 修饰符与指针  
  
  
（1）指向常量的指针  
  
  
const <类型名> \*指针名；如：  const int \*t=&x;这种指针可以修改自己的指向，但它指向的内容\*t不能修改。  
  
  
（2）常指针  
  
  
<类型名> \*const <指针名>  
  
  
int t=4;int \*const p=&t;这种指针不能改变指向，但可以改变指向的内容  
  
  
（3）指向常量的常指针  
  
  
const <类型名> \*const <指针名>  
  
  
int x=5;const int \*const=&x;  
  
  
这种指针不能改变指向，也不能改变指向的内容  
  
  
下面是代码：  
  
  
\# include <iostream>  
using namespace std;  
int main()  
\{  
const int x=4;  
const int \*p1=&x;  //指向常量的指针  
cout<<\*p1<<endl;  
int a=5;  
p1=&a;  
cout<<\*p1<<endl;  
//\*p=5;          //p为指向常量的指针，指向的内容不能修改  
const int \*const p2=&x;//指向常量的常指针  
//p2=&a;         //p2的指向和内容都不能改变  
int \*const p3=&a;  //p3为常指针  
int b=6;  
//p3=&b;     //p3的指向不能改变  
cin.get();  
return 0;

3.const与迭代器  
  
  
（1）const\_iterator与const迭代器的区别  
  
  
const\_iteroator指向某个容器元素，可以修改其指向，即指向其它元素，但不能改变指向的内容，const迭代器可以改变指向的内容，但不能改变其指向，有点类似于常指针。  
  
  
下面是代码：  
  
  
vector<int> v(10,1);  
  
  
vector <int>::const\_iterator iter()=v.begin();  
  
  
iter++;   //正确  
  
  
\*iter=2;  //错误  
  
  
const vector<int> ::iterator iter1=v.begin();  
  
  
iter1++;  // 错误  
  
  
\*iter1=2；//正确  
  
  
(2) const\_itearator和iterator都可以用来遍历容器的元素，const\_iterator可以用于const或非const容器，iterator只用于非const容器。  
  
  
（3）在泛型算法中有的算法只能接受iterator类型的迭代器，如果将const\_iterator传入会报错，为了将const\_iterator转换为iterator,用const\_cast操作符无法完成这个转换，解决办法是用 distance和advance函数，具体办法是：  
vector <int> v(10,1);  
  
  
Vector <int>::iterator it;  
  
  
Vector <int>::const\_iterator iter;  
  
  
it=v.begin();  
  
  
advance(it,distance<vector<int>::const\_iterator>)(it,iter);  
  
  
4.const 用于函数的重载  
  
  
（1）类中的成员函数可以用const进行重载，对象调用这个函数，非const对象将调用非const版本的函数，而const对象调用const版本的函数。  
  
  
下面是代码：  
  
  
\# include <iostream>  
using namespace std;  
class A  
\{  
public:  
A(int i):x(i)\{\}  
void show()\{cout<<"not const"<<endl;\}  
void show() const \{cout<<"const"<<endl;\}  
private:  
int x;  
\};  
int main()  
\{  
A a(1);  
a.show();      //普通对象调用非const版本的函数  
const A b(2);  //常对象调用常成员函数  
b.show();  
cin.get();  
return 0;  
\}  
常成员函数show()只能访问而不能修改类中的变量（mutable变量除外）。  
  
  
上面还讲到了常对象const A a，常对象只能调用常成员函数。  
  
  
（2）以下两个函数不能实现重载：  
  
  
f(char\*)和f(const char \*),因为如果把char \*类型的变量传入形参时，会有二义性的问题。  
  
  
5.const用于函数的形参  
  
  
int f(const int x) ;这个函数传入的实参可以是const类型，也可以是非const类型，在函数f中，x的值不能被改变  
  
  
int f(const int \* x) ;形参为指向常量的指针，指向的内容不能改变  
  
  
int f(int \*const x);形参为常指针，指向不可变  
  
  
int (const A& a);形参为A类型的引用，这样可以避免复制、修改对象，从而有提高效率并且保护对象的作用。  
  
  
6.const也可以用于修饰函数的返回值，此时函数的返回值可以相应地赋值给一个const类型的变量。