第十五章：C++访问控制权限、继承和多态详解

悠悠 2024-03-23 21:51 41阅读 0赞

## 第十五章：C++访问控制权限、继承和多态详解 ##

### 1. 概述 ###

C++中的访问控制权限是面向对象编程的重要概念之一。通过访问控制权限，我们可以限制类成员的访问范围，以保护数据的安全性和封装性。本文将详细讲解C++中的访问控制权限，结合继承和多态，给出大量代码和实际案例。

### 2. 访问控制权限 ###

#### 2.1 访问控制权限的类型 ####

C++中有三种访问控制权限：`public`、`protected`和`private`。它们定义了类成员对外暴露的程度，以下是它们的基本规则：

*  `public`：公共权限，允许在类内部和外部使用。
 *  `protected`：受保护的权限，允许在类内部和派生类中使用。
 *  `private`：私有权限，只允许在类内部使用。

#### 2.2 访问控制权限的示例代码 ####

class Shape {
        
    public:
        void printArea() const {
        
            cout << "The area is: " << calculateArea() << endl;
        }
    
    protected:
        virtual double calculateArea() const = 0;
    };
    
    class Circle : public Shape {
        
    private:
        double radius;
    
    public:
        Circle(double r) : radius(r) {
        }
    
    protected:
        double calculateArea() const {
        
            return 3.14 * radius * radius;
        }
    };
    
    int main() {
        
        Shape* shape = new Circle(5.0);
        
        shape->printArea();
    
        delete shape;
    
        return 0;
    }

**运行结果：**

The area is: 78.5

在上述代码中，`Shape`类中的函数`printArea()`是公共权限，可以在类内部和外部使用。`protected`权限用于声明纯虚函数`calculateArea()`，这个函数必须在派生类中实现。

派生类`Circle`中的私有成员变量`radius`只允许在类内部使用。通过实现`calculateArea()`函数，我们可以计算圆的面积。

在`main()`函数中，我们通过基类指针`shape`来存储`Circle`对象，并调用`printArea()`函数来打印圆的面积。尽管`calculateArea()`被定义为`protected`权限，但派生类可以正常地访问它。

### 3. 继承和多态中的访问控制权限 ###

#### 3.1 继承中的访问控制权限 ####

继承中，访问控制权限决定了派生类对基类成员的访问能力。以下是继承中的不同访问权限的示例代码：

class Animal {
        
    public:
        void eat() {
        
            cout << "Animal eats." << endl;
        }
    
    protected:
        void sleep() {
        
            cout << "Animal sleeps." << endl;
        }
    
    private:
        void run() {
        
            cout << "Animal runs." << endl;
        }
    };
    
    class Dog : public Animal {
        
    public:
        void accessBase() const {
        
            eat();     // 可以访问基类的公共成员
            sleep();   // 可以访问基类的受保护成员
            //run();   // 无法访问基类的私有成员
        }
    };
    
    int main() {
        
        Dog dog;
    
        dog.accessBase();
    
        return 0;
    }

**运行结果：**

Animal eats.
    Animal sleeps.

在上述代码中，`Dog`类继承了`Animal`类。通过对象`dog`调用`accessBase()`函数，我们可以看到派生类对不同访问权限的访问情况。

`Dog`类可以访问`Animal`类的公共和受保护成员（`eat()`和`sleep()`），但无法访问`Animal`类的私有成员（`run()`）。

#### 3.2 多态中的访问控制权限 ####

多态是指通过基类的指针或引用来操作派生类的对象，实现不同对象的不同行为。在多态中，使用基类指针或引用可以限制对对象成员的访问能力。以下是多态中的访问控制权限的示例代码：

class Animal {
        
    public:
        virtual void makeSound() = 0;
    };
    
    class Dog : public Animal {
        
    public:
        void makeSound() override {
        
            cout << "Woof!" << endl;
        }
    };
    
    class Cat : public Animal {
        
    private:
        void makeSound() override {
        
            cout << "Meow!" << endl;
        }
    };
    
    int main() {
        
        Animal* animal1 = new Dog();
        Animal* animal2 = new Cat();
    
        //animal1->makeSound();   // 无法访问基类的私有成员
        animal2->makeSound();
    
        delete animal1;
        delete animal2;
    
        return 0;
    }

**运行结果：**

Meow!

在上述代码中，`Animal`类声明了纯虚函数`makeSound()`，派生类`Dog`和`Cat`分别提供了自己对这个函数的实现。

通过基类指针`animal1`和`animal2`来存储派生类对象，并调用`makeSound()`函数。由于`Cat`类中的`makeSound()`函数被定义为`private`，因此无法通过基类指针来访问它，而只能通过派生类对象直接访问。

### 4. 总结 ###

本文详细介绍了C++中的访问控制权限，以及在继承和多态中的应用。通过设置不同的访问权限，可以限制类成员的访问范围，保护数据的安全性和封装性。

在继承中，访问控制权限决定了派生类对基类成员的访问能力。在多态中，使用基类指针或引用可以限制对对象成员的访问。