Creando una array de punteros en C++

Una array de punteros es una array de variables de puntero . También se conoce como arrays de punteros. Discutiremos cómo crear dinámicamente una array de punteros 1D y 2D. La palabra dinámica significa que la memoria se asigna durante el tiempo de ejecución y asigna memoria en la sección Heap . En una pila , la memoria es limitada, pero depende del idioma/sistema operativo que se use, el tamaño promedio es de 1 MB .

Array 1D dinámica en C++: una array de punteros es un tipo de array que consta de variables del tipo puntero. Significa que esas variables pueden apuntar a otros elementos de la array.

Ejemplo:

entero *p[3];

// Ahora P[0], P[1], P[2] pueden apuntar a bloques de memoria int.

En una array asignada dinámicamente de tamaño N , el bloque se crea en el montón y devuelve la dirección del primer bloque de memoria. Mediante el uso de esa dirección se puede acceder a todos los elementos. La array dinámica en C++ uno debe estar familiarizado con las nuevas palabras clave o se puede usar malloc(), calloc() .

Sintaxis:

<tipo de datos> * <nombre del puntero> = new <tipo de datos> [<tamaño>];

Ejemplo:

int *p = nuevo int [5];

Acceso a elementos de una array dinámica:

• 1. Se crea una array 1D de tamaño N (= 5) y se asigna la dirección base a la variable P. Si se escribe la declaración a continuación, la salida es 1000 .

cout << p;

• Si desea el valor de la dirección número 1000 , ^elimínelo utilizando el símbolo * (asterisco) como se ilustra a continuación:

cout << *P;

// Es lo mismo que P[0]. La salida es 23.

Aritmética básica de punteros: a continuación se muestran algunos puntos relacionados con la aritmética de punteros :

• *(P+1):

P = 1000 y 1 = tamaño de (int) = 4 bytes.
Por lo tanto, *(1004) y la desreferenciación por el símbolo * (asterisco). Ahora, el resultado final es 38.

• *(P) + 1:

P = 1000 
Por lo tanto, *(1000) y la desreferenciación por el símbolo * (asterisco) y luego al sumar 1 modifica el resultado a 23 + 1 = 24.

A continuación se muestra el programa C++ para ilustrar los conceptos anteriores:

// C++ program to illustrate the concepts
// of creating 1D array of pointers
#include <iostream>
using namespace std;
 
// Driver Code
int main()
{
    // Dynamically creating the array
    // of size = 5
    int* p = new int[5];
 
    // Initialize the array p[] as
    // {10, 20, 30, 40, 50}
    for (int i = 0; i < 5; i++) {
        p[i] = 10 * (i + 1);
    }
 
    // Print the values using pointers
    cout << *p << endl;
    cout << *p + 1 << endl;
    cout << *(p + 1) << endl;
    cout << 2 [p] << endl;
    cout << p[2] << endl;
    *p++;
 
    // Pointing to next location
    cout << *p;
 
    return 0;
}

10
11
20
30
30
20

Array dinámica 2D de punteros en C++: una array dinámica de punteros es básicamente una array de punteros donde cada índice de array apunta a un bloque de memoria. Esto representa una vista 2D en nuestra mente. Pero lógicamente es un bloque de memoria continuo.

Sintaxis:

<tipo de datos> **<nombre del puntero> = new <tipo de datos> *[<tamaño>]; 

Ejemplo:

int **P = nuevo int *[4];

Nota: El símbolo *(asterisco) define el nivel del puntero , un * significa un nivel de punteros, donde ** implica dos niveles de punteros, y así sucesivamente. Además, el nivel del puntero debe ser el mismo que el de la array dimensional que desea crear dinámicamente.

Acercarse:

• Cree una array 1D de punteros.

• Ahora, cree la columna como una array de punteros para cada fila como:
  • P[0] = nuevo entero [3];
  • P[1] = nuevo entero [3];
  • P[2] = nuevo entero [3];
  • P[3] = nuevo entero [3];

• La array 1D de punteros apunta a un bloque de memoria (se menciona el tamaño). Básicamente, P[0], …, P[3] apuntan a una array 1D de enteros.

Accediendo a los elementos de la array :

• *P es igual a P[0], que es la dirección de la primera fila, la primera columna es &P[0][0] = 3000 .
• *(P + 1) es igual a ‘ P ‘ es 1000 + 1(sizeof int) = 1004 y * significa desreferenciación. Entonces se imprime el valor almacenado en la dirección, es decir, *1004 = 4000.
• *(P + 1) + 2 es igual que el caso anterior pero +2 significa que (&P[1] + 2) es igual a &P[1] [2] = 4008 .
• *(*(P + 1) + 2) es lo mismo que el caso anterior, pero ese primer asterisco ‘*(….)’ significa quitar la referencia a esa dirección. Por lo tanto, el resultado es igual al valor en &P[1][2] = *(4008) = 54 .

A continuación se muestra el programa C++ para ilustrar los conceptos anteriores:

// C++ program to illustrate the concepts
// of creating 2-D array of pointers
#include <iostream>
using namespace std;
 
// Driver Code
int main()
{
    int N = 3;
 
    // Creating the array of pointers
    // of size N
    int** p = new int*[N];
    int x = 1;
 
    // For multiplying
    for (int i = 0; i < N; i++) {
 
        p[i] = new int[N];
 
        // Creating N sized int memory
        // block
        for (int j = 0; j < N; j++, x++) {
 
            p[i][j] = 10 * x;
 
            // The above statement can
            // also be written as:
            // *(*(p+i)+j) = 10 * x
        }
    }
 
    // Print the values using pointers
    cout << *p << endl;
    cout << **p << endl;
    cout << *p + 1 << endl;
    cout << **p + 1 << endl;
    cout << *(*(p + 1) + 0) << endl;
    cout << p[2][2] << endl;
 
    return 0;
}

0x158de90
10
0x158de94
11
40
90