Diferencia entre *ptr[10] y (*ptr)[10]

4 minutos de lectura

avatar de usuario
Amit Gupta

Para el siguiente código:

    int (*ptr)[10];
    int a[10]={99,1,2,3,4,5,6,7,8,9};
    ptr=&a;
    printf("%d",(*ptr)[1]);

¿Qué debe imprimir? Estoy esperando el valor de basura aquí, pero el resultado es 1.
(por lo que estoy concluyendo que inicializar de esta manera la matriz de punteros, es decir, ptr[10] empezaría a señalar elementos de a[10] en orden).

Pero ¿qué pasa con este fragmento de código:

int *ptr[10];
int a[10]={0,1,2,3,4,5,6,7,8,9};
*ptr=a;
printf("%d",*ptr[1]);

Está dando la falla de segmentación.

  • Esto puede ser útil para usted

    –Grijesh Chauhan

    17 de diciembre de 2012 a las 8:45

  • ¿Fue tan difícil escribir “entre” y “salida” por completo?

    – Eregrith

    17 de diciembre de 2012 a las 8:45

  • @Eregrith: Lo tendré en cuenta…

    – Amit Gupta

    17 de diciembre de 2012 a las 8:48

  • @GrijeshChauhan: ¡¡Gracias..!!

    – Amit Gupta

    17 de diciembre de 2012 a las 9:18

int *ptr[10];

Esta es una matriz de 10 int* punteros, no como supondría, un puntero a una matriz de 10 ints

int (*ptr)[10];

Este es un puntero a una matriz de 10 int

Es que creo lo mismo que int *ptr; en que ambos pueden apuntar a una matriz, pero la forma dada SOLO puede apuntar a una matriz de 10 ints

int (*ptr)[10];

es un puntero a una matriz de 10 enteros.

int *ptr[10];

es una matriz de 10 punteros.

Motivo de la falla de segmento:

*ptr=a; printf(“%d”,*ptr[1]);

Aquí está asignando la dirección de la matriz. a para ptr que apuntaría al elemento a[0]. Esto es equivalente a: *ptr=&a[0];

Sin embargo, cuando imprime, accede a ptr[1] que es un puntero no inicializado que tiene un comportamiento indefinido y, por lo tanto, da un error de segmento.

avatar de usuario
Jeyaram

int(*)[10] es un puntero a una matriz int con 10 miembros. es decir, apunta a int a[10].

mientras que int *[10] es una matriz de punteros enteros

#include <stdio.h>
int main()
{

int *ptr[10];
int a[10]={0,1,2,3,4,5,6,7,8,9};

printf("\n%p  %p", ptr[0], a);

*ptr=a; //ptr[0] is assigned with address of array a.

printf("\n%p  %p", ptr[0], a); //gives you same address

printf("\n%d",*ptr[0]); //Prints zero. If *ptr[1] is given then *(ptr + 1) i.e ptr[1] is considered which is uninitialized one.

return 0;
}

avatar de usuario
quieromaestropython

int (*p)[10] significa que p ahora es un puntero a una matriz de enteros de tamaño 10.

int * p[10] significa que p es una matriz de 10 punteros enteros.

int (*p)[10] es un puntero a una matriz de 10 enteros en cada fila, es decir, puede haber cualquier número de filas. básicamente se puede usar para apuntar a una matriz 2D y se puede acceder a las dimensiones incrementando i por *(p+i)[10] que es lo mismo que a[i][10]aquí 'i=1,2,3...' acceder 1,2,3.. rows.

mientras que, int *p[10] es una matriz de 10 punteros enteros.

Si la matriz es bidimensional, es decir, por ejemplo

b[2][10]={{0,1,2,3,4,5,6,7,8,9},{10,11,12,13,14,15,16,17,18,19}};

básicamente,
(*ptr)[10] // where the higher dimension index is omitted i.e, 2 se puede usar como puntero bidimensional a una matriz (que contiene 10 elementos en cada fila, es decir, la primera dimensión) como (*ptr)[10] = &b. En el printf("%d",(*ptr)[1]); según lo previsto (*ptr) es igual que *(ptr+0)evalúa a la primera dimensión, es decir, b[0][0] cuyo valor es 0. Del mismo modo, para acceder a la segunda dimensión de la matriz b[1][0] la expresión será **(ptr+1) o *(ptr+1)[0] o *(*(ptr+i)+j);
// where i=1 and j=0
da el primer elemento de la segunda dimensión, es decir, 10.

Lo he respondido mucho tiempo para entenderlo fácil.

avatar de usuario
малин чекуров

Los únicos dos casos de uso para (*ptr)[10] están:

  • cuando se trabaja con arreglos bidimensionales;
  • matrices de longitud fija typedef.

Dado que el primer caso ya fue explicado anteriormente por Sree áspera Punyasamudram, voy a explicar el caso de uso más exótico.

    #include <stdio.h>

typedef int arr1d10[10];
typedef int arr2d3[3][3];

void test1d0(arr1d10 *arr)
{
    /* This is the same as the case with function test1d1(). */
    printf("Element: %d\n", (*arr)[0]);
}

void test1d1(int (*arr)[10])
{
    /* As arr is a pointer to an array of 10 integers, pointer arithmetic will work with the size of an array of 10 integers, i.e. 
       when you increment arr it will increment by sizeof(arr1d10), which is 40 bytes.
       That's why when you dereference it, you can't simply do arr[1], because it will increment arr by 40 bytes forward.
       Also when dereferencing it, because it thinks it points to a whole array it will give you that array - it's address.
       This is another reason you can't do just arr[i], because those will be just addresses.
       The correct way is to dereference it once(*arr)), to get the address (think of implicitely casting to int*) and then you can do as usually (*arr)[1]).
    */
    printf("Element: %d\n", (*arr)[1]);
}

void test2d0(arr2d3 *arr2d)
{
    /* This is a little more complicated, but the principle is the same as above. */
    printf("Element: %d\n", (*arr2d)[0][0]);
}

void test2d1(int (*arr2d)[3][3])
{
    printf("Element: %d\n", (*arr2d)[0][1]);
}

int main(void)
{
    arr1d10 arr1d = {0, 1, 2};
    arr2d3 arr2d = { {0,1},{2,3},{3,4}};
    int (*p1d)[10] = &arr1d; 
    int (*p2d)[3][3] = &arr2d;

    printf("********** PRINT 1D array **********\n");
    test1d0(&arr1d);
    test1d1(&arr1d);
    test1d0(p1d);
    test1d1(p1d);

    printf("********** PRINT 2D array **********\n");
    test2d0(&arr2d);
    test2d1(&arr2d);
    test2d0(p2d);
    test2d1(p2d);

    return 0;
}

¿Ha sido útil esta solución?

Esta web utiliza cookies propias y de terceros para su correcto funcionamiento y para fines analíticos y para mostrarte publicidad relacionada con sus preferencias en base a un perfil elaborado a partir de tus hábitos de navegación. Al hacer clic en el botón Aceptar, acepta el uso de estas tecnologías y el procesamiento de tus datos para estos propósitos. Configurar y más información
Privacidad