vector.h

/*
 * STL vector implementation
 */

template<typename Data> class vector {
  size_t d_size;     // Stores no. of actually stored objects
  size_t d_capacity; // Stores allocated capacity
  Data *d_data;      // Stores data
  public:
    vector() : d_size(0), d_capacity(0), d_data(0) {
    
    };
    
    vector( vector const &other) : d_size(other.d_size), 
                                   d_capacity(other.d_capacity), 
                                   d_data(0) 
    { 
      d_data = (Data *)malloc(d_capacity*sizeof(Data)); 
      memcpy(d_data, other.d_data, d_size*sizeof(Data)); 
    };
    
    ~vector() { 
      free(d_data); 
    };

    /*
     * Reserve N positions on the vector
     * to save memory and time with push backs
     * empties old vector
     */
    void reserve(int nItems){
      if(d_data != NULL){
        free(d_data);
      }
      d_capacity = nItems;
      d_data = (Data *)malloc(nItems*sizeof(Data));
      d_size = nItems;
    }
    
    vector &operator=(vector const &other) { 
      free(d_data); 
      d_size = other.d_size; 
      d_capacity = other.d_capacity; 
      d_data = (Data *)malloc(d_capacity*sizeof(Data)); 
      memcpy(d_data, other.d_data, d_size*sizeof(Data)); 
      return *this; 
    };

    void push_back(Data const &x) { 
      if (d_capacity == d_size) resize(); 
      d_data[d_size++] = x; 
    }; // Adds new value. If needed, allocates more space


    void pop(){
      if(d_size>0)
        d_size--;
    }

    void remove(int i){
      if(i < d_size){
        int ncopy = d_size - (i+1); //number of elements to copy
        memcpy( &(d_data[i]), &(d_data[i+1]), ncopy * sizeof(Data));
        d_size--; //remove last elementX
      }
    }
    
    size_t size() const { 
      return d_size; 
    };
    
    Data const &operator[](size_t idx) const { 
      return d_data[idx]; 
    };
    
    Data &operator[](size_t idx) { 
      return d_data[idx]; 
    };
  private:
    void resize() { 
      d_capacity = d_capacity ? d_capacity*2 : 1; 
      Data *newdata = (Data *)malloc(d_capacity*sizeof(Data)); 
      memcpy(newdata, d_data, d_size * sizeof(Data)); 
      free(d_data); d_data = newdata; 
    };
};