Array.h

Aller à la documentation de ce fichier.

/*! \file Array.h
    \brief Tableaux dynamiques.

    Tableaux dynamique à allocation par block (plus robuste que vector).

    \author     aerith (http://aerith.fr)
    \version    1.0
    \date       05/06/2008
*/

#ifndef INCLUDE_RSRC_ARRAY
#define INCLUDE_RSRC_ARRAY

#include    <malloc.h>

#define     ARRAY_DEF_ALLOC     1000                /*!< Taille par défaut d'une allocation.                */
#define     ARRAY_DEF_DEALLOC   500                 /*!< Taille par défaut d'une désallocation.             */
#define     ARRAY_DEF_MAX       100000000           /*!< Taille max par défaut.                             */

//! Tableaux dynamique.
/*! Tableaux dynamique à allocation par block (plus robuste que vector).
*/
template <class T>
class Array
{
private :
    unsigned int                allocBlockSize;     /*!< Taille d'un block d'allocation.                    */
    unsigned int                deallocBlockSize;   /*!< Taille d'un block de désallocation.                */
    unsigned int                maxSize;            /*!< Taille max du tableaux.                            */
    T                           *tab;               /*!< Chaque lignes est une donnée.                      */
    unsigned int                allocatedSize;      /*!< Taille allouée.                                    */
    unsigned int                nbDatas;            /*!< Nombre de donnée.                                  */
    unsigned int                begin;              /*!< Début des données.                                 */
    long int                    end;                /*!< Fin des données.                                   */

public  :
    /*! Initialise avec des paramètres par défauts.
        \param iMaxSize taille max du tableau
        \param iAllocSize taille d'un block d'allocation
        \param iDeallocSize taille d'un block de désallocation
    */
    Array(unsigned int iMaxSize = ARRAY_DEF_MAX, unsigned int iAllocSize = ARRAY_DEF_ALLOC, unsigned int iDeallocSize = ARRAY_DEF_DEALLOC)
    {
        allocBlockSize      = iAllocSize;
        deallocBlockSize    = iDeallocSize;
        maxSize             = iMaxSize;
        tab                 = NULL;
        allocatedSize       = 0;
        nbDatas             = 0;
        begin               = 0;
        end                 = -1;
    };

    /*! Libere proprement la mémoire.
    */
    ~Array()
    {
        if(tab)
            free(tab);
    };

    //! Ajoute un élément.
    /*! Ajoute un élément à la fin du tableau.
        \param pData donnée à ajouter
        \return code d'erreur
    */
    unsigned int    push_back(T pData)
    {
        if((unsigned int)(end + 1) >= allocatedSize)
        {
            if(allocatedSize > maxSize)
                return 1;

            allocatedSize += allocBlockSize;
            tab = (T *)realloc(tab, sizeof(T) * allocatedSize);
        }

        end++;
        tab[end] = pData;
        nbDatas++;

        return 0;
    };

    //! Insert un élément.
    /*! Insert un élément.
        \param pData donnée à ajouter
        \param iPos position de l'élément
        \return code d'erreur
    */
    unsigned int    push(T pData, long int iPos)
    {
        unsigned int    i;

        if(iPos > (long int)nbDatas)
            return 1;

        if((unsigned int)(end + 1) >= allocatedSize)
        {
            if(allocatedSize > maxSize)
                return 1;

            allocatedSize += allocBlockSize;
            tab = (T *)realloc(tab, sizeof(T) * allocatedSize);
        }

        end++;

        for(i = iPos; i <= end; i++)
            tab[i + 1] = tab[i];
        tab[iPos] = pData;

        nbDatas++;

        return 0;
    };

    //! Supprime un élément.
    /*! Supprime l'élément à la position \a iPos .
        \param iPos position de l'élément
        \return code d'erreur
    */
    unsigned int    erase(long int iPos)
    {
        long int    i, j;

        if(iPos > (long int)nbDatas)
            return 1;

        for(i = iPos; i < end; i++)
            tab[i] = tab[i + 1];
        tab[i] = NULL;
        end--;
        nbDatas--;

        if(begin > deallocBlockSize)
        {
            for(i = begin, j = 0; i <= end; i++, j++)
                tab[j] = tab[i];

            begin = 0;
            end = nbDatas - 1;
        }

        return 0;
    };

    //! Vide le tableau.
    /*! Vide tout le tableau.
    */
    void    clear()
    {
        begin           = 0;
        end             = -1;
        nbDatas         = 0;
    };

    //! Retourne le premier élément.
    /*! Retourne le premier élément du tableau.
        \return pointeur sur le premier élément
    */
    inline T    front()
    {
        if(nbDatas)
            return tab[begin];

        return NULL;
    };

    //! Retourne le dernier élément.
    /*! Retourne le dernier élément du tableau.
        \return pointeur sur le dernier élément
    */
    inline T    back()
    {
        if(nbDatas)
            return tab[end];

        return NULL;
    };

    //! Retourne un élément.
    /*! Retourne l'élément à la position \a iPos .
        \param iPos position de l'élément
        \return pointeur sur l'élément
    */
    inline T    operator[](unsigned int iPos)
    {
        if(iPos < nbDatas)
            return tab[begin + iPos];

        return NULL;
    };

    //! Retourne le nombre d'élément.
    /*! Retourne le nombre d'élément du tableau \a size.
        \return nombre d'élément \a size.
    */
    inline unsigned int     size()
    {
        return nbDatas;
    };

    //! Retourne la taille allouée.
    /*! Retourne la taille allouée du tableau \a allocatedSize.
        \return taille allouée du tableau \a allocatedSize
    */
    inline unsigned int     capacity()
    {
        return allocatedSize;
    };

    //! Retourne la taille d'un block d'allocation.
    /*! Retourne la taille d'un block d'allocation \a allocBlockSize.
        \return taille d'un block d'allocation \a allocBlockSize
    */
    inline unsigned int     allocSize()
    {
        return allocBlockSize;
    };

    //! Retourne la taille d'un block de désallocation.
    /*! Retourne la taille d'un block de désallocation \a deallocBlockSize.
        \return taille d'un block de désallocation \a deallocBlockSize
    */
    inline unsigned int     deallocSize()
    {
        return deallocBlockSize;
    };

    //! Retourne la taille max du tableau.
    /*! Retourne la taille max du tableau \a maxSize.
        \return taille max du tableau \a maxSize
    */
    inline unsigned int     max_size()
    {
        return maxSize;
    };
};

#endif

---