AnimaL

Tutorial

Documentation

---

Documentation

• Overview
• Modules
• Namespace List
• Class Hierarchy
• Alphabetical List
• Compound List
• File List
• Namespace Members
• Compound Members
• File Members
• Examples

---

vector.h

Go to the documentation of this file.

#ifndef ANIMAL_VECTOR_H
#define ANIMAL_VECTOR_H

#include <vector>
#include <algorithm>
#include <cassert>

namespace animal {

//======================================================================
//======================================================================
template<
    class T, 
    class Alloc = std::allocator<T>
    > 
class vector: public std::vector<T,Alloc> 
{
public:

    typedef typename std::vector<T,Alloc>::size_type size_type;
    typedef typename std::vector<T,Alloc>::reference reference;
    typedef typename std::vector<T,Alloc>::const_reference const_reference;

  vector() : std::vector<T,Alloc>() {}
  vector(size_type n, const T& value): std::vector<T,Alloc>(n,value) {}
  vector(int n, const T& value): std::vector<T,Alloc>(n,value) {}
  vector(long n, const T& value): std::vector<T,Alloc>(n,value) {}
  explicit vector(size_type n): std::vector<T,Alloc>(n) {}
  vector(const std::vector<T, Alloc>& x): std::vector<T,Alloc>(x) {}
  vector<T, Alloc>& operator=(const std::vector<T, Alloc>& x) 
    {
        std::vector<T,Alloc>::operator = (x);
        return (*this);
  }

#ifdef __STL_MEMBER_TEMPLATES

  template <class InputIterator>
  vector(InputIterator first, InputIterator last): std::vector<T,Alloc>(first,last){}
#else /* __STL_MEMBER_TEMPLATES */

  vector(typename animal::vector<T,Alloc>::const_iterator first, typename animal::vector<T,Alloc>::const_iterator last): std::vector<T,Alloc>(first,last){}
#endif /* __STL_MEMBER_TEMPLATES */


reference operator[](size_type n) { 
#ifndef NDEBUG
    assert( n<this->size() );
#endif
    return *(this->begin() + n); 
  }

const_reference operator[](size_type n) const { 
#ifndef NDEBUG
    assert( n<this->size() );
#endif
    return *(this->begin() + n); 
  }

inline friend std::ostream& operator<< ( std::ostream& os, const std::vector<T,Alloc>& vec )
{
    if( vec.size()>0 ){
        for( unsigned int i=0; i<vec.size()-1; ++i ) os<<vec[i]<<" ";
        os<<vec[vec.size()-1];
    }
    return os;
}

};
// ======================  operations on standard vectors

// -----------------------------------------------------------
//  
//  
// -----------------------------------------------------------

template<class T, class TT> 
void remove( std::vector<T,TT>& v, const T& elem )
{
    typename vector<T>::iterator e = std::find( v.begin(), v.end(), elem );
    if( e != v.end() ){
        typename vector<T>::iterator next = e;
        next++;
        for( ; next != v.end(); ++e, ++next )
            *e = *next;
    }
        v.pop_back();
}

template<class T, class TT> 
void removeValue( std::vector<T,TT>& v, const T& elem )
{
    typename vector<T>::iterator e = std::find( v.begin(), v.end(), elem );
    if( e != v.end() ){
        *e = v.back();
        v.pop_back();
    }
}

template<class T, class TT> 
void removeIndex( std::vector<T,TT>& v, size_t index )
{
#ifndef NDEBUG
    assert( 0<= static_cast<int>(index) && index <v.size() );
#endif
    v[index] = v.back();
    v.pop_back();
}


// /// Dot product of two containers
// template<class C>
// C dot( const C& v1, const C& v2 )
// {
//  C res = 0;
//  typename C::const_iterator i1=v1.begin(), iend, i2=v2.begin();
//  for( iend=v1.end(); i1!=iend; ++i1, ++i2 )
//      res += *i1 * *i2;
//  return res;
// }





} // ==============================   end namespace animal



#endif

---