Tipo de datos de un puntero en C++

Un puntero es una variable que almacena la dirección de memoria de un objeto . El puntero simplemente «apunta» al objeto. El tipo del objeto debe corresponder con el tipo del puntero. Los punteros se usan mucho tanto en C como en C++ para tres propósitos principales:

• Para asignar nuevos objetos en el montón .
• Para pasar funciones a otras funciones.
• Para iterar sobre elementos en arrays u otras estructuras de datos.

Los punteros se utilizan para almacenar y administrar las direcciones de bloques de memoria asignados dinámicamente. Dichos bloques se utilizan para almacenar objetos de datos o arrays de objetos. La mayoría de los lenguajes estructurados y orientados a objetos proporcionan un área de memoria, llamada montón o almacenamiento libre, desde la cual los objetos se asignan dinámicamente.

Tipo de datos de puntero

El puntero es un tipo de datos y su forma más pura en C es void * . Un vacío * puede pasar la dirección de memoria, que es lo que hace un puntero, pero no se puede desreferenciar. 

Desreferenciar significa obtener los datos contenidos en la ubicación de la memoria a la que apunta el puntero. Esto significa que uno sabrá qué tipo de datos se leerán de la memoria.

Dado que void no es nada , significa que puede apuntar a cualquier bloque de memoria que contenga cualquier tipo de datos. void * es más bien un tipo restringido, ya que no se puede quitar la referencia y, por lo tanto, no se puede usar para la aritmética de punteros. 

Para hacer la vida más fácil, C proporciona una serie de tipos de punteros derivados como char *, int *, double *, etc. Los punteros tienen su propio tamaño independientemente del tipo de datos a los que apuntan.

Ejemplo:

char *x – puntero a char

int *x – puntero a entero

Programa en C para imprimir el tamaño del puntero:

// C program to print the
// size of pointer
#include <stdio.h>
  
// Driver code
int main()
{
    int x = 10;
    int* ptr = &x;
  
    // Print size of variable
    printf("Size of variable: %zu",
            sizeof x);
  
    // Print size of pointer
    printf("\nSize of pointer: %zu",
            sizeof ptr);
  
    return 0;
}

Size of variable: 4
Size of pointer: 8

Programa en C++ para imprimir la dirección del puntero:

// C++ program to point address
// of a pointer
#include <iostream>
using namespace std;
  
// Driver code
int main()
{
    int *ptr, var;
    var = 5;
  
    // Assign address of var
    // to ptr
    ptr = &var;
  
    // Access value pointed by ptr
    cout << "Value pointed by ptr: " << 
            *ptr << endl;
  
    // Address stored by ptr
    cout << "Address stored at ptr: " << 
             ptr << endl;
  
    // Address of pointer ptr
    cout << "Address of ptr: " << 
             &ptr;
}

Value pointed by ptr: 5
Address stored at ptr: 0x7ffe1c19b10c
Address of ptr: 0x7ffe1c19b110

¿Por qué es necesario declarar el tipo de datos del puntero?

El tipo de datos de un puntero se necesita en dos situaciones:

1. Desreferenciando el puntero.
2. Aritmética de punteros.

Vamos a discutir cada uno de estos en detalle.

Desreferenciando el puntero:

El tipo de datos del puntero es necesario cuando se elimina la referencia del puntero para que sepa cuántos datos debe leer. Por ejemplo, quitar la referencia a un puntero de caracteres debería leer el siguiente byte de la dirección a la que apunta, mientras que un puntero de número entero debería leer 4 bytes.

A continuación se muestra el programa C para demostrar la desreferenciación de un puntero int

// C program to demonstrate
// dereferencing int pointer
#include <stdio.h>
int main()
{
    // Declare the integer variable
    int a = 20;
  
    // Declare the integer pointer
    // variable.
    int* ptr;
  
    // Store the address of 'x' variable
    // to the pointer variable 'ptr'
    ptr = &a;
  
    // value of 'x' variable is changed
    // to 8 by dereferencing a pointer 'ptr'
    *ptr = 8;
    printf("Value of x is : %d", a);
    return 0;
}

Aritmética de punteros:

Diferentes tipos de punteros toman diferentes cantidades de memoria. Entonces, en el caso de avanzar un puntero, se debe tener en cuenta el tamaño del tipo.

Ejemplo:

char toma 1 byte
char c = ‘a’;
carácter *ptr = &c;
ptr++;
Aquí, ptr++ significa ptr = ptr + 1 ya que char ocupa 1 byte. 
Esto significa agregar 0x01 a la dirección.

De manera similar, para int son 4 bytes, por lo que ptr++ en caso de int agregará 0x04 a la dirección almacenada en el puntero.

El tipo de datos de puntero es un tipo especial de variable que está destinado a almacenar solo direcciones, en lugar de valores (entero, flotante, doble, carácter, etc.). Sabe en cuántos bytes se almacenan los datos. Cuando incrementamos un puntero, aumentamos el puntero por el tamaño del tipo de datos al que apunta. 
Consideremos el siguiente bloque de memoria:

Un puntero necesita 8 bytes de memoria para almacenarse. En el bloque de memoria anterior-

1. Si el puntero ‘ptr’ se almacena en el punto B (dirección entre 1000000 y 10000099) con el que no se declara el tipo de puntero (es decir, se almacenará en cualquier lugar disponible) y originalmente la dirección apunta a una variable que se encuentra entre 2100 -2199, entonces llevará mucho tiempo acceder a la variable a la que apunta.
2. Si el puntero se declara con el tipo de datos, se almacena en la posición disponible más cercana a ese valor, como si se almacenara en el Punto A (dirección 2200-2299), que es el más cercano a las variables de tipo ‘int’, es decir, una fila de 4 bytes, por lo que el acceso también sería ser más rápido en comparación. 

Por lo tanto, se puede concluir que la razón principal detrás de la declaración de punteros con tipo de datos es que puede ayudar a ahorrar tiempo adicional en el acceso a las variables durante su implementación.

Importancia de declarar el tipo de datos del puntero:

1. Sin el tipo de datos, la seguridad no puede garantizarse.
2. Declarar el tipo de datos ayuda a aumentar la velocidad de acceso a la variable a la que apunta el puntero.
3. El compilador tiene que saber el tamaño de la celda de memoria a la que apunta el puntero.
4. El encasillamiento del puntero es imprescindible cuando se accede a estructuras desde el puntero.