I have some doubts about my insert method. it is compiling, but with no result )). I presume that it is containing some coding errors. Can you help me resolving this? Thanks in advance.

private:
 T*             elements;
 int            capacity;
 int            nbElements;
 
 template <class T>
void TableDynamic<T>::insert(const T& element, int index)
 {

 int *temp = new int[capacity] ;
 for(int i =0; i<nbElements; i  )
         {
 temp[i] = element;
          }
  delete[] elements;
 int *elem = new int[capacite];

}

CodePudding user response：

I have written some code for you. see if its works for you.

#include <iostream>
using namespace std;

// insert element using template
template <class T>
class TableDynamic
{
private:
    T *elements;
    int capacity;
    int nbElements;

public:
    TableDynamic(int capacity)
    {
        this->capacity = capacity;
        this->nbElements = 0;
        this->elements = new T[capacity];
    }

    void insert(const T &element, int index)
    {
        if (index < 0 || index > nbElements)
        {
            cout << "Index out of range" << endl;
            return;
        }
        if (nbElements == capacity)
        {
            cout << "Table is full" << endl;
            return;
        }
        for (int i = nbElements; i > index; i--)
        {
            elements[i] = elements[i - 1];
        }
        elements[index] = element;
        nbElements  ;
    }

    void print()
    {
        for (int i = 0; i < nbElements; i  )
        {
            cout << elements[i] << " ";
        }
        cout << endl;
    }
};

int main()
{
    TableDynamic<int> table(10);
    table.insert(10, 0);
    table.insert(20, 1);
    table.insert(30, 2);
    // print the table
    table.print();

    return 0;
}

CodePudding user response：

temp and elem variables types should be T* , and in the last line you have wrote capacite, should be capacity

CodePudding user response：

Resizing should only be done, if the capacity is insufficient.

Furthermore you didn't copy any of the old elements over; you simply fill every element with the new element.

Also you're generating an array of ints regardless of element type which will only allow for element types int or const int.

The code should look something like this:

template <class T>
void TableDynamic<T>::insert(const T& element, int index)
{
    if ((index > nbElements) || (index < 0))
    {
        throw std::runtime_error("invalid index");
    }

    if ((nbElements   1) > capacity)
    {
        // reallocate array
        auto newCapacity = CalculateNewCapacity(capacity, nbElements   1); // todo: implement capacity calulation function

        auto temp = std::make_unique<T[]>(newCapacity);
        temp[index] = element; // note copying may result in an error, moving shouldn't, so copy first
        
        // move first half
        std::move(elements, elements   index, temp.get());
        // move second half
        std::move(elements   index, elements   nbElements, temp.get()   (index   1));

        // replace array
        delete[] elements;
        elements = temp.release();

        capacity = newCapacity;
    }
    else
    {
        // make room for new element
        std::move_backward(elements   index, elements   nbElements, elements   (nbElements   1));
        // insert new element
        elements[index] = element;
    }
      nbElements;
}