Generikus dinamikus tömb készítése

// Vector.h
#ifndef VECTOR_H
#define VECTOR_H

#include <iostream>
#include <exception>

// generikus dinamikus tomb osztaly
template<class T>
class Vector {
 unsigned elementNum; // a tomb merete
 T *pData; // az adatokra mutato pointer

public:
 // konstruktorok, destruktor
 Vector() { elementNum = 0; pData = 0; }
 Vector(const Vector &theOther) { pData = 0; *this = theOther; }
 ~Vector() { delete[] pData; }

 // beszur egy elemet a megadott indexu helyre
 // ha az index nagyobb, mint a tomb merete, megnoveli a tomb meretet,
 // és a szukseges uj helyeket nullakkal tolti fel
 void insert(unsigned position, const T &element);

 // torli a megadott indexu elemet, a 0 és size()-1 kozotti indexek ervenyesek
 void erase(unsigned position);

 // logikai igaz erteket ad vissza, ha az adott elem benne van a tombben
 bool isElement(const T &element) const;

 // ertekado operator felulirasa
 Vector &operator=(const Vector &theOther);
};

template<class T>
void Vector<T>::insert(unsigned position, const T &element) {
  // kezeljuk azt az esetet is amikor az utolso tag után szurjuk be az uj elemet
  unsigned NewSize = (position < elementNum) ? (elementNum + 1) : (position + 1);
  T *pTemp = new T[NewSize];

  for (unsigned i = 0, j = 0; j < NewSize; i++, j++) {
    if (j == position) {
      i--;
    } else {
      pTemp[j] = (i < elementNum) ? pData[i] : 0;
    }
  }

  pTemp[position] = element;
  delete[] pData;
  pData = pTemp;
  elementNum = NewSize;
}

template<class T>
void Vector<T>::erase(unsigned position) {
  if (position >= elementNum) {
    throw std::exception("Hibas index!");
  }

  // kezelnünk kell azt is amikor a vektor egyetlen elemét töröljük
  T *pTemp = elementNum > 1 ? new T[elementNum - 1] : 0;

  for (unsigned i = 0, j = 0; i < elementNum; i++, j++) {
    if (i == position) {
      j--; // a törlendő elemet nem másoljuk át
    } else {
      pTemp[j] = pData[i];
    }
  }

  delete[] pData;
  pData = pTemp;
  elementNum--;
}

// logikai igaz erteket ad vissza, ha az adott elem benne van a tombben
template<class T>
bool Vector<T>::isElement(const T &element) const {
 for (unsigned i = 0; i < elementNum; i++) {
  if (pData[i] == element) {
   return true;
  }
 }

 return false;
}

template<class T>
Vector<T> &Vector<T>::operator=(const Vector &theOther) {
  if (this == &theOther) {
    return *this;
  }

  delete[] pData;

  if ((elementNum = theOther.elementNum) == 0) {
    pData = 0;
  } else {
    pData = new T[elementNum];
    for (unsigned i = 0; i < elementNum; i++) {
      pData[i] = theOther.pData[i];
    }
  }

  return *this;
}

#endif // VECTOR_H



// Main.cpp
#include <iostream>
#include "Vector.h"
using namespace std;


int main() {
 int elements[] = {2, 7, 5, 9, 0, 1, 3};
 Vector<int> V1;

 for (unsigned i = 0; i < sizeof(elements) / sizeof(elements[0]); i++) {
  V1.insert(0, elements[i]);
 }

 Vector<int> V2 = V1;
 V1.erase(0);

 cout << V1.isElement(3) << endl;
 cout << V2.isElement(3) << endl;
 
 return 0;
}

// Kovetelmenyek a tarolando tipussal szemben:
// - legyen alapertelmezett konstruktora (tomb foglalasakor a default konstruktora hivodik meg a tipusnak)
// - az ertekado operator (operator=) helyesen mukodjon a tipussal
// - az egyenloseget vizsgalo operator(operator==) helyesen mukodjon a tipussal