El uso de puntero estrella en C

Hice la pregunta: Pasar matriz por referencia usando C. Me di cuenta de que mi problema era el uso de la estrella del puntero en C. Y finalmente resultó que este método funciona bien para mi programa:

#include <stdio.h>

void FillArray(int** myArray)
{   
     *myArray = (int*) malloc(sizeof(int) * 2);

     (*myArray)[0] = 1;
     (*myArray)[1] = 2;
}

int main()
{
     int* myArray = NULL;
     FillArray(& myArray);  
     printf("%d", myArray[0]);
     return 0;
}

Todo estaba bien hasta ese punto. Luego, modifiqué el RellenarArray() funciona como la siguiente para una mejor legibilidad del código:

#include <stdio.h>

void FillArray(int** myArray)
{
     int* temp = (*myArray);

     temp = (int*) malloc(sizeof(int) * 2);
     temp[0] = 1;
     temp[1] = 2;
}

int main()
{
     int* myArray = NULL;
     FillArray(& myArray);  
     printf("%d", myArray[0]);
     return 0;
}

Ahora, aparece el siguiente error de tiempo de ejecución en la línea printf:

Excepción no controlada en 0x773115de en Trial.exe: 0xC0000005: Ubicación de lectura de infracción de acceso 0x00000000.

Aunque no soy un experto en C, parecía legítimo hacer esta modificación. Sin embargo, aparentemente no funciona. ¿No es la sintaxis un poco confusa? ¿Echo de menos algo aquí?

Gracias por sus respuestas útiles,

Sat.

preguntado el 03 de mayo de 12 a las 22:05

6 Respuestas

temp obtiene una copia de la dirección de myArray, pero luego asignas algunos mallocmemoria ed para temp, por lo que la asignación original no tenía sentido y no tuvo un efecto duradero. A continuación, modifica el malloced memoria, pero eso no cambia myArray en absoluto. Cambiar myArray in main, tienes que asignar

*myArray = temp;

al final de FillArray.

void FillArray(int** myArray)
{
     int* temp;
     temp = (int*) malloc(sizeof(int) * 2);
     temp[0] = 1;
     temp[1] = 2;
     *myArray = temp;
}

hace lo que pretendes.

contestado el 03 de mayo de 12 a las 22:05

@DanielFischer temp en realidad no obtiene nada (*myArray) en la primera línea generará Access Voilation, ya que myArray es NULL y no se puede eliminar la referencia. Abid

@Abid No, él llama FillArray(& myArray);, el hecho de que myArray in main tiene el mismo nombre que el parámetro de función es confuso. En FillArray, *myArray is NULL, qué myArray in main es. - Daniel Fischer

@DanielFischer ay!! No lo leí bien. Pensé que estaba pasando un **. Gracias - Abid

Está asignando el búfer malloc a solo una variable local en la pila y luego está perdiendo esa memoria cuando regresa. Nunca está afectando el puntero pasado a la función.

contestado el 03 de mayo de 12 a las 22:05

Gracias por la respuesta. Sí, usted detectó el problema. - Sait

int* temp = (*myArray);

temp es una variable local. Cualesquiera que sean las modificaciones que se le hagan, no afectarán al original.

temp = (int*) malloc(sizeof(int) * 2);  // Will not affect *myArray

Es más o menos como -

void foo( int * ptr )
{
   ptr = malloc( sizeof(int) );
}

int *a ;
foo(a);   // Does `a` get allocated too ? NO.

contestado el 03 de mayo de 12 a las 22:05

Esto funciona para mi:

#include <stdio.h>

void FillArray(int** myArray)
{
    (*myArray) = (int*) malloc(sizeof(int) * 2);
    (*myArray)[0] = 1;
    (*myArray)[1] = 2;
}

int main()
{
    int* myArray = NULL;
    FillArray(& myArray);  
    printf("%d\n", myArray[0]);
    printf("%d\n", myArray[1]);
    return 0;
}

contestado el 03 de mayo de 12 a las 22:05

int* temp = (*myArray);

Esta línea es la causa raíz del problema, veamos qué es esta línea.

Dice desreferencia myArray y asigne el valor del resultado a temp Que es un int *, y desde myArray es y int **, la desreferenciación daría como resultado una int *. Pero no puede eliminar la referencia de un puntero que no apunta a ninguna parte, ya que cuando pasó myArray como argumento, era NULL y cuando lo hace (*myArray) intenta acceder a la ubicación de memoria a la que apunta myArray (que no está en ninguna parte como myArray es NULL), por lo tanto, acceda a la ubicación de lectura de violación 0x00000000, lo que significa que está tratando de eliminar la referencia a un puntero NULL.

Aparte de lo anterior, veamos qué está haciendo su código La imagen al principio es así

myArray ======> NULL

después de la primera línea

int* temp = (*myArray); //pointing temp to (*myArray)

dado que myArray es NULL, los puntos temporales no están en ninguna parte, por lo tanto, la nueva imagen

myArray =======> NULL
temp =======> NULL

línea 2 temp = (int*) malloc(tamaño(int) * 2);

Asignar memoria de dos enteros y señalar temporalmente la memoria recién asignada para que la imagen se convierta en

myArray =======> NULL
temp =======> [ ] [ ]

las siguientes dos líneas almacenan 1 y 2 en las ubicaciones de memoria 1 y 2 a las que apunta la temperatura

 temp[0] = 1;
 temp[1] = 2;

así que ahora la imagen es

myArray =======> NULL
temp =======> [1] [2]

contestado el 03 de mayo de 12 a las 22:05

Malloc temp antes de asignar!

contestado el 03 de mayo de 12 a las 22:05

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.