实例分析C++ 权限控制及const用法

  一、 引言

    分析如下小程序。找出它的错误（bug），并修改它：

class Identifier {    int x;    void show() { cout << x; };};class Student  {    const Identifier id;    // some other variables/functions below};void main()  {    Student s1,s2;    s1.id=100;     s2=s1;    s2.id.show();}

 下面是VS2008下显示的编译错误：

 二、复习下C++访问权限相关知识                    

1）一个类友元（包含友元函数或者友元类的成员函数或者友元类的所有成员函数）可以访问该类的任何成员（包括成员变量及成员方法）。

2）除去友元外，private成员只有该类自身的成员函数可以访问，protected成员只有该类及其派生类的成员函数可以访问，public成员则该类及其派生类的成员函数和对象都可以访问。

     上述总结全面吗？我们再来看一个例子：

//String类class String{public:    String(const char* str = NULL);    String(const String& rhs);    ~String();    String& operator = (const String& other);private:    char* m_pData;};//重写赋值操作String& String::operator = (const String& other){    if (&other == this)    {        return *this;    }    delete [] m_pData;    m_pData = NULL;    m_pData = new char [strlen(other.m_pData) + 1];    if (m_pData)    {        strcpy(m_pData, other.m_pData);    }    return *this;}

这个String类的赋值操作中直接引用了对象other的private成员。前面提到“private成员只有该类自身的成员函数可以访问",看来是不准确的！

   

1、类成员访问权限到控制是定义在类域的，而不是对象域，因而在一个成员函数中直接引用一个同类对象到private成员是可行的。

2、通常我们在一个成员函数中操作本对象到private成员，其实也是操作this所指到这一对象的成员，成员函数属于类，而不属于对象。

3、类到封装性体现在对外部对象，是对类的使用者，是针对类型而不是实例，对实现者没有必要隐藏。

    面向对象里的封装，是针对外部的使用者，而不是针对内部实现者。

     这个知识点的理解，可以找出引言程序中的一个bug:

    (1) s1.id=100;

  （2)  s2.id.show();//错，class成员默认为private.因此不能直接访问：s1.id, s2.id等。

  三、复习下C++ const相关知识   

(1)const修饰成员变量
const修饰类的成员函数，表示成员常量，不能被修改，同时它只能在初始化列表中赋值。
    class A
    {
        …
        const int nValue;         //成员常量不能被修改
        …
        A(int x): nValue(x) { } ; //只能在初始化列表中赋值
     }

(2)const修饰成员函数
const修饰类的成员函数，则该成员函数不能修改类中任何非const成员函数。一般写在函数的最后来修饰。
    class A
    {
        …
       void function()const; //常成员函数,它不改变对象的成员变量.                        

//也不能调用类中任何非const成员函数。
}

对于const类对象/指针/引用，只能调用类的const成员函数，因此，const修饰成员函数的最重要作用就是限制对于const对象的使用。

a. const成员函数不被允许修改它所在对象的任何一个数据成员。

b. const成员函数能够访问对象的const成员，而其他成员函数不可以。

 

(3)const修饰类对象/对象指针/对象引用

·             const修饰类对象表示该对象为常量对象，其中的任何成员都不能被修改。对于对象指针和对象引用也是一样。

·             const修饰的对象，该对象的任何非const成员函数都不能被调用，因为任何非const成员函数会有修改成员变量的企图。
例如：
class AAA
{
    void func1();
void func2() const;
}
const AAA aObj;
aObj.func1(); ×
aObj.func2(); 正确

const AAA* aObj = new AAA();
aObj-> func1(); ×
aObj-> func2(); 正确

const有什么作用？

1.可以定义const常量，具有不可变性。
例如：

const int Max=100;
int Array[Max];

2.便于进行类型检查，使编译器对处理内容有更多了解，消除了一些隐患。

例如：

void f(const int i) { .........}
编译器就会知道i是一个常量，不允许修改；

3.可以避免意义模糊的数字出现，同样可以很方便地进行参数的调整和修改。
同宏定义一样，可以做到不变则已，一变都变！如（1）中，如果想修改Max的内容，只需要：const int Max=you want；即可！

4.可以保护被修饰的东西，防止意外的修改，增强程序的健壮性。
还是上面的例子，如果在函数体内修改了i，编译器就会报错；
例如：
void f(const int i) { i=10;//error! }

5.为函数重载提供了一个参考。
class A
{
     ......
    void f(int i)       {......} file://一个函数
    void f(int i) const {......} file://上一个函数的重载
    ......
};

6.可以节省空间，避免不必要的内存分配。
例如：
#define PI 3.14159         file://常量宏
const doulbe Pi=3.14159; file://此时并未将Pi放入ROM中
......
double i=Pi;               file://此时为Pi分配内存，以后不再分配！
double I=PI;               file://编译期间进行宏替换，分配内存
double j=Pi;               file://没有内存分配
double J=PI;               file://再进行宏替换，又一次分配内存！

const定义常量从汇编的角度来看，只是给出了对应的内存地址，而不是象#define一样给出的是立即数，所以，const定义的常量在程序运行过程中只有一份拷贝，而#define定义的常量在内存中有若干个拷贝。

7.提高了效率。
编译器通常不为普通const常量分配存储空间，而是将它们保存在符号表中，这使得它成为一个编译期间的常量，没有了存储与读内存的操作，使得它的效率也很高。

{

    size = sz; // error：试图在构造函数体内对const成员变量进行初始化

}

 

  根据以上分析,可发现如下错误：

（1）const需要初始化时参数列表赋值。

（2）  s2.id.show();//错。Show函数返回值不是const类型的，而id是const类型的，不能从const类型转换成非const类型。

 

四、解决结果

    除了前面的几个主要错误外，还有以下错误：

   （1）” = “号未重载

   （2）构造函数不能使用编译器默认的,因为const需要初始化时参数列表赋值.

改完后结果：

// C++ConstDebug.cpp : Defines the entry point for the console application.//#include "stdio.h"#include "stdafx.h"#include <iostream>using namespace std;class Identifier {public:    int x;    void show() const { cout << x; };    Identifier(int var):x(var){};};class Student  {public:   const Identifier id;   Student(Identifier ID):id(ID){};

   Student& operator = (const Student& other);  };Student&  Student:: operator = (const Student& other){ if (&other == this)   return *this; //id = other.id;return *this; }int main(){Student s1(100),s2(100);         s2=s1;        s2.id.show();getchar();return 0;}