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

最新推荐文章于 2024-01-02 14:44:05 发布

Smith先生

最新推荐文章于 2024-01-02 14:44:05 发布

阅读量1.5k

点赞数

分类专栏：编程基础 C++

本文链接：https://blog.youkuaiyun.com/acs713/article/details/8712333

版权

编程基础同时被 2 个专栏收录

97 篇文章

订阅专栏

C++

14 篇文章

订阅专栏

一、引言

分析如下小程序。找出它的错误（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成员，而其他成员函数不可以。

任何不会修改数据成员的函数都应该声明为const 类型。如果在编写const 成员函数时，不慎修改了数据成员，或者调用了其它非const 成员函数，编译器将指出错误，这无疑会提高程序的健壮性。

const 成员函数的声明看起来怪怪的：const 关键字只能放在函数声明的尾部，大概是因为其它地方都已经被占用了。

关于Const函数的几点规则：

a. const对象只能访问const成员函数,而非const对象可以访问任意的成员函数,包括const成员函数.

b. const对象的成员是不可修改的,然而const对象通过指针维护的对象却是可以修改的.

c. const成员函数不可以修改对象的数据,不管对象是否具有const性质.它在编译时,以是否修改成员数据为依据,进行检查.

e. 然而加上mutable修饰符的数据成员,对于任何情况下通过任何手段都可修改,自然此时的const成员函数是可以修改它的。

//*********************************************************

看C++教材的时候，对于const function以为有了很正确的理解，但到使用时才知道，实践出真知！

const 函数只能调用 const 函数，即使某个函数本质上没有修改任何数据，但没有声明为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;
}