Tukukkk

Last question, on StackOverflow.com about speeding vector.push_back and push_front was said to have it's place here. So here it is :

Well well well, looks like, after work, my regenerating reserve vector may not be so bad after all ? (in question "44326712/speeding-vector-push-back", I presented a vector with a regenerating reserve, faster at push_back when reserve cant be predicted).

Deque may be cool, but faster is the vector.

So I ameliorated my Vector, with two reserves : one before the begin and another after the end, thus, enabling push_front in a vector very quickly (push_back is still better than normal vector).

With a RESA of 8192, and 1000 push_front, I had this results (computer is a Lenovo Think Center):

duration old push_front == 199 ticks ("insert (v.begin () , s)")

duration new push_front == 5 ticks

And here is the Code of my Vector :

#ifndef __VECTOR2_HPP

#define __VECTOR2_HPP

#include <vector>

#include <iostream>

#include "Concept.hpp"

#include <exception>

#include <algorithm>



template <typename T>

class Vector : public std::vector<T> {

public :

  class Error : public std::exception {

  public :

    Error (std::string val = "") throw () : val_ (val) {}

    ~Error () throw () {}

    const char* what () throw () {

      std::string s ("Vector Error :");

      s += val_;

      return s.c_str();

    } 

  private :

    std::string val_;

  };

  typename std::vector<T>::iterator begin () {

    typename std::vector<T>::iterator i (std::vector<T>::begin ());

    i += lresa_;

    return i;

  }

  typename std::vector<T>::iterator end () {

    typename std::vector<T>::iterator i (std::vector<T>::end ());

    i -= rresa_;

    return i;

  }

  typename std::vector<T>::const_iterator begin () const {

    typename std::vector<T>::const_iterator i (std::vector<T>::begin ());

    i += lresa_;

    return i;

  }

  typename std::vector<T>::const_iterator end () const {

    typename std::vector<T>::const_iterator i (std::vector<T>::end ());

    i -= rresa_;

    return i;

  }

  typename std::vector<T>::reverse_iterator rbegin () {

    typename std::vector<T>::reverse_iterator i (std::vector<T>::rbegin ());

    i += rresa_;

    return i;

  }

  typename std::vector<T>::reverse_iterator rend () {

    typename std::vector<T>::reverse_iterator i (std::vector<T>::rend ());

    i -= lresa_;

    return i;

  }

  typename std::vector<T>::const_reverse_iterator rbegin () const {

    typename std::vector<T>::const_reverse_iterator i (std::vector<T>::rbegin ());

    i += rresa_;

    return i;

  }

  typename std::vector<T>::const_reverse_iterator rend () const {

    typename std::vector<T>::const_reverse_iterator i (std::vector<T>::rend ());

    i -= lresa_;

    return i;

  }

  Vector () : std::vector<T> (2*(size_t) Concept::RESA, T()), lresa_ ((size_t) Concept::RESA), rresa_ ((size_t) Concept::RESA) {

  }

  size_t size () const {

    size_t s (std::vector<T>::size ());

    s -= lresa_;

    s -= rresa_;

    return s;

  }

  Vector (int n, T t0) : std::vector<T> (n + 2*(size_t) Concept::RESA, t0), lresa_ ((size_t) Concept::RESA), rresa_ ((size_t) Concept::RESA) {

  }

  Vector (const Vector& v) : std::vector<T> (v), lresa_ (v.lresa_), rresa_ (v.rresa_) {

  }

  bool operator == (const Vector& v) const {

    return std::equal (begin (), end (), v.begin ());

  }

  bool operator != (const Vector& v) const {

    return !operator == (v);

  }

  T& operator  (const size_t &s) {

    return std::vector<T>::operator  (s+lresa_);

  }

  void push_front (const T& t) {

    if (!lresa_) {

      std::vector<T>::insert (std::vector<T>::begin (), (size_t) Concept::RESA, t);

      lresa_ = (size_t) Concept::RESA;

    }

    typename std::vector<T>::iterator i (std::vector<T>::begin ());

    i += lresa_ -1;

    *i = t;

    --lresa_;

  }

  void push_back (const T& t) {

    if (!rresa_) {

      std::vector<T>::insert (std::vector<T>::end (), (size_t) Concept::RESA, t);

      rresa_ = (size_t) Concept::RESA;

    }

    typename std::vector<T>::iterator i (std::vector<T>::end ());

    i -= rresa_;

    *i = t;

    --rresa_;

  }

  //can be optimized,but that s not the topic

  Vector& operator = (const Vector& v) {

    std::vector<T>::operator = (v);

    lresa_ = v.lresa_;

    rresa_ = v.rresa_;

    return *this;

  }

  //intelligent resize to do  

  //at the moment just stupid

  void resize (size_t n) {

    std::vector<T>::resize (n + lresa_ + rresa_);

  }

private :

  size_t lresa_;

  size_t rresa_;

};

#endif

What do you think about it ?