1. This site uses cookies. By continuing to use this site, you are agreeing to our use of cookies. Learn More.
Dismiss Notice
Welcome to our Education website, plz like our page facebook to support us. Thank You and wish you good navigation

6.13 — Void pointers C++

abdelouafiDec 2, 2018

    1. abdelouafi

      abdelouafi Administrator Staff Member

      Messages:
      865
      Likes Received:
      14
      Trophy Points:
      38
      Joined
      Sep 13, 2016
      Le pointeur void, également appelé pointeur générique, est un type spécial de pointeur qui peut être pointé sur des objets de tout type de données! Un pointeur void est déclaré comme un pointeur normal, en utilisant le mot clé void comme type du pointeur:
      Code:
      void *ptr; // ptr is a void pointer
      
      Un pointeur void peut pointer sur des objets de tout type de données:
      Code:
      int nValue;
      float fValue;
      struct Something
      {
          int n;
          float f;
      };
      Something sValue;
      void *ptr;
      ptr = &nValue; // valid
      ptr = &fValue; // valid
      ptr = &sValue; // valid
      Cependant, comme le pointeur vide ne sait pas quel type d'objet il pointe, il ne peut pas être déréférencé directement! Au lieu de cela, le pointeur vide doit d’abord être explicitement converti en un autre type de pointeur avant d’être déréférencé.
      Code:
      int value = 5;
      void *voidPtr = &value;
      //cout << *voidPtr << endl; // illegal: cannot dereference a void pointer
      int *intPtr = static_cast<int*>(voidPtr); // however, if we cast our void pointer to an int pointer...
      cout << *intPtr << endl; // then we can dereference it like normal
      Cela affiche :
      5

      La prochaine question évidente est la suivante: si un pointeur vide ne sait pas ce qu’il pointe, comment savons-nous à quoi le lancer? En fin de compte, c'est à vous de suivre.

      Voici un exemple de pointeur de vide utilisé:
      Code:
      #include <iostream>
      enum Type
      {
          INT,
          FLOAT,
          CSTRING
      };
      void printValue(void *ptr, Type type)
      {
          switch (type)
          {
              case INT:
                  std::cout << *static_cast<int*>(ptr) << '\n'; // cast to int pointer and dereference
                  break;
              case FLOAT:
                  std::cout << *static_cast<float*>(ptr) << '\n'; // cast to float pointer and dereference
                  break;
              case CSTRING:
                  std::cout << static_cast<char*>(ptr) << '\n'; // cast to char pointer (no dereference)
                  // std::cout knows to treat char* as a C-style string
                  // if we were to dereference the result, then we'd just print the single char that ptr is pointing to
                  break;
          }
      }
      int main()
      {
          int nValue = 5;
          float fValue = 7.5;
          char szValue[] = "Mollie";
          printValue(&nValue, INT);
          printValue(&fValue, FLOAT);
          printValue(szValue, CSTRING);
          return 0;
      }
      Cela affiche:
      5
      7.5
      Mollie

      La collection des pointeurs void:
      Les pointeurs void peuvent être définis sur une valeur nulle:
      Code:
      void *ptr = 0; // ptr is a void pointer that is currently a null pointer
      
      Bien que certains compilateurs permettent de supprimer un pointeur vide qui pointe vers de la mémoire allouée dynamiquement, évitez-le, car cela peut entraîner un comportement indéfini.

      Il n'est pas possible de faire de l'arithmétique de pointeur sur un pointeur void. En effet, l'arithmétique de pointeur nécessite que le pointeur sache à quel objet de taille il pointe, afin qu'il puisse incrémenter ou décrémenter le pointeur de manière appropriée.

      Notez qu’il n’existe pas de référence vide. En effet, une référence void serait du type void et ne saurait savoir quel type de valeur elle faisait référence.

      Conclusion

      En règle générale, évitez d'utiliser des pointeurs vides, sauf en cas d'absolue nécessité, car ils vous permettent d'éviter la vérification de type. Cela vous permet de faire par inadvertance des choses qui n’ont aucun sens, et le compilateur ne s’en plaindra pas. Par exemple, ce qui suit serait valide:
      Code:
      int nValue = 5;
          printValue(&nValue, CSTRING);

      Mais qui sait ce que le résultat serait réellement!

      Bien que la fonction ci-dessus apparaisse comme un moyen astucieux de gérer une seule fonction pour gérer plusieurs types de données, le C ++ offre en réalité un moyen bien plus efficace de procéder de la même manière (via la surcharge de fonctions) en conservant la vérification de type pour éviter les utilisations abusives. De nombreux autres endroits où les pointeurs vides étaient autrefois utilisés pour gérer plusieurs types de données sont désormais mieux gérés à l'aide de modèles, qui offrent également une vérification de type robuste.

      Cependant, vous pouvez toujours trouver une utilisation raisonnable du pointeur vide. Assurez-vous simplement qu'il n'y a pas de meilleure façon (plus sûre) de faire la même chose en utilisant d'autres mécanismes de langage!

      Quiz

      1) Quelle est la différence entre un pointeur vide et un pointeur nul?
       
      Loading...
      Un pointeur void est un pointeur qui peut pointer sur n'importe quel type d'objet, mais ne sait pas à quel type d'objet il pointe. Un pointeur vide doit être explicitement converti dans un autre type de pointeur pour être déréférencé. Un pointeur nul est un pointeur qui ne pointe pas vers une adresse. Un pointeur vide peut être un pointeur nul.

Share This Page

Share
  1. This site uses cookies. By continuing to use this site, you are agreeing to our use of cookies. Learn More.
Dismiss Notice
Welcome to our Education website, plz like our page facebook to support us. Thank You and wish you good navigation