Como comparar pointers?

Suponha que eu tenha 2 pointers:

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

Se eu quiser compará-los e ver se eles apontam para o mesmo lugar, funciona (a == b)?

Sim, essa é a definição de igualdade de ponteiro: ambos apontam para o mesmo local (ou são apelidos de ponteiro )

Por um pouco se fatos aqui é o texto relevante das especificações

Operador de igualdade (==,! =)

Ponteiros para objects do mesmo tipo podem ser comparados por igualdade com os resultados esperados “intuitivos”:

A partir do § 5.10 da norma C ++ 11:

Ponteiros do mesmo tipo (após conversões de pointers) podem ser comparados por igualdade. Dois pointers do mesmo tipo comparam igual se e somente se ambos forem nulos, ambos apontam para a mesma function, ou ambos representam o mesmo endereço ( 3.9.2 ).

(deixando de fora detalhes sobre a comparação de pointers para membros e ou as constantes de ponteiro nulo – eles continuam na mesma linha de ‘Do What I Mean’ 🙂

  • […] Se os dois operandos são nulos, eles se comparam iguais. Caso contrário, se apenas um é nulo, eles se comparam desigual […]

A advertência mais “visível” tem a ver com os virtuais, e parece ser a coisa lógica a se esperar também:

  • […] se um dos dois é um ponteiro para uma function de membro virtual, o resultado não é especificado. Caso contrário, eles comparam se e se apenas se referirem ao mesmo membro do mesmo object mais derivado (1.8) ou ao mesmo subobject se foram desreferenciados com um object hipotético do tipo de class associado. […]

Operadores relacionais (< ,>, < =,> =)

A partir do § 5.9 da norma C ++ 11:

Ponteiros para objects ou funções do mesmo tipo (após conversões de pointers) podem ser comparados, com um resultado definido da seguinte forma:

  1. Se dois pointers p e q do mesmo tipo apontam para o mesmo object ou function, ou ambos apontam para um após o final da mesma matriz, ou ambos são nulos, então p< =q e p>=q ambos resultam em true e p e p>q ambos resultam em falso.
  2. Se dois pointers p e q do mesmo tipo apontam para objects diferentes que não são membros do mesmo object ou elementos da mesma matriz ou para funções diferentes, ou se apenas um deles é nulo, os resultados de p p>q, p< =q, e p>=q não são especificados .
  3. Se dois pointers apontam para membros de dados não-estáticos do mesmo object, ou para sub-objects ou elementos de matriz de tais membros, recursivamente, o ponteiro para o membro declarado mais tarde compara maior desde que os dois membros tenham o mesmo controle de access (Cláusula 11) e desde que sua class não seja um sindicato.
  4. Se dois pointers apontarem para membros de dados não estáticos do mesmo object com controle de access diferente (Seção 11), o resultado não é especificado.
  5. Se dois pointers apontam para membros de dados não estáticos do mesmo object de união, eles comparam iguais (após conversão para void* , se necessário). Se dois pointers apontam para elementos da mesma matriz ou um além do final da matriz, o ponteiro para o object com o maior subscrito se compara mais alto.
  6. Outras comparações de pointers não são especificadas.

Então, se você tivesse:

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

Também ok:

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

Mas isso depende de something em sua pergunta:

 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 } 

Bônus: o que mais há na biblioteca padrão?

§ 20.8.5 / 8 : "Para os modelos greater , less , greater_equal e less_equal , as especializações para qualquer tipo de ponteiro geram uma ordem total, mesmo que os operadores less_equal < , > , < = , >= não".

Então, você pode ordenar globalmente qualquer void* contanto que você use std::less<> e amigos, e não operator< nu operator< .

O operador == nos pointers irá comparar seu endereço numérico e, portanto, determinar se eles apontam para o mesmo object.

Resumindo. Se quisermos ver se dois pointers apontam para a mesma localização de memory, podemos fazer isso. Além disso, se quisermos comparar o conteúdo da memory apontada por dois pointers, podemos fazer isso também, apenas lembrar de desreferencia-los primeiro.

Se tiver-mos

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

que são dois pointers do mesmo tipo que podemos:

Compare o endereço de memory:

 a==b 

e compare o conteúdo:

 *a==*b 

Vamos dizer que você tem que apontar:

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

Você sabe o endereço de algo que é & algo1. Também o endereço de algo2 é & algo2.

Então, o que você precisa fazer é verificar se os dois endereços para os quais os pointers apontam estão corretos.

então você usa algo como

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

ou você pode usar o operador == para verificar se o ponteiro a tem um valor igual com o ponteiro b.