Bonjour !

Alors voilà, on m'a donné ce code sur la création d'un tampon :

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#define TYPE_DONNEE int

typedef struct
{
 TYPE_DONNEE* tableau ;
 int taille ;
 int indexProchaineCaseEcrite ;
}
Tampon_FIFO_decalage;


Tampon_FIFO_decalage* Tampon_creer ( int taille );
void Tampon_detruire ( Tampon_FIFO_decalage** _tampon );



int main ( int argc , char* argv [] )
{

 Tampon_FIFO_decalage* tampon = Tampon_creer ( 10 );

 Tampon_detruire ( &tampon );

 return 0;
}




Tampon_FIFO_decalage* Tampon_creer ( int _taille )
{

    Tampon_FIFO_decalage* tampon = ( Tampon_FIFO_decalage* ) malloc ( sizeof ( Tampon_FIFO_decalage ) );

    if ( tampon )
    {
        /**************************************************************************/
        /* Le nombre d’octets à allouer est égal à « _taille » multipliée par la */
        /* taille d’une donnée (obtenue à l’aide de l’opérateur sizeof). */
        /**************************************************************************/

        tampon->tableau = ( TYPE_DONNEE* ) malloc ( sizeof ( TYPE_DONNEE ) * _taille );

        if ( tampon->tableau )
        {
            int i;
    
            for ( i = 0 ; i < _taille ; i++ )
            {
                tampon->tableau [i] = 0;
            }

            tampon->taille = _taille;
            tampon->indexProchaineCaseEcrite = 0;
        }
        else 
        {
            perror ( "Impossible de creer le tampon" );
            free ( tampon );
            tampon = NULL;
        }
    }
    else 
    {
        perror ( "Impossible de creer le tampon" );
    }
    
    
 return tampon;
}



void Tampon_detruire ( Tampon_FIFO_decalage** _tampon )
{
    /*************************************************************************/
    /* On vérifie que le pointeur est différent de NULL car le déréférencement */
    /* et/ou la désallocation du pointeur NULL fait planter le programme. */
    /*************************************************************************/
    
    if ( *_tampon )
    {
 
    /***************************************************************************/
    /* Avant de détruire la structure, on doit détruire le tableau de données */
    /* qui lui est associé (en cas d'oubli, il n'est plus possible d'y accéder */
    /* donc cela provoque une fuite de mémoire. */
    /***************************************************************************/
    
        if ( (*_tampon)->tableau )
        {
            free ( (*_tampon)->tableau );
            (*_tampon)->tableau = NULL;
        }
        
        free ( *_tampon );
        *_tampon = NULL;
    }
}

Seulement il y a un point, par rapport aux pointeurs, que je ne comprend pas très bien. 

Dans la fonction tampon_creer(), je peux accéder au tableau du tampon en faisant :

_tampon->tableau

Alors que dans la fonction tampon_detruire, pour accéder au tableau je fais :

(*_tampon)->tableau

Je ne comprends pas quelle est la différence entre ces deux écritures et pourquoi dans la seconde on a besoin d'utiliser un pointeur, si dans la première on peut accéder au tableau directement.

Merci d'avoir pris le temps de me lire.

Au plaisir d'avoir une réponse.