I am trying to merge two dynamic arrays but I am getting an error in my merge function that

"data': is not a member of 'List<T>"

I know that the error is ocuring because the given parameter in the merge(const List& other) is list but I am confused how to access my ArrayList2 which has been passed in merge function in the main

my code is:

#include <iostream>
using namespace std;
    template<class T>
    class List {
    public:
    // return the capacity of the list
    virtual size_t capacity() const = 0;

    // return the number of elements in the list
    virtual size_t size() const = 0;

    // inserts an element to the beginning
    virtual void push_front(const T& value) = 0;

    // adds an element to the end
    virtual void push_back(const T& value) = 0;

    // removes the last element
    virtual void pop_back() = 0;

    // removes the first element
    virtual void pop_front() = 0;

    // remove the first occurrence of an element with the given value
    virtual void remove(const T& val) = 0;

    // merges two sorted lists
    virtual void merge(const List<T>& other) = 0;

    virtual ~List() {}
};




template<class T>
class ArrayList : public List<T> 
{
private:
    T* data;
    size_t max_capacity;
    size_t num_of_element;

public:
    ArrayList() = delete;   // disable default constructor

    // constructor
    ArrayList(size_t capacity) : max_capacity(capacity), num_of_element(0) {
        data = new T[capacity];
    }

    // copy constructor
    ArrayList(const ArrayList<T>& other_list) : max_capacity(other_list.max_capacity),
        num_of_element(other_list.num_of_element) {
        data = new T[max_capacity];
        for (size_t i = 0; i < other_list.num_of_element; i  ) {
            data[i] = other_list.data[i];
        }
    }

    // destructor
    virtual ~ArrayList() {
        delete[]data;
    }

    size_t capacity() const override {
        return max_capacity;
    }

    size_t size() const override {
        return num_of_element;
    }

    T& operator[](int index) {
        return data[index];
    }

    bool operator==(const ArrayList<T>& other_list) {
        // not comparing capacity as eventually array list can be made capacity irrelevant using dynamic allocation
        if (num_of_element != other_list.num_of_element) {
            return false;
        }
        for (int i = 0; i < num_of_element; i  ) {
            if (data[i] != other_list.data[i]) {
                return false;
            }
        }
        return true;
    }

    void push_front(const T& value)
    {


    }

    void push_back(const T& value)
    {

        if (max_capacity > num_of_element)
        {
            num_of_element  ;
            data[num_of_element - 1] = value;
        }

    }

    void pop_back()
    {




    }

    void pop_front()
    {




    }

    void remove(const T& val)
    {
        int i = 0, j;
        while (i < max_capacity)
        {
            if (data[i] == val)
            {
                for (int j = i; j < num_of_element-1; j  )
                        data[j] = data[j   1];
                    
                if (data[i] == val && (i   1) > num_of_element - 1)
                {
                    data[i] = {};
                    num_of_element--;
                    break;
                }


                    

                    num_of_element--;
            }
           

            else
                i  ;
        }
    }
            
        


    

    void merge(const List<T>& other)
    {

        int i;
        int newsize = size()   other.size();
        T* temp = new T[newsize];
        for (i = 0; i < num_of_element; i  )
            temp[i] = data[i];
            for (int j = 0; j < other.size(); j  )
{
                temp[i] = other.data[j]; //I am getting error on this line
                i  ;
}



    }

private:
    
    void shift_left_to(size_t start) {
        for (size_t i = start; i < num_of_element - 1; i  ) {
            data[i] = data[i   1];
        }
    }
};




















int main() {

    ArrayList<int> list1(3);
   list1.push_back(3);
   list1.push_back(1);
   list1.push_back(1);

    ArrayList<int> list2(2);
    list2.push_back(1);
    list2.push_back(8);

    list1.merge(list2);


   /* for (size_t i = 0; i < list1.size(); i  ) 
        cout<<list1[i]<<" ";
    
    cout<<"Size:"<<list1.size()<<"  Capacity:"<<list1.capacity();*/

   
    system("pause");
    return 0;
}

CodePudding user response：

I'd say the message is quite descriptive: List does not have a member called data. You should use the [] operator instead to access the list elements in the merge function. [] operator is implemented by descendants of List.

temp[i] = other[j]

CodePudding user response：

Presumably, all of your concrete List<T> classes (e.g. ArrayList<T>) will have some kind of accessors to the elements. You can make those accessors part of the List<T> interface and call them in the implementation of void merge(List<T> const&). As an example:

template <class T>
class List {
   public:
    // ...
    virtual T& operator[](int index) = 0;
    virtual T const& operator[](int index) const = 0;
};

template <class T>
class ArrayList : public List<T> {
   private:
    T* data;
    size_t max_capacity;
    size_t num_of_element;

   public:
    // ...

    T& operator[](int index) override { return data[index]; }
    T const& operator[](int index) const override { return data[index]; }

    // ...

    void merge(const List<T>& other) {
        int i;
        int newsize = size()   other.size();
        T* temp = new T[newsize];
        for (i = 0; i < num_of_element; i  ) temp[i] = data[i];
        for (int j = 0; j < other.size(); j  ) {
            temp[i] = other[j];  // < Use your List<T>::operator[] here
            i  ;
        }
    }

    // ...
};