C++常数据成员精讲—const关键字

来源：互联网发布：手机温度计软件编辑：程序博客网时间：2024/05/23 20:16

分类： c++2012-08-26 09:47 937人阅读评论(0) 收藏举报

c++systemclassc

用const修士的定义对象成为常对象；（两种声明方式）

[cpp] view plaincopy
const Point point1( 10,10);//常量对象  
    Point const point2( 10,10);//常量对象  

用const修饰的声明成员函数成为常成员函数；

[cpp] view plaincopy
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;}  
};  

用const修饰的声明数据成员成为常数据成员；
注意：变量或对象被const修饰后其值不能被更新（除非数据成员被mutable修饰时，可以被修改）。因此被const修饰的变量或者对象要进行初始化。

说明：
1 任何函数都不能对常数据成员赋值。
2 构造函数对常数据成员进行初始化时也只能通过初始化列表进行。
3 常数据成员在定义时必须赋值或称为必须初始化。
4 如果累有多个默认构造函数必须都初始化常数据成员。
通过下面例子来理解常数据成员：（借用网友实例）

[cpp] view plaincopy
class A  
{  
private:  
int w,h;  
      const int cctwl=5;  //错误一  
public:  
};  
void main()  
{     
        A a ;   //错误二     
    cout<< "sss";  
         system("pause");  
}  
错误一：不能对常数据成员在类中初始化、要通过类的构造函数，只有静态常量才能这样初始化。  
错误二：没有合适的默认构造函数可用。因为有常量cctwl没有初始化必须初始化所有常数据成员。  

多个构造函数下的常数据成员

[cpp] view plaincopy
class A{  
private:  
    int w,h;  
     const int  cctwl;  
public:  
    const int cct;  
    A():cctwl(5),cct(6){};  
      
A(int x,int y) //错误一      
{  
        　w=x,h=y;  
    }  
};  
void main()  
{  
    A a ;  
    A b(3,8);  
    cout<< "sss";  
    system("pause");  
}  
错误一：每个构造函数都要初始化常数据成员应改为  
A(int x,int y):cctwl(7),cct(8)  
 {  
   　w=x,h=y;  
　}  

c++ 常成员函数
声明： <类型标识符> 函数名（参数列表） const;

说明：

（1）const是函数类型的一部分，在实现部分也要带该关键字。

（2）const关键字可以用于对重载函数的区分。

（3）常成员函数不能更新任何数据成员，也不能调用该类中没有用const修饰的成员函数，只能调用常成员函数和常数据成员。

下面是相应的实例（借用网友）：

[cpp] view plaincopy
A、通过例子来理解const是函数类型的一部分，在实现部分也要带该关键字。  
class A{  
private:  
    int w,h;  
public:  
    int getValue() const;  
    int getValue();  
    A(int x,int y)  
    {  
        w=x,h=y;  
    }  
    A(){}  
};  
int A::getValue() const    //实现部分也带该关键字  
{  
    return w*h; //？？？？  
}  
void main()  
{  
    A const a(3,4);  
    A c(2,6);  
cout<<a.getValue()<<c.getValue()<<"cctwlTest";   
system("pause");  
}  
B、通过例子来理解const关键字的重载  
class A{  
private:  
    int w,h;  
public:  
int getValue() const  
{  
        return w*h;  
    }  
    int getValue(){  
        return w+h;  
    }  
    A(int x,int y)  
    {  
        w=x,h=y;  
    }  
    A(){}  
};  
void main()  
{     
    A const a(3,4);  
    A  c(2,6);  
    cout<<a.getValue()<<c.getValue()<<"cctwlTest"; //输出12和8  
    system("pause");  
}  
C、通过例子来理解常成员函数不能更新任何数据成员  
class A{  
private:  
    int w,h;  
public:  
    int getValue() const;  
    int getValue();  
    A(int x,int y)  
    {  
        w=x,h=y;  
    }  
    A(){}  
};  
int A::getValue() const  
{  
    w=10,h=10;//错误，因为常成员函数不能更新任何数据成员  
    return w*h;  
}  
int A::getValue()  
{  
    w=10,h=10;//可以更新数据成员  
    return w+h;  
}  
void main()  
{  
     A const a(3,4);  
    A  c(2,6);  
    cout<<a.getValue()<<endl<<c.getValue()<<"cctwlTest";                           system("pause");  
}  
D、通过例子来理解  
1、常成员函数可以被其他成员函数调用。  
2、但是不能调用其他非常成员函数。  
3、可以调用其他常成员函数。  
class A{  
private:  
    int w,h;  
public:  
    int getValue() const  
 {  
   return w*h + getValue2();//错误的不能调用其他非常成员函数。  
 }  
    int getValue2()  
    {  
          
        return w+h+getValue();//正确可以调用常成员函数  
    }  
      
    A(int x,int y)  
    {  
        w=x,h=y;  
    }  
    A(){}  
};  
void main()  
{  
    A const a(3,4);  
    A       c(2,6);  
cout<<a.getValue()<<endl<<c.getValue2()<<"cctwlTest";                     
system("pause");  
}  

0 0