in

Puntero a una matriz | Puntero de matriz

gfg 200x200 min

Requisito previo: Introducción a los punteros

Puntero a matriz

Considere el siguiente programa:

C ++

#include <iostream>

using namespace std;

int main()

{

int arr[5] = { 1, 2, 3, 4, 5 };

int *ptr = arr;

cout <<"n"<< ptr;

return 0;

}

C

#include<stdio.h>

int main()

{

  int arr[5] = { 1, 2, 3, 4, 5 };

  int *ptr = arr;

  printf("%pn", ptr);

  return 0;

}

En este programa, tenemos un puntero ptr que apunta al 0th elemento de la matriz. De manera similar, también podemos declarar un puntero que puede apuntar a una matriz completa en lugar de solo a un elemento de la matriz. Este puntero es útil cuando se habla de matrices multidimensionales.
Sintaxis:

data_type (*var_name)[size_of_array];

Ejemplo:

int (*ptr)[10];

Aquí ptr es un puntero que puede apuntar a una matriz de 10 enteros. Dado que el subíndice tiene mayor precedencia que la indirección, es necesario encerrar el operador de indirección y el nombre del puntero entre paréntesis. Aquí el tipo de ptr es ‘puntero a una matriz de 10 enteros’.
Nota : El puntero que apunta al 0th elemento de matriz y el puntero que apunta a toda la matriz son totalmente diferentes. El siguiente programa muestra esto:

C ++

#include <iostream>

using namespace std;

int main()

{

    

    int *p;

    

    

    int (*ptr)[5];

    int arr[5];

    

    

    p = arr;

    

    

    ptr = &arr;

    

    cout << "p =" << p <<", ptr = "<< ptr<< endl;

    p++;

    ptr++;

    cout << "p =" << p <<", ptr = "<< ptr<< endl;

    

    return 0;

}

C

#include<stdio.h>

int main()

{

    

    int *p;

    

    

    int (*ptr)[5];

    int arr[5];

    

    

    p = arr;

    

    

    ptr = &arr;

    

    printf("p = %p, ptr = %pn", p, ptr);

    

    p++;

    ptr++;

    

    printf("p = %p, ptr = %pn", p, ptr);

    

    return 0;

}

Producción:

p = 0x7fff4f32fd50, ptr = 0x7fff4f32fd50
p = 0x7fff4f32fd54, ptr = 0x7fff4f32fd64

pag: es el puntero a 0th elemento de la matriz arr, tiempo ptr es un puntero que apunta a toda la matriz arr.

  • El tipo base de pag es int mientras que el tipo base de ptr es ‘una matriz de 5 enteros’.
  • Sabemos que la aritmética del puntero se realiza en relación con el tamaño base, por lo que si escribimos ptr ++, entonces el puntero ptr se desplazará 20 bytes hacia adelante.

La siguiente figura muestra el puntero py ptr. La flecha más oscura denota un puntero a una matriz.

Diagram1 1

Al eliminar la referencia a una expresión de puntero, obtenemos un valor al que apunta esa expresión de puntero. El puntero a una matriz apunta a una matriz, por lo que al desreferenciarla, deberíamos obtener la matriz, y el nombre de la matriz denota la dirección base. Entonces, cada vez que se desreferencia un puntero a una matriz, obtenemos la dirección base de la matriz a la que apunta.

C ++

#include <bits/stdc++.h>

using namespace std;

int main()

{

    int arr[] = { 3, 5, 6, 7, 9 };

    int *p = arr;

    int (*ptr)[5] = &arr;

    

    cout << "p = "<< p <<", ptr = " << ptr << endl;

    cout << "*p = "<< *p <<", *ptr = " << *ptr << endl;

    

    cout << "sizeof(p) = "<< sizeof(p) <<

            ", sizeof(*p) = " << sizeof(*p) << endl;

    cout << "sizeof(ptr) = "<< sizeof(ptr) <<

        ", sizeof(*ptr) = " << sizeof(*ptr) << endl;

    return 0;

}

C

#include<stdio.h>

int main()

{

    int arr[] = { 3, 5, 6, 7, 9 };

    int *p = arr;

    int (*ptr)[5] = &arr;

    

    printf("p = %p, ptr = %pn", p, ptr);

    printf("*p = %d, *ptr = %pn", *p, *ptr);

    

    printf("sizeof(p) = %lu, sizeof(*p) = %lun",

                          sizeof(p), sizeof(*p));

    printf("sizeof(ptr) = %lu, sizeof(*ptr) = %lun",

                        sizeof(ptr), sizeof(*ptr));

    return 0;

}

Producción:

p = 0x7ffde1ee5010, ptr = 0x7ffde1ee5010
*p = 3, *ptr = 0x7ffde1ee5010
sizeof(p) = 8, sizeof(*p) = 4
sizeof(ptr) = 8, sizeof(*ptr) = 20

Puntero a matrices multidimensionales:

  • Punteros y matrices bidimensionales: En una matriz bidimensional, podemos acceder a cada elemento utilizando dos subíndices, donde el primer subíndice representa el número de fila y el segundo subíndice representa el número de columna. También se puede acceder a los elementos de la matriz 2-D con la ayuda de la notación de puntero. Supongamos que arr es una matriz 2-D, podemos acceder a cualquier elemento arr[i][j] de la matriz usando la expresión del puntero * (* (arr + i) + j). Ahora veremos cómo se puede derivar esta expresión.
    Tomemos una matriz bidimensional arr[3][4]:
int arr[3][4] = { {1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12} };

Diagram1 2

Dado que la memoria en una computadora está organizada linealmente, no es posible almacenar la matriz 2-D en filas y columnas. El concepto de filas y columnas es solo teórico, en realidad, una matriz 2-D se almacena en orden de fila principal, es decir, las filas se colocan una al lado de la otra. La siguiente figura muestra cómo la matriz 2-D anterior se almacenará en la memoria.

Diagram2

Cada fila se puede considerar como una matriz 1-D, por lo que una matriz bidimensional se puede considerar como una colección de matrices unidimensionales que se colocan una tras otra. En otras palabras, podemos decir que las matrices bidimensionales que se colocan una tras otra. Asi que aqui arr es una matriz de 3 elementos donde cada elemento es una matriz 1-D de 4 enteros.
Sabemos que el nombre de una matriz es un puntero constante que apunta a 0th Matriz 1-D y contiene la dirección 5000. Dado que arr es un ‘puntero a una matriz de 4 enteros’, de acuerdo con la aritmética de punteros, la expresión arr + 1 representará la dirección 5016 y la expresión arr + 2 representará la dirección 5032.
Entonces podemos decir que arr apunta al 0th Matriz 1-D, arr + 1 apunta al 1S t Matriz 1-D y arr + 2 apunta al 2Dakota del Norte Matriz 1-D.

Diagram3Screenshot from 2017 06 10 005619

En general podemos escribir:

arr + i  Points to ith element of arr ->
Points to ith 1-D array

  • Dado que arr + i apunta a ith elemento de arr, al desreferenciar obtendrá ith elemento de arr que es, por supuesto, una matriz 1-D. Así la expresión * (arr + i) nos da la dirección base de ith Matriz 1-D.
  • Sabemos, la expresión del puntero * (arr + i) es equivalente a la expresión de subíndice arr[i]. Entonces * (arr + i) que es lo mismo que arr[i] nos da la dirección base de ith Matriz 1-D.
  • Para acceder a un elemento individual de nuestra matriz 2-D, deberíamos poder acceder a cualquier jth elemento de ith Matriz 1-D.
  • Dado que el tipo base de * (arr + i) es En t y contiene la dirección de 0th elemento de ith Matriz 1-D, podemos obtener las direcciones de los elementos subsiguientes en la ith Matriz 1-D agregando valores enteros a * (arr + i).
  • Por ejemplo * (arr + i) + 1 representará la dirección de 1S t elemento de 1S telemento de ith Matriz 1-D y * (arr + i) +2 representará la dirección de 2Dakota del Norte elemento de ith Matriz 1-D.
  • De manera similar * (arr + i) + j representará la dirección de jth elemento de ith Matriz 1-D. Al desreferenciar esta expresión podemos obtener la jth elemento de la ith Matriz 1-D.
  • Punteros y matrices tridimensionales
    En una matriz tridimensional podemos acceder a cada elemento utilizando tres subíndices. Tomemos una matriz 3-D-
int arr[2][3][2] = { {{5, 10}, {6, 11}, {7, 12}}, {{20, 30}, {21, 31}, {22, 32}} };

Podemos considerar una matriz tridimensional como una matriz de matriz 2-D, es decir, cada elemento de una matriz 3-D se considera una matriz 2-D. La matriz 3-D arr se puede considerar como una matriz que consta de dos elementos donde cada elemento es una matriz 2-D. El nombre de la matriz arr es un puntero al 0th Matriz 2-D.

diagram

Por lo tanto, la expresión del puntero * (* (* (arr + i) + j) + k) es equivalente a la expresión de subíndice arr[i][j][k].
Sabemos que la expresión * (arr + i) es equivalente a arr[i] y la expresión * (* (arr + i) + j) es equivalente arr[i][j]. Entonces podemos decir que arr[i] representa la dirección base de ith Array 2-D y arr[i][j] representa la dirección base de la jth Matriz 1-D.

C ++

#include <iostream>

using namespace std;

int main()

{

  int arr[2][3][2] = {

                       {

                         {5, 10},

                         {6, 11},

                         {7, 12},

                       },

                       {

                         {20, 30},

                         {21, 31},

                         {22, 32},

                       }

                     };

  int i, j, k;

  for (i = 0; i < 2; i++)

  {

    for (j = 0; j < 3; j++)

    {

       for (k = 0; k < 2; k++)

          cout << *(*(*(arr + i) + j) +k) << "t";

       cout <<"n";

    }

  }

  return 0;

}

C

#include<stdio.h>

int main()

{

  int arr[2][3][2] = {

                       {

                         {5, 10},

                         {6, 11},

                         {7, 12},

                       },

                       {

                         {20, 30},

                         {21, 31},

                         {22, 32},

                       }

                     };

  int i, j, k;

  for (i = 0; i < 2; i++)

  {

    for (j = 0; j < 3; j++)

    {

       for (k = 0; k < 2; k++)

         printf("%dt", *(*(*(arr + i) + j) +k));

       printf("n");

    }

  }

  return 0;

}

Producción:

5    10    
6    11    
7    12    
20    30    
21    31    
22    32

La siguiente figura muestra cómo la matriz 3D utilizada en el programa anterior se almacena en la memoria.

Diagram12 1

Puntero de subíndice a una matriz

Suponer arr es una matriz 2-D con 3 filas y 4 columnas y ptr es un puntero a una matriz de 4 enteros, y ptr contiene la dirección base de la matriz arr.

int arr[3][4] = {{10, 11, 12, 13}, {20, 21, 22, 23}, {30, 31, 32, 33}};
int (*ptr)[4];
ptr = arr;

Diagram12 2

Ya que ptr es un puntero a una matriz de 4 enteros, ptr + i señalará yoth hilera. Sobre la desreferenciación ptr + i, obtenemos la dirección base de ith hilera. Para acceder a la dirección de jth elemento de ith fila podemos agregar j a la expresión del puntero * (ptr + i). Entonces la expresión del puntero * (ptr + i) + j da la dirección de jth elemento de ith fila y la expresión del puntero * (* (ptr + i) + j) da el valor de la jth elemento de ith hilera.
Sabemos que la expresión de puntero * (* (ptr + i) + j) es equivalente a la expresión de subíndice ptr[i][j]. Entonces, si tenemos una variable de puntero que contiene la dirección base de la matriz 2-D, entonces podemos acceder a los elementos de la matriz mediante un doble subíndice de esa variable de puntero.

C ++

#include <iostream>

using namespace std;

int main()

{

  int arr[3][4] = {

                    {10, 11, 12, 13},

                    {20, 21, 22, 23},

                    {30, 31, 32, 33}

                  };

  int (*ptr)[4];

  ptr = arr;

  cout << ptr<< " "<< ptr + 1<< " "<< ptr + 2 << endl;

  cout << *ptr<< " "<< *(ptr + 1)<< " "<< *(ptr + 2)<< endl;

  cout << **ptr<< " "<< *(*(ptr + 1) + 2)<< " "<< *(*(ptr + 2) + 3)<< endl;

  cout << ptr[0][0]<< " "<< ptr[1][2]<< " "<< ptr[2][3]<< endl;

  return 0;

}

C

#include<stdio.h>

int main()

{

  int arr[3][4] = {

                    {10, 11, 12, 13},

                    {20, 21, 22, 23},

                    {30, 31, 32, 33}

                  };

  int (*ptr)[4];

  ptr = arr;

  printf("%p %p %pn", ptr, ptr +...

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

apple touch icon@2

¿Cómo puedo revertir una lista en Python?

edit

Canguro vs Wallaby – Diferencia y comparación