Quelle est la signification de "sauvage" pointeur en C?

la norme ne définit ni n'utilise le terme"sauvage". Je serais prudent de "corriger" les opinions des autres sur ce que cela signifie, Et je serais surtout éviter de citer au hasard non-normative junk internet pour soutenir ma position.

pour moi, cela signifierait un pointeur qui ne se réfère ni à un objet légitime, ni N'est nul. Les sources possibles de ces types de valeurs de pointeur peuvent inclure des objets pointeurs non initialisés, des objets qui ont cessé d'exister, des pointeurs calculés valeurs, valeurs de pointeur mal alignées, corruption accidentelle du pointeur lui-même, ou ce qu'il pointait, etc.

int main(void)
{

   int *p;  // uninitialized and non-static;  value undefined
   { 
      int i1; 
      p = &i1;  // valid 
   }            // i1 no longer exists;  p now invalid    

   p = (int*)0xABCDEF01;  // very likely not the address of a real object

   { 
      int i2;  
      p = (int*)(((char*)&i2) + 1);  // p very likely to not be aligned for int access
   }

   {
      char *oops = (char*)&p;  
      oops[0] = 'f';  oops[1] = 35;  // p was clobbered
   }
}  

et ainsi de suite. Il y a toutes sortes de façons d'obtenir une valeur de pointeur invalide dans C. Mon préféré doit être le gars qui a essayé de "sauver" ses objets en écrivant leurs adresses dans un fichier. Étrangement, quand il relisait ces valeurs de pointeur lors d'un passage différent du programme, elles ne pointaient plus vers ses objets. Fantaisie, que.

mais c'est exactement ce que wild signifie pour moi. Comme il ne s'agit pas d'un terme normatif, cela signifie ce que la personne qui a parlé ou écrit voulait dire. Demandez-lui.

un indicateur sauvage en C est un indicateur qui n'a pas été initialisé avant sa première utilisation. De Wikipedia :

les pointes sauvages sont créées en omettant initialisation nécessaire avant la première utilisation. Donc, à strictement parler, chaque pointeur dans les langages de programmation qui n'imposent pas d'initialisation commence comme un sauvage pointeur.

cela se produit le plus souvent en raison de saut au cours de la initialisation, pas par omettre. La plupart des compilateurs sont capables afin de vous avertir.

eg

int f(int i)
{
    char* dp;    //dp is a wild pointer
    ...
}

ce n'est pas le terme standard. Il est normalement utilisé pour désigner les pointeurs pointant vers l'emplacement de mémoire non valide. int *p; *p = 0; //P is a wild pointer

ou

int *p = NULL;
{
  int a;
  p = &a; // as soon as 'a' goes out of scope,'p' is pointing to invalid location
}

*p = 0;

Pour obtenir un sauvage (aka bancales) pointeur de vous:

• créer un objet
• créer un pointeur vers cet objet
• Supprimer l'objet
• Oubliez pas de mettre le pointeur à null

le pointeur est maintenant classé comme "sauvage" car il pointe vers un morceau arbitraire de mémoire et son utilisation dans cet état pourrait causer des problèmes avec votre programme.

un pointeur qui n'est initialisé avec aucune adresse est appelé comme un pointeur wild. Il peut contenir n'importe quelle adresse de poubelle, de sorte que déréférencer un indicateur sauvage est dangereux

un pointeur wild est tout pointeur qui est utilisé (en particulier comme un l_value {ie (*pointer) = x } ) tout en ayant une valeur qui n'est pas ou plus correcte. Il pourrait également être utilisé pour décrire l'utilisation de la mémoire qui n'est pas défini comme un pointeur comme un pointeur (éventuellement en ayant suivi un pointeur sauvage ou en utilisant des définitions de structure périmées).

il n'y a pas de définition officielle. Ce sont juste des mots que nous utilisons quand nous nous référons à certaines erreurs de pointeur ou les résultats de ces erreurs.

Wiki

c'est un pointeur vers un objet non initialisé ou un objet en mauvais état. utiliser ce pointeur causera des problèmes. le wiki est une bonne source d'explication.

Wild pointer est un pointeur qui ne pointe ni vers un objet valide (du type indiqué, le cas échéant), ni vers une valeur nulle distincte, le cas échéant.

plus d'informations à propos de Wild point ici

Wild pointer est un pointeur dont la déclaration est présente mais qui n'a pas encore été défini.Signifie que nous devons déclarer un pointeur - data_type *ptr; //mais pas définir l'adresse qu'il contient *ptr=100 / / le pointeur wild ne pointe pas vers une adresse valide.nous aurons donc une erreur. printf("ptr:%d",ptr);//nous aurons:0(compilateur gcc)

un pondeur qui n'ont pas de localisation de type de données varable que varable est appel le pointeur wild

pointeur non initialisé est appelé Wild Pointer. Supposons que vous essayiez

int *p; //pointe sur aucun hasard ou lieu inconnu. *p= 16; / un inconnu emplacement de mémoire est corrompue.Cela ne devrait jamais être fait. /

Cela peut créer une grande menace pour votre programme. B'Coz parce qu'ils pointent vers un emplacement de mémoire arbitraire et changer le contenu de cet emplacement peut causer un programme de planter ou de se comporter mal.