const常类型说明

红太狼 2024-04-19 13:47 47阅读 0赞

学习C++后，一直想就一些问题总结一下。无奈本人天生四体不勤，一再搁浅。本篇旨在谈谈C++中易被忽略的常类型（**const**），并给以小结。

*  分类

常变量：  **const 类型说明符 变量名**

常引用：  **const 类型说明符 &引用名**

常对象：  **类名 const 对象名**

常成员函数：  **类名::fun(形参) const**

常数组：  **类型说明符 const 数组名\[大小\]**

常指针：  **const 类型说明符\* 指针名 ，类型说明符\* const 指针名**

*  实例说明

**const** **类型说明符 &引用名 ：**

\#include<iostream.h>  
void display(const double& r)  
\{  
// r=12.0;//错的  
 cout<<r<<endl;  
\}  
void main()  
\{  
 double d=9.5;  
 display(d);  
\}

**   类名 const 对象名**  与  **类名::fun(形参) const**

\#include<iostream.h>

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; \}

const int R::print() const  
\{ cout<<R1<<":"<<R2<<endl;  
  return R1;\}

void main()  
\{  
 //常对象只能调用常成员函数，非常对象既可以调用普通成员函数也可以调用常成员函数（最佳匹配）  
 R a1(5,4);  
 a1.print();//调用void print()  
 R const a(5,4);  
 a.print();//调用void print() const

**   类型说明符 const 数组名\[大小\]**

void main()  
\{  
 const int A\[\]=\{1,2,3,4,5,6,7,8,9,0\};  
 int const B\[\]=\{1,2,3,4,5,6,7,8,9,0\};//两种定义都可以

**   const 类型说明符\* 指针名 ** 与  **类型说明符\* const 指针名**

void main()  
\{  
  int a=5;        
 int const \*p=&a;//常类型中，const 与类型说明符的位置可互换  
 a++;//可行  
// \*p=\*p+2;//不可以  
 cout<<\*p<<endl;

int b=100;  
 const int \*name1=&b;//值不便，地址可以变  
 cout<<name1<<endl;  
 name1=&a;  
 cout<<name1<<endl;  
// \*name1=1;//错的

int n1=3, n2=5;  
 int\* const pn=&n1;  
// pn=&n2;//错  
 \*pn=6;  
 char\* const name3="John";  
// name3="abc";//错

*  注意事项

1.  在常变量（**const 类型说明符 变量名）、**常引用（**const 类型说明符 &引用名**）、常对象（**类名 const 对象名）、** 常数组（**类型说明符 const 数组名\[大小\]），** **const”** **与 “类型说明符”或“类名”（其实类名是一种自定义的类型说明符）** 的位置可以互换。如： 
    
         const int a=5; 与 int const a=5; 等同
    
         类名 const 对象名 与const 类名 对象名 等同
2.  用函数fun(b)调用函数 fun(const double & a)中，实参b在main()中可以定义成const double b=5.0；,也可定义成double b=5.0; 。由引用的实质可知，a与b在内存中是同一个值，但若b定义成double b=5.0;，在main()中b是可重赋值的，而fun(const double & a)中则不可以，且b重新赋值会引起a值的改变。
3.  **const 类型说明符\* 指针名** 的定义声明中，指针所指向的值不可以改变，但其所指向的地址可以变。如：  int a=11,b=100;  
                           const int \*name1=&b;  
                           cout<<name1<<endl;  
                           name1=&a;  
                           cout<<name1<<endl;  
                           // \*name1=1;//错的
4.  **类型说明符\* const 指针名** 的定义声明中，指针所指向的值可以改变，但其所指向的地址不可以变。如：  int n1=3, n2=5;  
                           int\* const pn=&n1;  
                           // pn=&n2;//错的  
                           \*pn=6;
5.   常成员函数（**类名::fun(形参) const**），常对象只能调用常成员函数，非常对象既可以调用普通成员函数也可以调用常成员函数（最佳匹配）。

\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#

const

*  一般常量：

> > > eg：int const x=2  或  const int x=2            两者无区别

*  对象常量：

> > > eg：<类名>const<对象名>   或  const<类名><对象名>               两者无区别

*  常指针：
    
     *   
        
         *  int \* const r=&n    （r是常量指针，不允许改变，所以：r=m是错误的，\*r=1是允许的。）
         *  const int \*r=&n    （\*r是常量，不允许改变，所以：r=m是允许的，\*r=1是错误的。）

*  常引用：

> > > const <类名>&<引用名>
> > 
> > >   
> > >

*  常成员函数：只有常成员函数才能操作常量或常对象。

> > > <类型><函数名>(<参数表>) const
> > 
> > >   
> > >

*  常数据成员：只能使用成员初始化列表的方式生成构造函数来对数据成员进行初始化

\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#

常对象和常函数的关系 const

[http://blog.sina.com.cn/s/blog\_4ac0a0d30100cmz5.html][http_blog.sina.com.cn_s_blog_4ac0a0d30100cmz5.html]

（1） 常对象  
用const修饰的对象叫对象常量，其格式如下：  
〈类名〉const 〈对象名〉 或者 const 〈类名〉〈对象名〉  
声明为常对象的同时必须被初始化，并从此不能改写对象的数据成员。

例：分析下列错误的地方，说明理由；  
\#include<iostream.h>  
class Point  
\{ int x, y;  
public:  
Point(int a, int b) \{ x=a; y=b;\}  
Void MovePoint( int a, int b)\{ x+=a; y+=b;\}  
Void print()\{ cout<<"x="<<x<<"y="<<y<<endl;\}  
\};  
void main( )  
\{  
const Point point1( 10,10);//常量对象  
point1.MovePoint(2,2);//常对象point1的数据不能被更改，所以错误  
point1.print( );//print函数的this指针不能指向常对象  
\}  
错误原因在旁边已经注释。  
常对象常被用在对象的引用上。所谓常引用是指说明引用时用const修饰。常引用所引用的对象不能被更新，一般用做形参。其格式：  
const 〈类型说明〉&〈引用名〉  
例：根据例题5-11的类给出程序的执行结果：  
\#include<math.h>  
int length(const Point &p1, const Point &p2)  
\{ int l;  
l=sqrt((p1.x -p2.x)\* (p1.x -p2.x)+(p1.y-p2.y)\*(p1.y-p2.y));  
return l;  
\}  
void main( )  
\{  
Point a(1,1),b(4,5);  
Cout<<"两点的距离是："<<length( a, b)<<endl;  
\}  
本程序的输出：  
两点的距离是：5  
（2）常成员函数  
用const关键词说明的函数叫常成员函数。其格式如下：  
〈类型〉〈函数名〉（〈参数表〉）const;  
常成员函数的作用和功能：  
常成员函数不能更新对象的数据，也不能调用非const修饰的成员函数。常对象只能调用类的常成员函数。  
例：给出下列程序的执行结果：  
\#include<iostream.h>  
class Point  
\{ int x, y;  
public:  
Point(int a, int b) \{ x=a; y=b;\}  
Void MovePoint( int a, int b)\{ x+=a; y+=b;\}  
Void print()const \{ cout<<"x="<<x<<"y="<<y<<endl;\}  
\};  
void main( )  
\{  
Point point1(1,1);  
const Point point2( 2,2);//常量对象  
point1.print();//普通对象可以调用常成员函数  
point2.print( );//常对象调用常成员函数  
\}  
本程序执行结果：  
x=1 y=1  
x=2 y=2

使用const关键字说明的成员函数称为常成员函数，常成员函数的说明格式如下：  
    <返回类型说明符> <成员函数名>(<参数表>) const;  
    在使用常成员函数时要注意：  
    (1) const是函数类型的一个组成部分，因此在函数实现部分也要带有const关键字。  
    (2) 常成员函数不更新对象的数据成员，也不能调用该类中没有用const修饰的成员函数。  
    (3) 常对象只能调用它的常成员函数，而不能调用其他成员函数。成员函数与对象之间的操作关系如表12-1所示。

来源：( [http://blog.sina.com.cn/s/blog\_4ac0a0d30100cmz5.html][http_blog.sina.com.cn_s_blog_4ac0a0d30100cmz5.html] ) - 常对象和常函数的关系 const\_天涯霜雪\_新浪博客

(4) const关键字可以用于参与重载函数的区分。例如：  
    void Print();  
    void Print() const；  
    这两个函数可以用于重载。重载的原则是：常对象调用常成员函数，一般对象调用一般成员函数。  
  （5）在const成员函数中:    
  可以修改被定义成mutable的成员变量,使用mutable关键字定义的成员变量可以被const成员函数修改!

保护类的成员变量不在成员函数中被修改，是为了保证模型的逻辑正确，通过用const关键字来避免在函数中错误的修改了类对象的状态。并且在所有使用该成员函数的地方都可以更准确的预测到使用该成员函数的带来的影响。而mutable则是为了能突破const的封锁线，让类的一些次要的或者是辅助性的成员变量随时可以被更改。没有使用const和mutable关键字当然没有错，const和mutable关键字只是给了建模工具更多的设计约束和设计灵活性，而且程序员也可以把更多的逻辑检查问题交给编译器和建模工具去做，从而减轻程序员的负担(yayv觉得这只不过是把负担移交给了设计人员~, :（，并没有降低任何工作量 )。如果开发过程有比较严格的迭代过程，使用这两个关键字应该更能体现出他们的作用。

\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_

### const参数，const返回值与const函数  ###

[默认分类][Link 1] 2010-04-10 12:07:16 阅读137 评论0  字号：大**中**小 订阅

在C++程序中，经常用const 来限制对一个对象的操作，例如，将一个变量定义为const 的：

const  int  n=3;

则这个变量的值不能被修改，即不能对变量赋值。

const 这个关键字经常出现在函数的定义中，而且会出现在不同的位置，比如：

int  strcmp (const  char  \*str1,const   char  \*str2);

const   int  & min (int  &, int  &);

void  printMessage (char  \*msg) const;

**1.const 参数**

出现在函数参数中的const 表示在函数体中不能对这个参数做修改。比如上面的例子中strcmp() 函数用来比较两个字符串的大小，在函数体中不应该改变两个参数的值，所以将它定义为是const 的。const 通常用来限制函数的指针参数，引用和数组参数，而**一般形式的参数因为形参和实参本来就不在同一内存空间，所以对形参的修改不会影响实参，因此也没有必要限制函数体不能对参数进行修改。**

下面是一些使用函数 const 参数的例子：

(1)  函数 strcpy() 将 src 字符串的内容复制到 targ 字符串中，为保证 src 字符串不被修改，将它定义为 const 参数：

void  strcpy ( const  char  \*src , char  \* targ);

(2)  函数 max() 从数组 array 中找出具有最大值的数组元素并返回这个最大元素的值，为保证数组元素不会在函数中被修改， 将它定义为 const  参数：

int  max ( const  int  array\[ \],  int  size);

(3)  函数 outputObject( ) 将类 Myclass 的对象 obj 的内容输出。对象定义为 const  引用，即可以保证对象不会在函数体中有所改变，又可以节省对象传递的开销：

void  outputObject ( const   Myclass  &obj) ;

**PS:**

const 指针可以接受const 和非 const 地址，但是非const 指针只能接受非const 地址。所以const  指针的能力更强一些，所以尽量多用const 指针，这是一种习惯。

**2. const 返回值**

函数返回值为 const  只有用在函数返回为引用的情况。 函数返回值引用常量表示不能将函数调用表达式作为左值使用。例如前面讲的返回引用的函数 min( )。

int  & min ( int  &i,  int  &j);

可以对函数调用进行赋值,因为它返回的是左值：  min ( a ,  b )=4;

但是，如果对函数的返回值限定为 const  的：const  int  & min ( int & i, int  &j );

那么，就不能对 min ( a, b ) 调用进行赋值了。

**3. const 函数**

在类中，可以为类的成员函数进行如下形式的定义：

class  classname \{

int  member ;

public:

int  getMember ( ) const;

\};

这里,在函数定义头后面加上的 const 表示这个函数是一个“只读函数”，函数不能改变类对象的状态，不能改变对象的成员变量的值。如在函数体中不能这么写：

classname :: getmember( )

\{  member =4 ;

return  member;

另外，**const成员函数也不能在函数中调用其他非const 的函数。\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_**

**补充:**

以下内容转载于： [http://www.chinaunix.net/jh/23/300602.html][http_www.chinaunix.net_jh_23_300602.html]

以下面的例子为例进行说明：

\#include <iostream>;

\#include <string>;

using namespace std;

class Student \{

string name;

int score;

public:

Student ( ) \{ \}

Student ( const string& nm, int sc = 0 )  : name( nm ), score( sc ) \{ \}

void set\_student( const string& nm, int sc = 0 )   // 后面不能有const

\{     name = nm;         score = sc;        \}

const string& get\_name() const

\{     return name;   \}

int get\_score() const

\{     return score;   \}

\};

// output student's name and score

void output\_student( const Student& student )

cout << student.get\_name() << "\\t";

cout << student.get\_score() << endl;

int main()

Student stu( "Wang", 85 );

output\_student( stu );

首先说一点题外话，为什么 get\_name( ) 前面也加 const。如果没有前后两个 const 的话，get\_name() 返回的是对私有数据成员 name 的引用，所以通过这个引用可以改变私有成员 name 的值，如：

Student stu( "Wang", 85 );

stu.get\_name() = "Li";       //  引用可以作为左值

即把 name 由原来的 "Wang" 变成了 "Li"，而这不是我们希望的发生的。所以在 get\_name() 前面加 const 避免这种情况的发生。

那么，get\_name( ) 和 get\_score( ) 这两个后面应该加 const 的成员函数，如果没有 const 修饰的话可不可以呢？回答是可以！但是这样做的代价是：**const 对象将不能再调用这两个非const成员函数了**。如：

const string& get\_name( );

int get\_score( );         // 这两个函数都应该设成 const 型

void output\_student( const Student& student )

cout << student.get\_name() << "\\t";

cout << student.get\_score() << endl;

// 如果 get\_name() 和 get\_score() 是非const 成员函数，这两句调用都是错误的

由于参数 student 表示的是一个对const Student 型对象的引用，所以 student 不能调用非const 成员函数如 set\_student( )。如果 get\_name() 和 get\_score() 成员函数也变成非const 型，那么上面的 student.get\_name() 和 student.get\_score() 的使用就是非法的，这样就会给我们处理问题造成困难。

因此，我们没有理由反对使用const，该加const 时就应该加上const，这样使成员函数除了非const 的对象之外，const 对象也能够调用它。

对象.成员函数  
  
         对象          成员函数       对/错  
1、  const            const              对  
2、  const           non-const       错  
3、  non-const     const             对  
4、  not-const     non-const       对  
  
  
  
          成员函数调用成员函数  
  
     成员函数      成员函数       对/错  
5、  const            const             对  
6、  const         non-const        错  
7、  non-const     const            对  
8、  non-const     non-const     对

[http://04051051.blog.163.com/blog/static/8600749320103100716140/][http_04051051.blog.163.com_blog_static_8600749320103100716140]

\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_

转载于:https://my.oschina.net/alphajay/blog/5749

[http_blog.sina.com.cn_s_blog_4ac0a0d30100cmz5.html]: http://blog.sina.com.cn/s/blog_4ac0a0d30100cmz5.html
[Link 1]: http://04051051.blog.163.com/blog/#m=0&t=1&c=fks_087067092080081068080095085095092080081067083082095064
[http_www.chinaunix.net_jh_23_300602.html]: http://www.chinaunix.net/jh/23/300602.html
[http_04051051.blog.163.com_blog_static_8600749320103100716140]: http://04051051.blog.163.com/blog/static/8600749320103100716140/