Comment comparer les pointeurs?

Pour un peu, si faits voici le texte de l'spécifications

Opérateur d'Égalité (==,!=)

Les pointeurs vers des objets du même type peuvent être comparés pour l'égalité avec les résultats attendus "intuitifs":

De § 5.10 de la norme C++11:

Pointeurs du même type (après les conversions de pointeur) peut être comparé pour l'égalité. Deux pointeurs du même type comparent égaux si et seulement si elles sont toutes les deux nulles, deux points de la même fonction, ou les deux représentent la même adresse (3.9.2).

(laissant de côté les détails sur la comparaison des pointeurs aux constantes de pointeur membre et ou null-ils continuent sur la même ligne de 'faire ce que je veux dire':)

• [...] Si les deux opérandes sont nulles, ils comparent égaux. Sinon, si un seul est nul, ils comparent inégal.[...]

La mise en garde la plus "visible" a à voir avec les virtuals, et il semble soyez la chose logique à attendre aussi:

• [...] si l'un est un pointeur vers une fonction membre virtuelle, le résultat est indéfini. Sinon, ils comparez égal si et seulement s'ils se référeraient au même membre du même objet le plus dérivé (1.8) ou le même sous-objet s'ils ont été déréférencés avec un objet hypothétique du type de classe associé. [...]

Opérateurs Relationnels (,=)

De § 5.9 du C++11 norme:

Les pointeurs vers des objets ou des fonctions du même type (après conversions de pointeurs) peuvent être comparés, avec un résultat défini comme suit:

1. si deux pointeurs p et q du même type pointent vers le même objet ou fonction, ou les deux pointent un après la fin du même tableau, ou sont les deux null, p<=q et p>=q rendement vrai et p<q et p>q rendement faux.
2. si deux pointeurs p et q du même type pointent vers des objets différents que sont pas membres du même objet ou des éléments du même tableau ou à des fonctions, ou si un seul d'entre eux est null, le résultat de p<q, p>q, p<=q, et p>=q sont non spécifiés .
3. si deux pointeurs pointent vers des membres de données non statiques du même objet, ou vers sous-objets ou éléments de tableau de tels membres, récursivement, le pointeur vers le membre déclaré plus tard compare plus à condition que les deux membres ont le même contrôle d'accès (article 11) et à condition que leur classe ne soit pas un syndicat.
4. si deux pointeurs pointent vers des membres de données non statiques du même objet avec contrôle d'accès différent (Clause 11) le résultat n'est pas spécifié.
5. si deux pointeurs pointent vers des membres de données non statiques du même objet union, ils comparent égal (après conversion à void*, si nécessaire). Si deux pointeurs pointez vers des éléments du même tableau ou un au-delà de la fin du tableau, le pointeur vers l'objet avec l'indice supérieur compare plus élevé.
6. les autres comparaisons de pointeurs ne sont pas spécifiées.

Donc, si vous aviez:

int arr[3];
int *a = arr;
int *b = a + 1;
assert(a != b); // OK! well defined

Aussi OK:

struct X { int x,y; } s;
int *a = &s.x;
int *b = &s.y;
assert(b > a); // OK! well defined

, Mais il dépend de la something dans votre question:

int g; 
int main()
{
     int h;
     int i;

     int *a = &g;
     int *b = &h; // can't compare a <=> b
     int *c = &i; // can't compare b <=> c, or a <=> c etc.
     // but a==b, b!=c, a!=c etc. are supported just fine
}

Bonus: qu'y a-t-il d'autre dans la bibliothèque standard?

§ 20.8.5/8: "pour les modèles greater, less, greater_equal, et less_equal, les spécialisations pour tout type de pointeur donnent un ordre total, même si les opérateurs intégrés <, >, <=, >= non."

Ainsi, vous pouvez globalement commander {[26] } n'importe quel void* Impair tant que vous utilisez {[22] } et des amis, pas nus operator<.

L'opérateur == sur les pointeurs comparera leur adresse numérique et déterminera donc s'ils pointent vers le même objet.

Pour résumer. Si nous voulons voir si les deux pointeurs pointent vers le même emplacement de mémoire, nous pouvons le faire. Aussi, si nous voulons comparer le contenu de la mémoire pointée par deux pointeurs, nous pouvons le faire aussi, il suffit de les déréférencer en premier.

Si nous avons

int *a = something; 
int *b = something;

Qui sont deux pointeurs du même type que nous pouvons:

Comparer l'adresse mémoire:

a==b

Et comparer le contenu:

*a==*b

Disons que vous devez pointeurs:

int *a = something1;
int *b = something2;

Vous connaissez l'adresse de something1 qui est &something1. Aussi l'adresse de something2 est & something2.

Donc, ce que vous devez faire est de vérifier si les deux adresses que les pointeurs pointent sont correctes.

Donc vous utilisez quelque chose comme

if(&something1 == &something2) {
//do something
}

Ou vous pouvez utiliser l'opérateur == pour vérifier si un pointeur a une valeur égale avec le pointeur b.