¿Cómo comparar punteros?

Bienvenido a nuestra comunidad, en este lugar vas a encontrar la respuesta de lo que estabas buscando.

Solución:

por un poco de hechos aquí está el texto relevante de las especificaciones

Operador de igualdad (==,!=)

Los punteros a objetos del mismo tipo se pueden comparar por igualdad con los resultados esperados ‘intuitivos’:

Desde § 5.10 del estándar C++11:

Los punteros del mismo tipo (después de las conversiones de puntero) se pueden comparar para la igualdad. Dos punteros del mismo tipo se comparan iguales si y solo si ambos son nullambos apuntan a la misma función, o ambos representan la misma dirección (3.9.2).

(Omitiendo detalles sobre la comparación de punteros al miembro y/o al null constantes de puntero: continúan en la misma línea de ‘Haz lo que quiero decir’ 🙂

• […] Si ambos operandos son null, se comparan iguales. De lo contrario, si solo uno es nullse comparan desiguales.[…]

La advertencia más ‘conspicua’ tiene que ver con los virtuales, y también parece ser lo lógico de esperar:

• […] si cualquiera es un puntero a una función de miembro virtual, el resultado no se especifica. De lo contrario, se comparan iguales si y solo si se referirían al mismo miembro del mismo objeto más derivado (1.8) o al mismo subobjeto si fueran desreferenciados con un objeto hipotético del tipo de clase asociado. […]

Operadores relacionales (<,>,<=,>=)

Desde § 5.9 del estándar C++11:

Los punteros a objetos o funciones del mismo tipo (después de las conversiones de puntero) se pueden comparar, con un resultado definido de la siguiente manera:

1. Si dos punteros p y q del mismo tipo apuntan al mismo objeto o función, o ambos apuntan uno más allá del final del mismo arrayo son ambos
   nullluego p<=q y p>=q ambos rinden true y p y p>q ambos rinden false.
2. Si dos punteros p y q del mismo tipo apuntan a diferentes objetos que no son miembros del mismo objeto o elementos del mismo array o a diferentes funciones, o si sólo una de ellas es nullLos resultados de pp>q,p<=q, y
p>=qno están especificados.
3. Si dos punteros apuntan a no-static miembros de datos del mismo objeto, o a subobjetos o array elementos de dichos miembros, recursivamente, el puntero al miembro declarado más tarde se compara mayor siempre que los dos miembros tengan el mismo control de acceso (Cláusula 11) y siempre que su clase no sea una unión.
4. Si dos punteros apuntan a no-static miembros de datos del mismo objeto con diferente control de acceso (Cláusula 11), el resultado no se especifica.
5. Si dos punteros apuntan a no-static miembros de datos del mismo objeto de unión, se comparan iguales (después de la conversión a void*, si necesario). Si dos punteros apuntan a elementos del mismo array o uno más allá del final de la arrayel puntero al objeto con el subíndice más alto se compara más alto.
6. No se especifican otras comparaciones de punteros.

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

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

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