Comparação de Ponteiros e Ponteiro para Constantes

Neste tutorial, vamos aprender como fazer comparação entre ponteiros bem como usar variáveis constantes com eles.

Comparação entre ponteiros em C++

Do mesmo jeito que podemos comparar duas variáveis quaisquer (como int e double), também podemos comparar ponteiros.

E usando os mesmo operadores: > , >=, <, <=, == e !=

Dizemos, por exemplo, que um ponteiro é maior que outro, quando, por exemplo, seu endereço de memória em um array aponta para uma variável cujo índice é maior que outro.

Por exemplo:
int *ptr1 = array[0];
int *ptr2 = array[1];

Então, a comparação: ptr2 > ptr1 vai resultar em um resultado verdadeiro.
Já: ptr1 == ptr2 vai resultar em um resultado falso, pois apontam para endereços de memória diferente.

Ou seja, ponteiros são variáveis que armazenam endereços de memória.
Então, ao comparar dois ponteiros, estamos comparando dois endereços de memória, e não os valores para qual eles apontam, ok ?

Ponteiros e const C++

Sempre que usamos a palavra-chave const, estamos dizendo ao compilador que o valor armazenado naquela variável não deve ser alterado.

Muitas vezes, queremos passar uma variável como informação, mas não queremos que ela seja modificada de maneira alguma, nesses casos, é importante usar a keyword const.

Até o momento, usamos ponteiros não-constantes que apontam para variáveis não-constantes, ou seja, podemos mudar até o valor da variável via ponteiro que aponta para ela.

Você não pode, por exemplo, passar um ponteiro, que não é constante, para uma função que espera uma variável constante como argumento. Veja:

#include <iostream>
using namespace std;

int main()
{
    const double pi = 3.14;
    const double *ptr = &pi;

    cout << *ptr << endl;

    return 0;
}

Para apontarmos para uma variável constante (pi), tivemos que definir um ponteiro constante (const double *).
Tente tirar o 'const' da declaração do ponteiro, e veja o que acontece.

Poderemos, porém, ter um ponteiro constante que aponta para uma variável que não é constante:

#include <iostream>
using namespace std;

int main()
{
    double pi = 3.14;
    double * const ptr = &pi;

    cout << *ptr << endl;

    return 0;
}

A diferença é que esse ponteiro vai apontar SEMPRE para o mesmo endereço de memória. Você pode até alterar o valor para qual ele aponta. Mas jamais vai alterar o endereço para qual ele aponta. Ponteiros do tipo constante devem ser inicializados ao serem declarados.

Por fim, poderemos ter um ponteiro constante, que aponta para uma variável constante:

#include <iostream>
using namespace std;

int main()
{
    double pi = 3.14;
    const double *const ptr = &pi;

    cout << *ptr << endl;

    return 0;
}

Note que, neste caso, não podemos alterar o endereço do ponteiro (não podemos fazer ptr = &outra_variavel) e nem podemos alterar o valor armazenado no local que o ponteiro aponta (*ptr = 21.12)

Esses casos de constante e ponteiros, bem como de comparação entre ponteiros, é muito usado no estudo de strings, por exemplo.