Les pointeurs non initialisés dans le code

Je suis en train d'apprendre le C++, et je suis venu pour savoir que les pointeurs si laissé non initialisée peut pointer vers des endroits aléatoires dans la mémoire et créer des problèmes de mémoire peut être utilisé par un autre programme.

Maintenant, si c'est le cas, nous ne devrions jamais avoir cette ligne dans n'importe quelle partie de notre code: 

int* ptr;

Au lieu de cela, nous devrions avoir quelque chose comme 

int* ptr = NULL; //Is this going to avoid the problem

S'il vous plaît suggérer parce que j'ai vu de la première ligne(int* ptr;) dans de nombreux livres, alors je suis ce doute. Si possible donner quelques exemples.

  • Vérifier la valeur null avant d'utiliser un pointeur ou d'utiliser des références à s'en sortir.
  • Presque tous compilateur avoir un drapeau qui va vous avertir abou cette. L'allumer.
  • Si un pointeur n'est pas explicitement défini à NULL, la vérification de la valeur NULL habitude de faire quelque chose.
InformationsquelleAutor munish | 2011-05-03
  1. 36
    int* ptr = NULL; //Is this going to avoid the problem

    Ce sera la cause de ptr à point à NULL qui vous pouvez explicitement vérifier en tant que par défaut/valeur non initialisée. Il empêche le problème que vous décrivez, mais imprudente par le programmeur peut accidentellement déréférencement d'un pointeur null sans vérifier, provoquant un comportement indéterminé.

    Le principal avantage est à votre disposition pour vérifier si la ptr a ou n'a pas été initialisé à quoi que ce soit, c'est à dire:

     if (ptr != NULL)
 {
     //assume it points to something
 }

    Car c'est assez idiomatique, c'est assez dangereux de ne pas initialiser le pointeur de NULL. Le pointeur serait initialisé à une valeur non NULLE valeur d'ordures qui n'a pas vraiment de point à quelque chose de réel. Le pire de tous, la case ci-dessus passerait, même causer des problèmes plus graves si il se trouve que l'adresse du pointeur de la mémoire vous pouvez légalement accès. Dans certains environnements Embarqués, vous pourriez être en mesure d'accéder à une partie de la mémoire, de sorte que vous pourriez endommager accidentellement aléatoire parties de la mémoire ou des parties de votre exécution du code.

    • Si vous faites cela, il est également important de se rappeler de le faire de manière cohérente par la mise à NULL de nouveau lorsque le pointeur est libéré. Sinon, vous ne pouvez pas supposer un pointeur non NULL est dereferenceable.
    • Donc @Doug-vous dire int* ptr; ne doit jamais être utilisé? mais @Sasquiha écrit que son coffre-fort jusqu'à ce que nous ne déréférencement d'elle.
    • Oui c'est sûr si vous n'avez jamais déréférencement d'elle, mais quel est le point d'un pointeur si vous n'avez jamais déréférencement d'elle?
    • Hmm, je suis votre point, mais je pensais.Si vous considérez un exemple dans lequel il y a une ligne dans mon code int* ptr; et puis je déréférencement de 100 0r 1000 lignes plus tard dans la moyenne alors que j'.e entre le moment où elle atteint le 1000e en ligne, il doit être dirigée vers un emplacement aléatoire.il va être déréférencés beaucoup plus tard.
    • obtenu grâce à tout le monde.
    InformationsquelleAutor Doug T.
  2. 9

    Toujours initialiser vos variables.

    Parfois, vous pouvez initialiser à NULL, mais la plupart du temps, vous devriez être en mesure d'initialiser le pointeur de la valeur, il est censé tenir. Déclarer des variables aussi tard que possible, et de les initialiser à ce point, pas 15 lignes plus loin dans votre code.

    • L'une des principales raisons que les gens veulent utiliser des pointeurs est parce qu'ils veulent avoir une poignée de quelque chose et d'être en mesure de voir si quelque chose existe (en cochant la valeur NULL). Si vous pouvez l'initialiser lors de la déclaration de la variable, pourquoi ne pas répartir les chose sur la pile et être fait avec elle?
    • généralement parce que vous en avez besoin pour survivre à la portée actuelle. Et je ne vois vraiment pas comment la vérification des poignées pour les NULS change quoi que ce soit. Dans ce cas, vous devez aussi déclarer le plus tard possible, et essayez d'initialiser immédiatement.
    InformationsquelleAutor jalf
  3. 6

    La ligne:

    int* ptr;

    est certainement pas garanti pour initialiser le pointeur de la valeur à quelque chose en particulier.
    La ligne:

    int* ptr = NULL;

    Va initialiser le pointeur sur l'adresse de zéro, ce qui dans la pratique ne tiendrez jamais rien d'utile, et qui sera classiquement être vérifié pour une valeur de pointeur non valide.

    Bien sûr, il est toujours possible, comme cela a été dit par Doug T., afin de tenter d'utiliser ce pointeur sans vérification et il crash tout de même.

    Explicitement initialiser à NULL a l'avantage de garantir que le déréférencement de pointeur avant de le mettre à quelque chose d'utile crash, qui est en fait une bonne chose, car il empêche le code de "accidentellement" de travail tout en masquant un bug grave.

    InformationsquelleAutor DataGraham
  4. 2

    Il est toujours préférable d'initialiser un pointeur à NULL si pour une raison quelconque vous ne pouvez pas initialiser tandis que la déclaration se produit . Par exemple:

    Object *ptr = new Object();

    Généralement une fonction peut vérifier la valeur du pointeur par rapport à NULL pour vérifier que le pointeur a été initialisée avant. Si vous n'avez pas défini explicitement, c'est à NULL, et elle montre une valeur aléatoire, alors il pourrait être déréférencé provoque une erreur de segmentation.

    • Il est toujours préférable d'initialiser un pointeur. Mais il n'est pas toujours du meilleur de l'initialiser à NULL. Si vous savez quelle valeur il se doit, d'initialiser cette valeur directement.
    • vous avez raison.. je vais corriger ma réponse
    InformationsquelleAutor Heisenbug
  5. 1

    Si le pointeur n'est pas utilisé, le compilateur va simplement l'ignorer. Initialisation à la valeur NULL est la chose prudente à faire, à mon humble avis.

    Êtes-vous sûr que votre ne pas confondre avec une déclaration de fonction? Il est très commun pour une fonction à être déclarés en tant que

    char* faire_quelque_chose(const char* l'un,const char* deux);

    Dans ce cas, les pointeurs sont utilisés pour spécifier quel type d'argument que vous souhaitez passer.

    • Belle réponse je comprends bien, merci
    InformationsquelleAutor Jeroen Baert
  6. 1

    C++ suivre à partir de C en ce qu'il n'est pas conçu pour être un coffre-fort; il est conçu pour être efficace. C'est donc pour cette raison que automatique des variables ne sont pas initialisées. C'est à vous de veiller à ce qu'aucun pointeur est utilisé avant qu'il est initialisé (bien que de nombreux compilateur vous avertira si vous n'avez pas initialiser vos variables)

    InformationsquelleAutor doron
  7. 1
    int a,*ptr;

    maintenant

    print(ptr,*ptr)

    Dans le code ci-dessus, deux cas sont possibles:

    1. Il va exécuter si la valeur par défaut dans ptr n'est pas l'adresse de certains utilisent de la mémoire de programme.

      De sortie:

             ptr             *ptr
eg.  0x400730       -1992206795

    2. Ça va donner d'erreur (segmentaire faute) si l'adresse par défaut dans le ptr est l'adresse de certains utilisent de la mémoire de programme. E. g. si l'adresse de la variable a dans la mémoire est également 0x400730.

    InformationsquelleAutor Shubhay
  8. -1

    En C++, il est généralement préférable d'éviter de plain old pointeurs tout à fait. Standard de la bibliothèque de classes, des pointeurs intelligents (jusqu'à ce que le C++0x seulement dans les différentes bibliothèques comme Boost ou Loki) et les références qui peuvent et doivent être utilisés dans la plupart des endroits à la place.

    Si vous ne pouvez pas éviter les pointeurs, il est en effet préférable de les déclarer avec les initialisations, qui dans la plupart des cas ne doit pas être NUL, mais la cible réelle de la valeur, car en C++, vous pouvez mélanger des déclarations et des expressions librement, de sorte que vous pouvez et ne devrait déclarer la variable au point que vous avez des valeur pour elle.

    Qui n'est pas le cas C où vous devez utiliser des pointeurs beaucoup et que toutes les variables ont (ou avaient avant C99; je n'en suis pas sûr) être déclaré au début de la portée. Donc, beaucoup de gens ont encore de mauvaises habitudes de C qui ne sont pas appropriés pour le C++.

    • C'est tout simplement faux. Plaine anciens pointeurs sont toujours le type le plus commun dans bien écrit en C++. Et pendant que vous êtes correct que vous devez initialiser le pointeur avec sa valeur finale, si possible, une raison possible à l'aide d'un pointeur est précisément ce que vous pourriez ne pas être en mesure de le faire, et de le mettre plus tard. (Sinon, vous auriez besoin d'une référence.)
    InformationsquelleAutor Jan Hudec