Dtk_tab< T > Class Template Reference

This is a high level array class. More...

Public Types
typedef const_pointer	const_iterator
typedef T const *	const_pointer
typedef pointer	iterator
typedef T *	pointer
typedef T	value_type

Public Member Functions
T &	at (Dtk_Size_t k)
const T &	at (Dtk_Size_t k) const
T &	back ()
	Return the elements at the end of the array. More...
const T &	back () const
	Return the elements at the end of the array. More...
iterator	begin ()
const_iterator	begin () const
Dtk_Size_t	capacity () const
	Returns the size of the storage space currently allocated for the array, expressed in terms of elements. More...
const_iterator	cbegin () const
const_iterator	cend () const
void	clear (int no_delete=0)
	Resets the Dtk_tab content. More...
T *	data ()
T const *	data () const
	Dtk_tab ()
	Default constructor. More...
	Dtk_tab (const Dtk_tab< T > &t)
	Dtk_tab (Dtk_Size_t initreservesize, int resize=0)
	Dtk_tab (Dtk_tab< T > &&t) DTK_NOEXCEPT
	Move constructor. More...
iterator	end ()
const_iterator	end () const
int	find (const T &e) const
template<typename comp >
int	find (const T &e, const comp &C) const
T &	front ()
	Return the elements at the beginning of the array. More...
const T &	front () const
	Return the elements at the beginning of the array. More...
const T *	GetArray () const
	Returns array of T elements. More...
Dtk_Size_t	GetSize () const
T	max_element () const
Dtk_Size_t	max_ithelement ()
T	min_element () const
Dtk_Size_t	min_ithelement ()
Dtk_tab &	operator+= (const Dtk_tab &t)
Dtk_tab &	operator+= (Dtk_tab &&t)
int	operator< (const Dtk_tab< T > &t) const
Dtk_tab &	operator= (const Dtk_tab< T > &t)
Dtk_tab< T > &	operator= (Dtk_tab< T > &&t) DTK_NOEXCEPT
	Move assignment operator. More...
int	operator== (const Dtk_tab< T > &t) const
T &	operator[] (Dtk_Size_t k)
	Accesses the ith element - like a classic array -. More...
const T &	operator[] (Dtk_Size_t k) const
void	pop_back ()
	Removes the last element. More...
void	push_back (const T &x)
	Inserts an element at the end of the array. More...
void	push_back (T &&x)
	Inserts an element by moving it at the end of the array. More...
void	reduce ()
void	remove (const T &a)
	Removes the first element with the value a. More...
void	reserve (Dtk_Size_t n)
void	resize (Dtk_Size_t n)
void	resize (Dtk_Size_t n, const T &t)
	Resizes the array. More...
void	reverse ()
Dtk_Size_t	size () const
	Returns the size of the array. More...
void	sort ()
	Swap two elements. More...
template<typename comp >
void	sort (const comp &C)
	Sorts the array with custom sorting. More...
Dtk_tab	subtab (Dtk_Size_t a, Dtk_Size_t b)
void	swap (const Dtk_Size_t inA, const Dtk_Size_t inB)
	Sorts the array. More...
	~Dtk_tab ()

Friends
std::ostream &	operator<< (std::ostream &o, const Dtk_tab &d)

Detailed Description

template<typename T>
class Dtk_tab< T >

This is a high level array class.

This class lets you use optimized arrays.

Member Typedef Documentation

const_iterator

template<typename T >

typedef const_pointer Dtk_tab< T >::const_iterator

const_pointer

template<typename T >

typedef T const* Dtk_tab< T >::const_pointer

iterator

template<typename T >

typedef pointer Dtk_tab< T >::iterator

pointer

template<typename T >

typedef T* Dtk_tab< T >::pointer

value_type

template<typename T >

typedef T Dtk_tab< T >::value_type

Constructor & Destructor Documentation

Dtk_tab() [1/4]

template<typename T >

Dtk_tab< T >::Dtk_tab

(

)

Default constructor.

Remarks

create an empty array

     {
          nb=0;
          rsv=0;
          v=NULL;
     }

Dtk_tab() [2/4]

template<typename T >

Dtk_tab< T >::Dtk_tab	(	Dtk_Size_t	initreservesize,
		int	resize = 0
	)

     {
          Pdtk_Assert(initreservesize>0);  // forbidden : at least one element on reserve.
          rsv=initreservesize;
          nb=0;
          if (resize)
               nb = rsv;
          if (rsv>0)
               v=new T[rsv];
          else
               v=NULL;
     }

~Dtk_tab()

template<typename T >

Dtk_tab< T >::~Dtk_tab

(

)

     {
          if (v!=NULL)
          {
               delete [] v;
               v=NULL;
          }
     }

Dtk_tab() [3/4]

template<typename T >

Dtk_tab< T >::Dtk_tab

(

const Dtk_tab< T > &

t

)

     {
//#ifdef DTK_DEBUG_STL_TRACE
//        FILE* F = fopen("/stltrace.txt","a");
//        fprintf(F,"Dtk_tab copy constructor size : %d ; elemsize : %d\n",t.size(),sizeof(T));
//        fclose(F);
//#endif
          nb=t.nb;
          rsv=t.nb; // shrink_to_fit while copy
          if (rsv>0)
          {
               Pdtk_Assert(nb > 0);
               v=new T[nb];
               for(Dtk_Size_t i=0;i<nb;i++)
                    v[i] = t.v[i];
          }
          else
               v=NULL;
     }

Dtk_tab() [4/4]

template<typename T >

Dtk_tab< T >::Dtk_tab

(

Dtk_tab< T > &&

t

)

Move constructor.

Parameters

t	the Dtk_tab to move

                                           : v(t.v), nb(t.nb), rsv(t.rsv)
     {
          t.v = 0;
          t.nb = 0;
          t.rsv = 0;
     }

Member Function Documentation

at() [1/2]

template<typename T >

T& Dtk_tab< T >::at

(

Dtk_Size_t

k

)

     {
          return operator[](k);
     }

at() [2/2]

template<typename T >

const T& Dtk_tab< T >::at

(

Dtk_Size_t

k

)

const

     {
          return operator[](k);
     } 

back() [1/2]

template<typename T >

T& Dtk_tab< T >::back

(

)

Return the elements at the end of the array.

Sample:

Dtk_tab<int> L; //we construct an array of int.
L.push_back(5);
L.push_back(35);
L.push_back(8);  // array is now : 5 - 35 - 8
int a = L.back();   // a is 8

     {
          Pdtk_Assert(nb!=0);
          return v[nb - 1];
     }

back() [2/2]

template<typename T >

const T& Dtk_tab< T >::back

(

)

const

Return the elements at the end of the array.

Sample:

Dtk_tab<int> L; //we construct an array of int.
L.push_back(5);
L.push_back(35);
L.push_back(8);  // array is now : 5 - 35 - 8
int a = L.back();   // a is 8

     {
          Pdtk_Assert(nb!=0);
          return v[nb - 1];
     }

begin() [1/2]

template<typename T >

iterator Dtk_tab< T >::begin

(

)

     {
          return v;
     }

begin() [2/2]

template<typename T >

const_iterator Dtk_tab< T >::begin

(

)

const

     {
          return v;
     }

capacity()

template<typename T >

Dtk_Size_t Dtk_tab< T >::capacity

(

)

const

Returns the size of the storage space currently allocated for the array, expressed in terms of elements.

This capacity is not necessarily equal to the size. It can be equal or greater. The capacity of the Dtk_tab can be explicitly altered by calling member Dtk_tab::reserve.

Sample:

Dtk_tab<int> tab; //we construct an array of int.
tab.reserve(5); //we reserve 5 element of type int.
tab.push_back(0); //we insert '0'
tab.push_back(2); //we insert '2'
tab.push_back(1); //we insert '1'
Dtk_Size_t size = tab.size(); //size is equal to 3
Dtk_Size_t capacity = tab.capacity(); //capacity is equal to 5

     {
          return rsv;
     }

cbegin()

template<typename T >

const_iterator Dtk_tab< T >::cbegin

(

)

const

     {
          return v;
     }

cend()

template<typename T >

const_iterator Dtk_tab< T >::cend

(

)

const

     {
          return v + nb;
     }

clear()

template<typename T >

void Dtk_tab< T >::clear

(

int

no_delete = 0

)

Resets the Dtk_tab content.

Remarks

If the Dtk_tab has pointers, theses ones aren't deleted.

Sample:

Dtk_tab<int> tab; //we construct an array of int.
tab.push_back(0); //we insert '0'
tab.push_back(2); //we insert '2'
tab.push_back(1); //we insert '1'
Now tab has 3 elements...
tab.clear(); //Now tab hasn't any element.

     {
          if (v==NULL)
               return;
          if (no_delete)
          {
               nb=0;
               return;
          }
          delete [] v;
          nb=0;
          rsv=0;
          v=NULL;
     }

data() [1/2]

template<typename T >

T* Dtk_tab< T >::data

(

)

{ return v; }

data() [2/2]

template<typename T >

T const* Dtk_tab< T >::data

(

)

const

{ return v; }

end() [1/2]

template<typename T >

iterator Dtk_tab< T >::end

(

)

     {
          return v + nb;
     }

end() [2/2]

template<typename T >

const_iterator Dtk_tab< T >::end

(

)

const

     {
          return v + nb;
     }

find() [1/2]

template<typename T >

int Dtk_tab< T >::find

(

const T &

e

)

const

     {
          for(Dtk_Size_t i=0;i<nb;i++) 
               if (v[i]==e) 
                    return (int)i;
          return -1;
     }

find() [2/2]

template<typename T >

template<typename comp >

int Dtk_tab< T >::find	(	const T &	e,
		const comp &	C
	)		const

     {
          for(Dtk_Size_t i=0;i<nb;i++) 
               if (!C(v[i],e) && !C(e,v[i])) 
                    return (int)i;
          return -1;
     }

front() [1/2]

template<typename T >

T& Dtk_tab< T >::front

(

)

Return the elements at the beginning of the array.

Sample:

Dtk_tab<int> L; //we construct a list of array.
L.push_back(5);
L.push_back(35);
L.push_back(8);  // array is now : 5 - 35 - 8
int a = L.front();   // a is 5

     {
          Pdtk_Assert(nb!=0);
          return v[0];
     }

front() [2/2]

template<typename T >

const T& Dtk_tab< T >::front

(

)

const

Return the elements at the beginning of the array.

Sample:

Dtk_tab<int> L; //we construct a list of array.
L.push_back(5);
L.push_back(35);
L.push_back(8);  // array is now : 5 - 35 - 8
int a = L.front();   // a is 5

     {
          Pdtk_Assert(nb!=0);
          return v[0];
     }

GetArray()

template<typename T >

const T* Dtk_tab< T >::GetArray

(

)

const

Returns array of T elements.

Remarks

You should call size () method to know returned array size.

     {
          return this->v;
     }

GetSize()

template<typename T >

Dtk_Size_t Dtk_tab< T >::GetSize

(

)

const

     {
          return 2*sizeof(Dtk_Size_t) + sizeof(T*) + rsv * sizeof(T);
     }

max_element()

template<typename T >

T Dtk_tab< T >::max_element

(

)

const

     {
          if (nb==0) 
               return T();
          T max = v[0];
          for(Dtk_Size_t i=0;i<nb;i++) 
               if (v[i]>max) 
                    max=v[i];
          return max;
     }

max_ithelement()

template<typename T >

Dtk_Size_t Dtk_tab< T >::max_ithelement

(

)

     {
          if (nb==0) 
               return 0;
          Dtk_Size_t imax = 0;
          T max = v[0];
          for(Dtk_Size_t i=0;i<nb;i++) 
               if (v[i]>max) 
               {
                    max=v[i];
                    imax = i;
               }
               return imax;
     }

min_element()

template<typename T >

T Dtk_tab< T >::min_element

(

)

const

     {
          if (nb==0) 
               return T();
          T min = v[0];
          for(Dtk_Size_t i=0;i<nb;i++) 
               if (v[i]<min) 
                    min=v[i];
          return min;
     }

min_ithelement()

template<typename T >

Dtk_Size_t Dtk_tab< T >::min_ithelement

(

)

     {
          if (nb==0) 
               return 0;
          Dtk_Size_t imin = 0;
          T min = v[0];
          for(Dtk_Size_t i=0;i<nb;i++) 
               if (v[i]<min) 
               {
                    min=v[i];
                    imin = i;
               }
               return imin;
     }

operator+=() [1/2]

template<typename T >

Dtk_tab& Dtk_tab< T >::operator+=

(

const Dtk_tab< T > &

t

)

     {
          if (t.nb==0) // empty 2nd
               return *this;
          rsv=nb+t.nb;
          if (v==NULL)
               v = new T[rsv];
          else
               delete [] _dtk_doublerealloc(rsv);
          for(Dtk_Size_t i=0;i<t.nb;i++) 
               v[i+nb] = t.v[i];
          nb=nb+t.nb;
          return *this;
     }

operator+=() [2/2]

template<typename T >

Dtk_tab& Dtk_tab< T >::operator+=

(

Dtk_tab< T > &&

t

)

     {
          if( t.nb == 0 )
               return *this;
          rsv = nb + t.nb;
          if( v == nullptr )
               v = new T[ rsv ];
          else
               delete[] _dtk_doublerealloc( rsv );
          for( Dtk_Size_t i = 0; i < t.nb; i++ )
               v[ i + nb ] = std::move( t.v[ i ] );
          nb = nb + t.nb;
          return *this;
     }

operator<()

template<typename T >

int Dtk_tab< T >::operator<

(

const Dtk_tab< T > &

t

)

const

     {
          Dtk_Size_t i;
          if (size()<t.size())
               return 1;
          if (t.size()<size())
               return 0;
          for(i=0;i<size();i++)
          {
               if ((v[i]<t.v[i]))
                    return 1;
               if ((t.v[i]<v[i]))
                    return 0;
          }
          return 0;
     }

operator=() [1/2]

template<typename T >

Dtk_tab& Dtk_tab< T >::operator=

(

const Dtk_tab< T > &

t

)

     {
          if (&t!=this)
          {
               if (v!=NULL)
               {
                    Pdtk_Assert(rsv>0);
                    delete [] v;
               }
               v=NULL;
               nb=t.nb;
               rsv=t.nb;
               if (t.v!=NULL && nb > 0)
               {
                    v=new T[nb];
                    for(Dtk_Size_t i=0;i<nb;i++)
                         v[i] = t.v[i];
               }
          } 
          return *this;
     }

operator=() [2/2]

template<typename T >

Dtk_tab<T>& Dtk_tab< T >::operator=

(

Dtk_tab< T > &&

t

)

Move assignment operator.

Parameters

t	the Dtk_tab to move

     {
          if(this != &t)
          {
               delete [] v;
               v = t.v;
               nb = t.nb;
               rsv = t.rsv;
               t.v = 0;
               t.nb = 0;
               t.rsv = 0;
          }
 
          return *this;
     }

operator==()

template<typename T >

int Dtk_tab< T >::operator==

(

const Dtk_tab< T > &

t

)

const

     {
          if (t<*this || *this<t)
               return 0;
          return 1;
     }

operator[]() [1/2]

template<typename T >

T& Dtk_tab< T >::operator[]

(

Dtk_Size_t

k

)

Accesses the ith element - like a classic array -.

Parameters

[in]

k

: The element position.

Warning

There isn't any check for the element position validity !!!

Sample:

Dtk_tab<int> tab; //we construct an array of int.
tab.push_back(0); //we insert '0'
tab.push_back(2); //we insert '2'
tab.push_back(1); //we insert '1'
// tab is {0,2,1}
int elt = tab[2]; //elt is equal to 1
tab[1] = 5; // tab is {0,5,1}
tab[5] = 5; // Error !!! The program will crash :(

     {
#ifdef _DEBUG_DTK
          if (k>=nb)
               Dtk_ThrowOverflowException();
#endif
          return v[k];
     }

operator[]() [2/2]

template<typename T >

const T& Dtk_tab< T >::operator[]

(

Dtk_Size_t

k

)

const

     {
#ifdef _DEBUG_DTK
          if (k>=nb)
               Dtk_ThrowOverflowException();
#endif
          return v[k];
     }

pop_back()

template<typename T >

void Dtk_tab< T >::pop_back

(

)

Removes the last element.

Sample:

Dtk_tab<int> tab; //we construct an array of int.
tab.push_back(0); //we insert '0'
tab.push_back(2); //we insert '2'
tab.push_back(1); //we insert '1'
Now tab is {0,2,1}...

     {
          Pdtk_Assert(nb!=0);
          if( nb == 0 ) {     Dtk_ThrowOverflowException(); }
          nb--;
     }  // extent : liberation a 1/3.

push_back() [1/2]

template<typename T >

void Dtk_tab< T >::push_back

(

const T &

x

)

Inserts an element at the end of the array.

Parameters

[in]

x

The element to insert.

Sample:

Dtk_tab<int> tab; //we construct an array of int.
tab.push_back(0); //we insert '0'
tab.push_back(2); //we insert '2'
tab.push_back(1); //we insert '1'
Now tab is {0,2,1}...

     {
          if (nb==rsv)
          {
               if (nb==0)
               {
                    rsv=1;
                    v = new T[1];
                    v[nb++]=x;
               }
               else
               {
                    rsv*=2;
                    T to_add;
                    to_add = x;
                    T* ex = _dtk_doublerealloc(rsv);
                    //v[nb++]=x;
                    v[ nb++ ] = to_add;
                    delete [] ex;
               }
          }
          else
               v[nb++]=x;
     }

push_back() [2/2]

template<typename T >

void Dtk_tab< T >::push_back

(

T &&

x

)

Inserts an element by moving it at the end of the array.

Parameters

[in]

x

The element to insert.

Sample:

Dtk_tab<int> tab; //we construct an array of int.
tab.push_back(0); //we insert '0'
tab.push_back(2); //we insert '2'
tab.push_back(1); //we insert '1'
Now tab is {0,2,1}...

     {
          if (nb==rsv)
          {
               if (nb==0)
               {
                    rsv=1;
                    v = new T[1];
                    v[nb++]=std::move(x);
               }
               else
               {
                    rsv*=2;
                    T* ex = _dtk_doublerealloc(rsv);
                    v[nb++]= std::move(x);
                    delete [] ex;
               }
          }
          else
               v[nb++]=std::move(x);
     }

reduce()

template<typename T >

void Dtk_tab< T >::reduce

(

)

     {
          if (rsv>nb)
          {
               rsv = nb;
               if (rsv==0)
                    rsv = 1;
               delete [] _dtk_doublerealloc(rsv);
          }
     }

remove()

template<typename T >

void Dtk_tab< T >::remove

(

const T &

a

)

Removes the first element with the value a.

Parameters

[in]

a

The value of the element that should be removed

Remarks

: The order of the elements of the tab won't be conserved, the last element is moved to the old position of the removed element

Sample:

Dtk_tab<int> tab; //we construct an array of int.
tab.push_back(0); //we insert '0'
tab.push_back(1); //we insert '1'
tab.push_back(2); //we insert '2'
tab.push_back(3); //we insert '3'
tab.remove(1); //Now tab is {0,3,2}
tab.remove(2); //Now tab is {0,3}

     {
          int pos = find( a );
          if( pos >= 0)
          {
            swap( pos, nb - 1 );
               pop_back();
          }
     }

reserve()

template<typename T >

void Dtk_tab< T >::reserve

(

Dtk_Size_t

n

)

     {
          if (n<=rsv) 
               return; 
          if (v==NULL)
          {
               Pdtk_Assert(rsv==0);
               v = new T[n];
               rsv = n;
               return;
          }
          rsv = n;
          delete [] _dtk_doublerealloc(rsv);
     }

resize() [1/2]

template<typename T >

void Dtk_tab< T >::resize

(

Dtk_Size_t

n

)

     {
          if (n<=nb) 
          {
               nb=n;
               return;
          } 
          if (n<=0) 
          {
               clear();
               return;
          }
          if (n<rsv)  // cas ou n>nb && n<rsv
          {
               nb = n;
               return;
          }
          if (v==NULL)
          {
               Pdtk_Assert(rsv==0);
               v = new T[n];
          }
          else
               delete [] _dtk_doublerealloc(n);
 
          nb=rsv=n;
     }

resize() [2/2]

template<typename T >

void Dtk_tab< T >::resize	(	Dtk_Size_t	n,
		const T &	t
	)

Resizes the array.

Parameters

[in]	n	The new size.
[in]	t	The filling element.

Remarks

If the new size is lower than the old one, the last elements are removed.

If the new size is greater than the old one, inserts t in the new elements.

Sample:

Dtk_tab<int> tab; //we construct an array of int.
tab.push_back(0); //we insert '0'
tab.push_back(2); //we insert '2'
tab.push_back(1); //we insert '1'
tab.resize(2); //Now tab is {0,2}
tab.resize(5,6); //Now tab is {0,2,6,6,6}

     {
          if (n<=nb) 
          {
               nb=n;
               return;
          } 
          if (n<=0) 
          {
               clear();
               return;
          }
          if (v==NULL)
          {
               Pdtk_Assert(rsv==0 && n>0);
               v = new T[n];
          }
          else
               delete [] _dtk_doublerealloc(n);
          for(Dtk_Size_t i=nb;i<n;i++) 
               v[i]=t;
          nb=rsv=n;
     }

reverse()

template<typename T >

void Dtk_tab< T >::reverse

(

)

{Dtk_Size_t i;for(i=0;i<nb/2;i++) Dtk_swap(v[i],v[nb-i-1]);}

size()

template<typename T >

Dtk_Size_t Dtk_tab< T >::size

(

)

const

Returns the size of the array.

Sample:

Dtk_tab<int> tab; //we construct an array of int.
tab.push_back(0); //we insert '0'
tab.push_back(2); //we insert '2'
tab.push_back(1); //we insert '1'
int size = tab.size(); //size is equal to 3

     {
          return nb;
     }

sort() [1/2]

template<typename T >

void Dtk_tab< T >::sort

(

)

Swap two elements.

Sample:

Dtk_tab<int> tab; //we construct an array of int.
tab.push_back(0); //we insert '0'
tab.push_back(2); //we insert '2'
tab.push_back(1); //we insert '1'
//tab is {0,2,1}
tab.swap(tab[0],tab[1]);
//tab is {2,0,1}

     {
          sort(Dtk_less<T>());
     }

sort() [2/2]

template<typename T >

template<typename comp >

void Dtk_tab< T >::sort

(

const comp &

C

)

Sorts the array with custom sorting.

Parameters

[in]

C

Comparison Functor

Remarks

Comparison functor need to be instanciated with default : use (). See sample.

Use a custom functor or one of the two internal functors available : Dtk_less (default) and Dtk_greater

Sample:

Dtk_tab<int> tab; //we construct an array of int.
tab.push_back(0); //we insert '0'
tab.push_back(2); //we insert '2'
tab.push_back(1); //we insert '1'
//tab is {0,2,1}
tab.sort(Dtk_greater<int>());
//tab is {2,1,0}

     {
          if(nb > 0 )
          {
               //_quicksort((int)0,(int)(nb-1),C);
               T* tmp = new T[nb];
               _mergesort(tmp,(int)0,(int)(nb-1),C);
               delete [] tmp;
          }
     }

subtab()

template<typename T >

Dtk_tab Dtk_tab< T >::subtab	(	Dtk_Size_t	a,
		Dtk_Size_t	b
	)

     {
          Pdtk_Assert(a<nb && b<nb && b>=a);
          Dtk_tab<T> res;
          res.resize(b-a+1);
          for(Dtk_Size_t i=0;i<res.rsv;i++) 
               res.v[i] = v[a+i];
          return res;
     }

swap()

template<typename T >

void Dtk_tab< T >::swap	(	const Dtk_Size_t	inA,
		const Dtk_Size_t	inB
	)

Sorts the array.

Sample:

Dtk_tab<int> tab; //we construct an array of int.
tab.push_back(0); //we insert '0'
tab.push_back(2); //we insert '2'
tab.push_back(1); //we insert '1'
//tab is {0,2,1}
tab.sort();
//tab is {0,1,2}

     {
#ifdef _DEBUG_DTK
          if ( inA >= nb || inB >= nb )
               Dtk_ThrowOverflowException();
#endif
          const T Tmp = v[ inA ];
          v[ inA ] = v[ inB ];
          v[ inB ] = Tmp;
     }

Friends And Related Function Documentation

operator<<

template<typename T >

std::ostream& operator<< ( std::ostream &  o, const Dtk_tab< T > &  d  )

friend

     {
          o<<"<Tab><Size>"<<d.size()<<"</Size>"<<std::endl;
          Dtk_Size_t i;
          for(i=0;i<d.size();i++)
          {
               o<<"<Elem_"<<i<<">"<< d[i] <<"</Elem_"<<i<<">"<<std::endl;
          }
          o << "</Tab>"<<std::endl;
          return o;
     }