ArrayList c++ implementation

class ArrayList
{
public:
    ArrayList();
    ArrayList(int iSize, string sName);
    ArrayList(const ArrayList& obj);
    ~ArrayList();

    void add(int iElem);
    void add(int iIndex, int iElem);
    void remove(int iIndex);
    void clear();
    bool isEmpty();
    bool contains(int elem);
    int get(int iIndex);
    int size() { return iCounter;  }
    void toString();

    string getSName() { return sName; }
    int getILength() { return iLength; }
    int* getArray() { return pi_array; }
    ArrayList operator+ (const ArrayList& pcOther);
    void operator= (const ArrayList& pcOther);

private:
    void amortizedArrayUp();
    void amortizedArrayDown();
    void vSetValueAt(int offSet, int newValue);
    string sName;
    int iLength;
    int iCounter;
    int* pi_array;

};


ArrayList::ArrayList()
{
    pi_array = new int[DEFAULT_LENGTH];
    sName = DEFAULT_NAME;
    iLength = DEFAULT_LENGTH;
    iCounter = 0;
}

ArrayList::ArrayList(int iSize, string sName)
{
    pi_array = new int[iSize];
    this->sName = sName;
    iLength = iSize;
    iCounter = 0;
}

ArrayList::ArrayList(const ArrayList& pcOther)
{
    iLength = pcOther.iLength;
    iCounter = pcOther.iCounter;
    sName = pcOther.sName + "_copy";

    if (iLength > 1)
    {
        pi_array = new int[iLength];
        for (int i = 0; i < iLength; i++)
            pi_array[i] = pcOther.pi_array[i];
    }
    else
        cout << UNCORRECT_DATA << endl;

    if (DEBUG)  cout << COPY << endl;
    if (DEBUG)  cout << COPY << sName << endl;
}


ArrayList::~ArrayList()
{
    if (DEBUG) cout << DELETE << sName << endl;
    if (DEBUG) cout << DELETE << iLength << endl;
    delete[] pi_array;
}


void ArrayList::operator=(const ArrayList& obj)
{
    clear();

    for (int ii = 0; ii < obj.iCounter; ii++)
        add(obj.pi_array[ii]);

}


ArrayList ArrayList::operator+(const ArrayList& pcOther)
{
    ArrayList cont_list;

    for (int ii = 0; ii < iCounter+pcOther.iCounter ; ii++)
    {
        if (ii < iCounter)
            cont_list.add(pi_array[ii]);
        else
            cont_list.add(pcOther.pi_array[ii - iCounter]);
    }

    return cont_list;
}

int ArrayList::get(int iElem)
{
    if (iElem < iCounter && iElem > 0)
    return pi_array[iElem];
}

void ArrayList::add(int iElem)
{
    if (iCounter < iLength)
        pi_array[iCounter] = iElem;
    else
        amortizedArrayUp();
    pi_array[iCounter] = iElem;

    iCounter++;
}

void ArrayList::add(int iIndex, int iElem)
{
    if (iIndex < iCounter && iIndex > 0)
    {
        if (iCounter >= iLength)
            amortizedArrayUp();

        int* help_array = new int[iCounter - iIndex];

        for (int ii = iIndex; ii < iCounter; ii++)
            help_array[ii - iIndex] = pi_array[ii];

        pi_array[iIndex] = iElem;

        iCounter++;
        iIndex++;


        for (int ii = iIndex; ii < iCounter; ii++)
        {
            pi_array[ii] = help_array[ii - iIndex];
        }
        delete[] help_array;
    }
    else
        cout << UNCORRECT_DATA << endl;
}

void ArrayList::amortizedArrayUp()
{
    int* pi_new_tab = new int[iLength * INCREASE_FACTOR];

    for (int ii = 0; ii < iCounter; ii++)
        pi_new_tab[ii] = pi_array[ii];

    delete[] pi_array;
    iLength *= INCREASE_FACTOR;
    pi_array = pi_new_tab;
}

void ArrayList::amortizedArrayDown()
{
    int* pi_new_tab = new int[(int) iLength / DECREASE_FACTOR + 1];

    for (int ii = 0; ii < iCounter; ii++)
        pi_new_tab[ii] = pi_array[ii];

    delete[] pi_array;
    iLength = (int) iLength / DECREASE_FACTOR + 1;
    pi_array = pi_new_tab;
}

void ArrayList::toString()
{
    for (int ii = 0; ii < iCounter; ii++)
    {
        cout << (ii + 1) << ": " << (pi_array[ii]) << endl;
    }
}

bool ArrayList::contains(int iElem)
{
    for (int ii = 0; ii < iCounter; ii++)
        if (pi_array[ii] == iElem)
            return true;

    return false;
}

void ArrayList::remove(int iIndex)
{
    if (iIndex < iCounter && iIndex > 0)
    {
        iCounter--;

        for (int ii = iIndex--; ii < iCounter; ii++)
            pi_array[ii] = pi_array[ii + 1];
    }
    else
        cout << UNCORRECT_DATA << endl;

    if (iCounter < iLength / DECREASE_FACTOR && iCounter > DEFAULT_LENGTH)
        amortizedArrayDown();
}

void ArrayList::clear()
{
    string name = sName;
    delete[] pi_array;

    pi_array = new int[DEFAULT_LENGTH];
    iLength = DEFAULT_LENGTH;
    iCounter = 0;
    sName = name;
}

bool ArrayList::isEmpty()
{
    return iCounter == 0;
}