Diferencia entre puntero constante, punteros a constante y punteros constantes a constantes

En este artículo, discutiremos las diferencias entre puntero constante , punteros a constante y punteros constantes a constantes . Los punteros son las variables que contienen la dirección de algunas otras variables, constantes o funciones. Hay varias formas de calificar punteros usando const .

• Punteros a constante.
• Punteros constantes.
• Punteros constantes a constante.

Punteros a constante :

En los punteros a constante, los datos apuntados por el puntero son constantes y no se pueden cambiar. Aunque, el puntero en sí puede cambiar y apunta a otro lugar (ya que el puntero en sí es una variable).

A continuación se muestra el programa para ilustrar lo mismo:

// C++ program to illustrate concept
// of the pointers to constant
#include <iostream>
using namespace std;
  
// Driver Code
int main()
{
  
    int high{ 100 };
    int low{ 66 };
    const int* score{ &high };
  
    // Pointer variable are read from
    // the right to left
    cout << *score << "\n";
  
    // Score is a pointer to integer
    // which is constant *score = 78
  
    // It will give you an Error:
    // assignment of read-only location
    // ‘* score’ because value stored in
    // constant cannot be changed
    score = &low;
  
    // This can be done here as we are
    // changing the location where the
    // score points now it points to low
    cout << *score << "\n";
  
    return 0;
}

100
66

Punteros constantes :

En punteros constantes, el puntero apunta a una ubicación de memoria fija , y el valor en esa ubicación se puede cambiar porque es una variable, pero el puntero siempre apuntará a la misma ubicación porque aquí se hace constante.

A continuación se muestra un ejemplo para comprender los punteros constantes con respecto a las referencias. Se pueden asumir las referencias como punteros constantes que se desreferencian automáticamente. El valor pasado en el parámetro real se puede cambiar, pero la referencia apunta a la misma variable.

A continuación se muestra el programa para ilustrar lo mismo:

// C++ program to illustrate concept
// of the constant pointers
#include <iostream>
using namespace std;
  
// Driver Code
int main()
{
  
    int a{ 90 };
    int b{ 50 };
  
    int* const ptr{ &a };
    cout << *ptr << "\n";
    cout << ptr << "\n";
  
    // Address what it points to
  
    *ptr = 56;
  
    // Acceptable to change the
    // value of a
  
    // Error: assignment of read-only
    // variable ‘ptr’
    // ptr = &b;
  
    cout << *ptr << "\n";
    cout << ptr << "\n";
  
    return 0;
}

90
0x7ffc641845a8
56
0x7ffc641845a8

Punteros constantes a constantes :

En los punteros constantes a constantes, los datos a los que apunta el puntero son constantes y no se pueden cambiar. El puntero en sí es constante y no puede cambiar y apuntar a otro lugar. A continuación se muestra la imagen para ilustrar lo mismo:

A continuación se muestra el programa para ilustrar lo mismo:

// C++ program to illustrate concept of
// the constant pointers to pointers
#include <iostream>
using namespace std;
  
// Driver Code
int main()
{
  
    const int a{ 50 };
    const int b{ 90 };
  
    // ptr points to a
    const int* const ptr{ &a };
  
    // *ptr = 90;
    // Error: assignment of read-only
    // location ‘*(const int*)ptr’
  
    // ptr = &b;
    // Error: assignment of read-only
    // variable ‘ptr’
  
    // Address of a
    cout << ptr << "\n";
  
    // Value of a
    cout << *ptr << "\n";
  
    return 0;
}

0x7ffea7e22d68
50