Dynamische array-Klasse in c++

Schreibe ich einen dynamischen array-Klasse. Ich habe einen copy-Konstruktor und operator= - Funktion, mir zu erlauben, weisen Sie einem array zu einem anderen. Es funktioniert, wenn ich zuweisen von arrays, die die gleiche Länge der anderen, aber wenn Sie unterschiedliche Längen haben, bekomme ich die compiler-memory-Warnungen und/oder der code-Bomben, ohne Sie auszuführen, je nachdem, ob der linken-array ist größer als der Rechte-hand-array, und Umgekehrt. Ich habe eine Funktion, fügt Werte in das array und denke, dass das Problem vielleicht hier liegen (Anmerkung: ich habe einen Kommentar aus dem Speicher löschen innerhalb der Destruktor für den code gehen).

class Array
{
    private:
    int * ptr;
    int size; 
    int numElement;

public:
    Array();
    Array(const int*, int);
    Array(const Array&);
    ~Array();
    void setValueAtIndex(int, int);
    void insertValueAtEnd(int ); 
    int getArraySize();
    const Array& operator=(const Array& );  
};

#include "array.h"
#include <stdlib.h>
#include <iostream>
using namespace std;

Array::Array()
{
  size = 10;
  numElement = 0;
  ptr = new int[size];
  for (int i = 0; i < size; ++i)
  {
    ptr[i] = 0;
  }
}

Array::Array(const int * ptr_, int size_)
{
  size = size_;
  numElement = size;
  ptr = new int[numElement];
  for (int i = 0; i < size; ++i)
  {
    ptr[i] = ptr_[i];
  }
}

Array::Array(const Array& other)
{
  size = other.size;
  numElement = other.numElement;
  if (other.ptr)
  {    
      ptr = new int[numElement];
      for(int i = 0; i < size; ++i)
      {
        ptr[i] = other.ptr[i];
      }
      if(!ptr)
      {
        exit(EXIT_FAILURE);
      }
  }
  else ptr = 0;
}

Array::~Array()
{
  if(ptr)
  {
   //delete [] ptr;
   //ptr = 0;
  }
}

void Array::setValueAtIndex(int a, int b)
{
  if(b > size)
  {  
      exit(EXIT_FAILURE);
  }
  ptr[b] = a;
}

void Array::insertValueAtEnd(int insert)
{
  if(numElement == size)
  {
      size++;
  } 
  ptr[size-1] = insert;
  numElement++;
}

int Array::getArraySize()
{
  return size;
}

const Array& Array::operator=(const Array& other)
{    
    if(this != &other)
    {
     if (ptr)
     {
       delete [] ptr;
      ptr = 0;
     }
     numElement = other.numElement;
     size = other.size;
     if(other.ptr)
     {
       ptr = new int[numElement];
       for(int i = 0; i < size; ++i)
       {
         ptr[i] = other.ptr[i]; 
       }
     }
     else ptr = 0;
    }
    return *this;
}

InformationsquelleAutor cadebe | 2013-09-15