Partial Code

main.cpp

#include <iostream>
#include "function.h"
using namespace std;
int main() {
    /* I/O optimization */
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);

    int t;
    cin >> t;
    while(t--) {
        int n;
        cin >> n;
        int *arr = new int[n + 1];
        for(int i=1;i<=n;i++)    cin >> arr[i];

        int q;
        cin >> q;
        Operation *ops = new Operation[q + 1];
        int op2Cnt = 0, op3Cnt = 0;
        for(int i=1;i<=q;i++) {
            cin >> ops[i].type;

            if(ops[i].type == 2) {
                cin >> ops[i].d;
                op2Cnt++;
            }
            else if(ops[i].type == 3) {
                op3Cnt++;
            }
        }

        ContainerBase *solver = create(n, arr, op2Cnt, op3Cnt);
        for(int i=1;i<=q;i++) {
            if(ops[i].type == 1)
                cout << solver->print() << '\n';
            else if(ops[i].type == 2)
                solver->move(ops[i].d);
            else if(ops[i].type == 3)
                solver->remove();
            else
                solver->reverse();
        }

        delete[] arr;
        delete[] ops;
        delete solver;
    }
    return 0;
}

function.h

#ifndef FUNCTION_H
#define FUNCTION_H

/* an abstract class for the container used in this problem */
class ContainerBase {
    public:
        /* for the first-type operation */
        virtual int print() = 0;
        /* for the second-type operation */
        virtual void move(int) = 0;
        /* for the third-type operation */
        virtual void remove() = 0;
        /* for the fourth-type operation */
        virtual void reverse() = 0;
        int getSize() { return size; }

        virtual ~ContainerBase() {}
    protected:
        int size;    // the number of elements(people) in the container
        bool rev;    // record whether the row need to be reversed or not
};

/* array class deriving from ContainerBase */
class Array final : public ContainerBase {
    public:
        Array() {}
        Array(int n, int *arr) {
            size = n;

            mem = new int[size + 1];
            for(int i=1;i<=size;i++)    mem[i] = arr[i];
            cur = 1;

            rev = false;
        }

        virtual int print() override { return mem[cur]; }
        /* TODO */
        virtual void move(int) override;
        /* TODO */
        virtual void remove() override;
        /* TODO */
        virtual void reverse() override;

        ~Array() { delete[] mem; }
    private:
        int *mem;    // array for maintaining all the elements(the happy value of all the people)
        int cur;    // record who is carrying the ball
};

/* doubly linked list class deriving from ContainerBase */
class List final : public ContainerBase {
    public:
        List() {}
        List(int n, int *arr) {
            size = n;

            cur = new Node(arr[1]);
            Node *back = cur;
            for(int i=2;i<=n;i++) {
                Node *newNode = new Node(arr[i]);
                back->insertBack(newNode);
                back = newNode;
            }

            rev = false;
        }

        virtual int print() override { return cur->val; }
        /* TODO */
        virtual void move(int) override;
        /* TODO */
        virtual void remove() override;
        /* TODO */
        virtual void reverse() override;

        ~List() { for(int i=1;i<=size;i++)    cur = cur->remove(); }
    private:
        /* nested class for the node in linked list */
        class Node {
            public:
                Node *pre, *nxt;
                int val;

                Node() {}
                Node(int newVal) : pre(nullptr), nxt(nullptr), val(newVal) {}
                /* insert a new node after the current node */
                void insertBack(Node *newNode) {
                    nxt = newNode;
                    newNode->pre = this;
                }
                /* remove the current node and return the next node(or the previous node if the next node doesn't exist) */
                Node* remove(bool preFirst=false) {
                    Node *ret = (nxt == nullptr ? pre : nxt);
                    if(preFirst && pre != nullptr)    ret = pre;
                    if(pre != nullptr)    pre->nxt = nxt;
                    if(nxt != nullptr)    nxt->pre = pre;
                    delete this;
                    return ret;
                }
        } *cur;    // record who is carrying the ball
};

/* a class for operation */
class Operation {
    public:
        int type,d;
};

/* TODO: create array/linked list based on the number of the second-type and the third-type operations. then return it */
ContainerBase* create(int, int*, int, int);

#endif

Implement the seven functions: Array::move, Array::remove, Array::reverse, List::move, List::remove, List::reverse, and create.

To reduce your coding time, you could refer to the following code :P

function.cpp

#include "function.h"

void Array::move(int d) {
}

void Array::remove() {
}

void Array::reverse() {
}

void List::move(int d) {
}

void List::remove() {
}

void List::reverse() {
}

ContainerBase* create(int n, int *arr, int op2Cnt, int op3Cnt) {
}