IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

 C++ Discussion :

[debutant] pointeur de pointeur


Sujet :

C++

Vue hybride

Message précédent Message précédent   Message suivant Message suivant
  1. #1
    Membre confirmé
    Profil pro
    Inscrit en
    Septembre 2005
    Messages
    176
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Septembre 2005
    Messages : 176
    Par défaut [debutant] pointeur de pointeur
    Bonjour a tous,
    j'ai essayé de trouver des infos avec google mais je n'ai trouver que des
    exemples compliqués...
    Est ce que l'un d'entre vous pourrait m'expliquer brievement, l'interêt d'utiliser
    des pointeurs de pointeurs ?
    J'ai compris le principe mais pas l'utilité, pourtant j'imagine bien qu'il doit y en
    avoir une.
    Merci.

  2. #2
    Membre éclairé Avatar de Higestromm
    Profil pro
    Inscrit en
    Juin 2002
    Messages
    516
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Juin 2002
    Messages : 516
    Par défaut
    Par exemple tu as un tableau (un pointeur) qui contient des pointeurs d'objets assez lourd à copier. Si tu souhaite faire un tris de ces données, il est plus rapide de trier des pointeurs que des objets.

    Bon c'est un exemple comme ca mais il doit y en avoir des autres. L'utilisation de pointeur est de toute maniere souvent lié à un gain de performance.

  3. #3
    Expert éminent
    Avatar de koala01
    Homme Profil pro
    aucun
    Inscrit en
    Octobre 2004
    Messages
    11 644
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 53
    Localisation : Belgique

    Informations professionnelles :
    Activité : aucun

    Informations forums :
    Inscription : Octobre 2004
    Messages : 11 644
    Par défaut
    Salut,

    Les pointeurs de pointeurs sont, entre autres, particulièrement utiles lorsque tu souhaites passer un pointeur en argument à une fonction (peu conseillé) et que tu souhaites que le pointeur passé soit réellement modifié en sortie de la fonction...

    Quelques exemples académiques, qui sont loin, comme tout exemple purement académique, d'être pleinement efficaces

    Soit une fonction void plus5(int* nombre) qui permet d'obtenir, apres exécution, la valeur du nombre introduit en argument additionnée de 5 (ici, c'est un pointeur, tu l'auras remarqué )
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
     
    void plus5(int* nombre)
    {
        *nombre+=5; //ajoute 5 à ce qui est pointé par nombre
    }
    //l'appel sous la forme de
    void mafonct()
    {
        int i=2;//déclaration d'un entier de valeur 2
        plus5(&i);//appel de la fonction en fournissant "l'adresse de i"(c'est
                  // à dire un pointeur sur i)
    //ici, i vaut 7
    }
    soit une fonction prenant bool alloue(int** pptr,int n)un pointeur de pointeur en argument et allouant n entier au pointeur (et renvoyant un booléen pour la réussite)
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
     
    bool alloue(int** pptr, int n)
    {
        int *ptempo;
        ptempo=new int(n);//allocation d'un pointeur contenant n entiers;
        if(ptempo==NULL) //l'allocation a échoué (on aurait du faire un bloc try catch
            return false;    //on renvoi donc  false sans modifier le pointeur
        delete *pptr; //libération de ce qui est pointé par pptr (c'est à dire d'un 
                      //pointeur... devrait etre delete[] si on avait affaire à un 
                      //pointeur contenant déjà plusieurs entiers)
                      //le contenu pointé par le pointeur de pointeur est perdu ;)
        *pptr=ptempo;//ce qui est pointé par pptr recoit le pointeur ptempo
        return true;
    }
     
    void mafonct()
    {
        int *pint=new int;//allocation d'un entier à un pointeur d'entier
        bool ok=alloue(&pint,4);//appel de alloue avec l'adresse de pint (c'est à dire
                                 //un pointeur de pointeur) et récupération du résultat
                                 //renvoyé par la fonction
        if(ok==true)
        {
    //l'allocation a réussi, pint dispose de quatre entier (forts semblable à un tableau)
        }
        else
        {
    //l'allocation a échoué, pint ne dispose toujours que d'un seul entier
        }
    }
    Aucun des deux codes n'es réellement efficace, ni meme tout à fait correct...

    En effet, un bloc try catch serait beaucoup plus adapté à la tentative d'allocation de ptempo, et, en plus, on perd les valeurs du pointeur libéré...

    C'est surtout de manière à te montrer comment, en utilisant "ce qui est pointé par" un pointeur, on peut modifier la valeur d'une variable, et en utilisant "ce qui est pointé par un pointeur de pointeur", on peut modifier un pointeur...

    Pour rappel, un pointeur est une variable spéciale qui contient "l'adresse à laquelle se trouve une valeur", et un pointeur de pointeur est un pointeur spécial qui contient "l'adresse à laquelle on trouvera un pointeur" (autrement dit "l'adresse à laquelle on trouvera une adresse à laquelle on trouvera une valeur" )
    A méditer: La solution la plus simple est toujours la moins compliquée
    Ce qui se conçoit bien s'énonce clairement, et les mots pour le dire vous viennent aisément. Nicolas Boileau
    Compiler Gcc sous windows avec MinGW
    Coder efficacement en C++ : dans les bacs le 17 février 2014
    mon tout nouveau blog

  4. #4
    Expert éminent
    Avatar de Médinoc
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Septembre 2005
    Messages
    27 395
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 41
    Localisation : France

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Septembre 2005
    Messages : 27 395
    Par défaut
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    *nombre+=5; //ajoute 5 à ce qui est pointé par nombre
    Attention avec ce genre de construction sans parenthèses: Je crois bien que ça marche avec les opérateurs d'affectation comme = ou +=, mais si on mettait ++ à la place, on aurait une surprise...
    SVP, pas de questions techniques par MP. Surtout si je ne vous ai jamais parlé avant.

    "Aw, come on, who would be so stupid as to insert a cast to make an error go away without actually fixing the error?"
    Apparently everyone.
    -- Raymond Chen.
    Traduction obligatoire: "Oh, voyons, qui serait assez stupide pour mettre un cast pour faire disparaitre un message d'erreur sans vraiment corriger l'erreur?" - Apparemment, tout le monde. -- Raymond Chen.

  5. #5
    Membre confirmé
    Profil pro
    Inscrit en
    Septembre 2005
    Messages
    176
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Septembre 2005
    Messages : 176
    Par défaut
    Merci pour votre aide
    Afin de verifier si j'ai bien tout compris, j'ai ecrit ceci :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    void Fn1 (int **pptr)
    	{
    	int *a = new int;
    	*pptr = &a
    	}
     
    int b = 1;
    int *toto = &b;
    Fn1 (&toto);
    est-ce que j'ai bon ?

    Attention avec ce genre de construction sans parenthèses: Je crois bien que ça marche avec les opérateurs d'affectation comme = ou +=, mais si on mettait ++ à la place, on aurait une surprise...
    J'aurais bien aimé savoir ou mettre les parentheses dans ce cas. Parce que je
    vois pas pourquoi ça marcherait pas. Merci a tous.

  6. #6
    Membre éclairé Avatar de telliam
    Inscrit en
    Octobre 2006
    Messages
    63
    Détails du profil
    Informations forums :
    Inscription : Octobre 2006
    Messages : 63
    Par défaut
    presque, j'ai modifié ton code :
    void Fn1 (int **pptr)
    {
    int *a = new int;
    *pptr = a; /*ici tu vx, je suppose, récupérer l'addresse de la zone alloué, donc c'est a qui faut stocker dans *pptr,
    sinon tu vas stocker dans *pptr l'adresse de la variable a, donc une adresse en pile*/

    }

    int b = 1;
    int *toto = &b;
    Fn1 (&toto);


+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. Pointeurs et pointeurs de pointeurs
    Par wallace27 dans le forum C
    Réponses: 10
    Dernier message: 09/04/2015, 22h07
  2. Réponses: 21
    Dernier message: 06/08/2009, 09h31
  3. Réponses: 6
    Dernier message: 26/05/2007, 00h33
  4. [debutant] Problème de pointeur
    Par x dans le forum C
    Réponses: 8
    Dernier message: 19/01/2006, 11h00
  5. [debutant]Convertir un pointeur byte en String
    Par patmaba dans le forum SL & STL
    Réponses: 3
    Dernier message: 22/07/2005, 13h34

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo