任务描述 建立一个继承体系。List 是基类，ArrayList 和 LinkedList 是派生类。 List 提供 5 个函数，分别是增删查改显。其中，前 4 个是纯虚函数，第 5 个是虚函数。 用户需在 ArrayList 和 LinkedList 中编写实现相应的实现。 注意一条：在 ArrayList 中无需再实现显示函数。

好的，你的问题是关于建立继承体系的。你想要实现一个 List 基类，以及它的两个派生类 ArrayList 和 LinkedList。List 基类提供增、删、查、改和显五个函数，其中前四个是纯虚函数，第五个是虚函数。在 ArrayList 和 LinkedList 中，你需要实现相应的函数。在 ArrayList 中，无需再实现显示函数。

相关问题

建立一个继承体系。List 是基类，ArrayList 和 LinkedList 是派生类。 List 提供 5 个函数，分别是增删查改显。其中，前 4 个是纯虚函数，第 5 个是虚函数。 用户需在 ArrayList 和 LinkedList 中编写实现相应的实现。

好的，您需要建立一个继承体系，其中List是基类，而ArrayList和LinkedList是派生类，并且List提供了5个函数，其中前4个是纯虚函数，第5个是虚函数，您需要在ArrayList和LinkedList中分别实现相应的函数。为了实现这个任务，您可以按照以下步骤进行：

1. 创建一个名为List的基类，其中定义5个函数，前4个是纯虚函数，第5个是虚函数。如下所示：

class List {
public:
    virtual void add(int value) = 0;
    virtual void remove(int index) = 0;
    virtual int get(int index) const = 0;
    virtual void set(int index, int value) = 0;
    virtual void display() const;
};

2. 创建一个名为ArrayList的派生类，它继承自List类，并实现List类中定义的5个函数。ArrayList类应该包含一个数组来存储元素。如下所示：

class ArrayList : public List {
private:
    int* array;
    int size;
public:
    ArrayList(int size);
    ~ArrayList();
    void add(int value) override;
    void remove(int index) override;
    int get(int index) const override;
    void set(int index, int value) override;
    void display() const override;
};

3. 创建一个名为LinkedList的派生类，它继承自List类，并实现List类中定义的5个函数。LinkedList类应该包含一个链表来存储元素。如下所示：

class LinkedList : public List {
private:
    struct Node {
        int value;
        Node* next;
        Node(int value, Node* next = nullptr) : value(value), next(next) {}
    };
    Node* head;
public:
    LinkedList();
    ~LinkedList();
    void add(int value) override;
    void remove(int index) override;
    int get(int index) const override;
    void set(int index, int value) override;
    void display() const override;
};

4. 在ArrayList和LinkedList的构造函数中初始化成员变量。

5. 实现List类中定义的函数。在ArrayList中，add、remove、get和set函数可以通过数组的操作来实现。在LinkedList中，这些函数需要使用链表的操作来实现。display函数在两个派生类中都可以实现。

6. 最后，您可以创建一个测试函数，用于测试ArrayList和LinkedList的功能。例如：

int main() {
    List* list1 = new ArrayList(10);
    list1->add(3);
    list1->add(7);
    list1->set(0, 5);
    list1->remove(1);
    list1->display();
    delete list1;

    List* list2 = new LinkedList();
    list2->add(3);
    list2->add(7);
    list2->set(0, 5);
    list2->remove(1);
    list2->display();
    delete list2;

    return 0;
}

这样，您就可以建立一个继承体系，其中List是基类，ArrayList和LinkedList是派生类，并在ArrayList和LinkedList中实现相应的函数。

任务描述 建立一个继承体系，List 是基类，ArrayList 和 LinkedList 是其派生类。并且编写实现下述函数并达到如下效果。 ostream& operator << (ostream&os, const List&rhs); 做一个流输出运算符重载，其第二个参数是List的常引用类型。我们知道子类的对象天生可以作为父类类型使用，因此 ArrayList a; LinkedList b; operator << (cout,a); operator << (cout,b); 这上面的调

用会根据对象的实际类型调用对应的重载函数，从而实现输出不同派生类的对象的功能。下面是代码示例：

#include <iostream>
#include <vector>

using namespace std;

class List {
public:
    virtual void push_back(int val) = 0;
    virtual int size() const = 0;
    virtual int operator[](int index) const = 0;
};

class ArrayList : public List {
public:
    void push_back(int val) override {
        data.push_back(val);
    }
    int size() const override {
        return data.size();
    }
    int operator[](int index) const override {
        return data[index];
    }
private:
    vector<int> data;
};

class LinkedList : public List {
private:
    struct Node {
        int val;
        Node* next;
        Node(int v) : val(v), next(nullptr) {}
    };
    Node* head = nullptr;
    int len = 0;
public:
    void push_back(int val) override {
        if (!head) {
            head = new Node(val);
        } else {
            Node* cur = head;
            while (cur->next) {
                cur = cur->next;
            }
            cur->next = new Node(val);
        }
        ++len;
    }
    int size() const override {
        return len;
    }
    int operator[](int index) const override {
        Node* cur = head;
        while (index--) {
            cur = cur->next;
        }
        return cur->val;
    }
};

ostream& operator << (ostream& os, const List& rhs) {
    int n = rhs.size();
    os << "[";
    for (int i = 0; i < n; ++i) {
        if (i) os << ",";
        os << rhs[i];
    }
    os << "]";
    return os;
}

int main() {
    ArrayList a;
    a.push_back(1);
    a.push_back(2);
    a.push_back(3);
    cout << a << endl;

    LinkedList b;
    b.push_back(4);
    b.push_back(5);
    b.push_back(6);
    cout << b << endl;

    return 0;
}

输出结果：

[1,2,3]
[4,5,6]