【C++多态性应用】：std::stack在继承中的栈操作实现

# 1. C++多态性的基础理论

C++中的多态性是面向对象编程的核心概念之一，它允许程序员以统一的方式处理不同的对象类型。简单来说，多态性意味着可以使用基类的指针或引用来指向派生类的对象，并通过这些基类的接口来执行操作，具体执行哪个对象的哪种操作将由程序在运行时决定。在C++中，多态性主要通过继承和虚函数实现。

在本章节中，我们将首先介绍多态性的基本概念和原理，然后深入探讨它在C++中的实现方式。我们将会看到虚函数的作用，以及它是如何在继承体系中实现动态绑定的。通过本章的学习，读者将能够理解并掌握如何在C++中利用多态性来设计更加灵活和可扩展的代码。

# 2. std::stack的标准用法和原理

## 3.1 基类和派生类的栈操作封装

### 3.1.1 基类的栈操作实现

在C++标准库中，`std::stack`容器适配器提供了一种后进先出（LIFO, Last In First Out）的数据结构。为了理解`std::stack`的用法和原理，我们将首先通过基类展示如何实现栈操作。

#include <stack>
#include <iostream>

template <typename T>
class Stack {
private:
    std::stack<T> st;

public:
    bool empty() const {
        return st.empty();
    }

    size_t size() const {
        return st.size();
    }

    void push(const T& value) {
        st.push(value);
    }

    void pop() {
        st.pop();
    }

    T& top() {
        ***();
    }
};

在这个基类的实现中，我们使用了模板以允许栈操作不同的数据类型。我们定义了一个私有成员变量`std::stack<T> st`，并通过成员函数提供了`empty`、`size`、`push`、`pop`和`top`等接口。

**逻辑分析：**
`std::stack`容器适配器的内部实现并不公开，但我们可以知道它是基于另一种容器实现的，比如`std::deque`或者`std::vector`。通过这些操作函数，我们实现了基本的栈操作。

### 3.1.2 派生类的栈操作重载

为了展示继承中的多态性，我们可以创建一个派生类并重载其中的栈操作。

class DerivedStack : public Stack<int> {
public:
    void push(int value) override {
        std::cout << "Derived push: " << value << std::endl;
        Stack<int>::push(value);
    }

    void pop() override {
        std::cout << "Derived pop" << std::endl;
        Stack<int>::pop();
    }
};

我们重载了`push`和`pop`函数来添加额外的输出，以证明函数确实被重载了。需要注意的是，我们需要显式地调用基类的`push`和`pop`函数来确保基类栈操作的完整性。

**逻辑分析：**
派生类中的函数通过`override`关键字声明，这不仅是对基类方法的重写，也是向编译器声明我们期望实现多态性的意图。注意，我们在派生类中添加了对基类成员函数的调用，这是实现基类功能所必需的。

## 3.2 动态多态性的实现机制

### 3.2.1 虚函数和动态绑定

动态多态性在C++中主要通过虚函数和动态绑定来实现。我们将在派生类中将函数声明为虚函数，允许在运行时根据对象的实际类型来调用相应的函数。

class BaseStack {
public:
    virtual void push(int value) {
        std::cout << "Base push: " << value << std::endl;
    }

    virtual void pop() {
        std::cout << "Base pop" << std::endl;
    }
};

class DerivedStack : public BaseStack {
public:
    void push(int value) override {
        std::cout << "Derived push: " << value << std::endl;
        BaseStack::push(value);
    }

    void pop() override {
        std::cout << "Derived pop" << std::endl;
        BaseStack::pop();
    }
};

在这里，`BaseStack`中的`push`和`pop`函数被声明为虚函数。派生类`DerivedStack`中的同名函数使用`override`关键字，实现了对基类虚函数的重写。

**逻辑分析：**
当通过基类指针或引用来操作派生类对象时，C++编译器会在运行时根据对象的实际类型来调用相应的方法，这是通过虚函数表（vtable）实现的。`override`关键字有助于确保派生类中的函数签名与基类中的虚函数签名一致。

### 3.2.2 纯虚函数和抽象类

纯虚函数在基类中未定义，需在派生类中实现。具有纯虚函数的类被称为抽象类，不能直接实例化。

class AbstractStack {
public:
    virtual void push(int value) = 0;
    virtual void pop() = 0;

    virtual ~AbstractStack() {}
};

class ConcreteStack : public AbstractStack {
public:
    void push(int value) override {
        // 实现具体操作
    }

    void pop() override {
        // 实现具体操作
    }
};

在此示例中，`AbstractStack`是一个抽象类，拥有两个纯虚函数`push`和`pop`。`ConcreteStack`继承自`AbstractStack`并实现了这两个纯虚函数。

**逻辑分析：**
纯虚函数通过在函数声明末尾添加`= 0`来定义，这样基类就变成了抽象类。当存在纯虚函数时，派生类必须提供具体的实现，否则派生类也会变成抽象类。

### 3.2.3 多态性在继承中的应用

多态性使得同一接口可以使用不同的实例而实现不同的功能。它允许将派生类对象作为基类对象来处理。

void stackUsage(AbstractStack& stack) {
    stack.push(10);
    stack.pop();
}

int main() {
    ConcreteStack cStack;
    stackUsage(cStack);  // 使用多态性
    return 0;
}

在这个例子中，`stackUsage`函数接受一个`AbstractStack`类型的引用参数。尽管`ConcreteStack`是一个具体类，我们可以将其作为`AbstractStack`类型传递给`stackUsage`函数。在运行时，C++编译器确定调用哪个版本的`push`和`pop`函数。

**逻辑分析：**
多态性的核心在于基类指针或引用可以指向派生类对象，而虚函数允许在运行时调用正确的派生类函数。这在处理多种类型的数据时提供了灵活性和可扩展性。

## 3.3 std::stack在继承中的应用

### 3.3.1 std::stack的模板特性

`std::stack`的模板特性使得它可以支持不同类型的元素，这在继承中可以体现为能够操作不同类型的派生类数据。

template <typename T, typename Container = std::deque<T>>
class Stack : private Container {
    // ...
};

上述代码段显示了`std::stack`模板声明的一个简化的版本。通过这种方式，我们可以使用任何容器来实现栈，包括那些可以被派生和自定义的容器。

### 3.3.2 std::stack在派生类中的自定义行为

我们可以在派生类中实现`std::stack`的自定义行为，包括如何处理元素的存储。

template <typename T>
class MyStack : public std::stack<T> {
public:
    void pushCustom(const T& value) {
        // 自定义push操作
        this->c.push_back(value);
    }

    // 其他自定义函数...
};

这里`MyStack`继承自`std::stack<T>`，我们可以添加额外的函数，比如`pushCustom`，以定制`push`操作。

**逻辑分析：**
继承自`std::stack<T>`允许我们访问其成员变量和函数，并可以添加新的成员函数。模板允许我们针对特定类型进行定制。

### 3.3.3 案例分析：栈操作的多态性实现

我们来看一个完整的案例，展示`std::stack`如何在继承中实现多态性。

#include <iostream>
#include <stack>

template <typename T>
class StackAdapter {
private:
    std::stack<T> st;

public:
    void push(const T& value) {
        st.push(value);
    }

    T& top() {
        ***();
    }

    void pop() {
        st.pop();
    }
};

class CustomStack : public StackAdapter<int> {
public:
    void push(int value) override {
        std::cout << "CustomStack push: " << value << std::endl;
        StackAdapter<int>::push(value);
    }
};

int main() {
    CustomStack customStack;
    customStack.push(1);
    std::cout << "Top element: " << ***() << std::endl;
    customStack.pop();
    return 0;
}

在这个案例中，我们定义了一个`StackAdapter`模板类和继承自它的`CustomStack`类。`CustomStack`重写了`push`方法，在调用基类`push`之前执行了额外的操作。

**逻辑分析：**
通过定义模板类和继承，我们展示了如何在保持`std::stack`不变的情况下，为特定类型提供自定义行为。这利用了C++模板和继承提供的多态性。

# 3. 继承中的多态性应用实践

在C++中，继承是实现多态性的一种主要手段。它允许我们创建一个类（称为派生类）来继承另一个类（称为基类）的属性和行为。派生类可以覆盖（override）基类中的某些行为，而多态性允许我们使用基类指针或引用来调用派生类的方法。这种能力是面向对象编程的基石之一，它提高了代码的可扩展性和可维护性。

## 3.1 基类和派生类的栈操作封装

在本小节中，我们将探讨如何在基类和派生类中封装和实现栈操作，并为继承中的多态性应用奠定基础。

### 3.1.1 基类的栈操作实现

首先，我们定义一个基类，比如叫 `Stack`，来实现一些通用的栈操作。这里我们使用 `std::vector` 作为内部容器来存储栈元素。

#include <vector>
#include <iostream>

class Stack {
protected:
    std::vector<i