¿Cómo puedo asignar memoria y devolverla (a través de un puntero-parámetro) a la función de llamada?

Question

que tienen algo de código en un par de diferentes funciones que se ve algo como esto:

void someFunction (int *data) { 
    data = (int *) malloc (sizeof (data)); 
} 

void useData (int *data) { 
    printf ("%p", data); 
} 

int main() { 
    int *data = NULL; 

    someFunction (data); 

    useData (data); 

    return 0; 
} 

someFunction() y useData() se definen en módulos independientes (archivos * .c).

El problema es que, aunque malloc funciona bien, y la memoria asignada se puede usar en someFunction, la misma memoria no está disponible una vez que la función ha regresado.

Se puede ver una ejecución de ejemplo del programa here, con salida que muestra las distintas direcciones de memoria.

¿Puede alguien explicarme por favor lo que estoy haciendo mal aquí, y cómo puedo conseguir que este código funcione?

---

EDIT: Por lo que parece que tengo que utilizar punteros dobles de hacer esto - ¿cómo voy a ir haciendo la misma cosa cuando realmente se necesita para el uso punteros dobles? Por ejemplo, los datos son

int **data = NULL; //used for 2D array 

¿Necesito utilizar punteros triples en las llamadas a funciones?

Answer 1

Usted desea utilizar un puntero a puntero:

void someFunction (int **data) { 
    *data = malloc (sizeof (int)); 
} 

void useData (int *data) { 
    printf ("%p", data); 
} 

int main() { 
    int *data = NULL; 

    someFunction (&data); 

    useData (data); 

    return 0; 
} 

¿Por qué? Bueno, quiere cambiar su puntero data en la función principal. En C, si desea cambiar algo que se transfiere como parámetro (y que ese cambio aparezca en la versión de la persona que llama), debe pasar un puntero a lo que quiera cambiar. En este caso, ese "algo que desea cambiar" es un puntero, de modo que para poder cambiar ese puntero, debe usar un puntero a puntero ...

Tenga en cuenta que además de su principal problema, había otro error en el código: sizeof(data) le da la cantidad de bytes necesarios para almacenar el puntero (4 bytes en un sistema operativo de 32 bits u 8 bytes en un sistema operativo de 64 bits), mientras que realmente desea el número de bytes requerido para almacenar lo que indica el puntero a (un int, es decir, 4 bytes en la mayoría de los sistemas operativos). Debido a que típicamente sizeof(int *)>=sizeof(int), esto probablemente no habría causado un problema, pero es algo a tener en cuenta. He corregido esto en el código de arriba.

Estas son algunas preguntas útiles sobre punteros-a-punteros:

How do pointer to pointers work in C?

Uses for multiple levels of pointer dereferences?

Answer 2

Tiene que pasar un puntero al puntero si desea modificar el puntero.

es decir. :

void someFunction (int **data) { 
    *data = malloc (sizeof (int)*ARRAY_SIZE); 
} 

edición: Agregado ARRAY_SIZE, en algún momento usted tiene que saber cuántos números enteros que desea asignar.

Answer 3

Eso se debe a que los datos de puntero se pasa por valor de someFunction.

int *data = NULL; 
//data is passed by value here. 
someFunction (data); 
//the memory allocated inside someFunction is not available. 

Puntero a puntero o devolver el puntero asignado resolvería el problema.

void someFunction (int **data) { 
    *data = (int *) malloc (sizeof (data)); 
} 


int* someFunction (int *data) { 
    data = (int *) malloc (sizeof (data)); 
return data; 
} 

Answer 4

someFunction() toma su parámetro como int *. Entonces cuando lo llamas desde main(), se crea una copia del valor que pasaste. Lo que sea que esté modificando dentro de la función es esta copia y, por lo tanto, los cambios no se reflejarán en el exterior. Como otros sugirieron, puede usar int ** para obtener los cambios reflejados en los datos. Otra forma de hacerlo es devolver int * desde algunaFunción().

Answer 5

Aparte de utilizar la técnica de doublepointer, si sólo hay 1 retorno parámetro necesaria reescritura es la siguiente:

int *someFunction() { 
    return (int *) malloc (sizeof (int *)); 
} 

y utilizarla:

int *data = someFunction(); 

Answer 6

Aquí está tratando de modificar el decir puntero de "data == Null" a "data == 0xabcd" alguna otra memoria que haya asignado. Por lo tanto, para modificar los datos que necesita, pase la dirección de datos, es decir, & de datos.

void someFunction (int **data) { 
    *data = (int *) malloc (sizeof (int)); 
} 

Answer 7

En respuesta a su pregunta adicional que ha editado en:

'*' denota un puntero a algo. Entonces '**' sería un puntero a un puntero a algo, '***' un puntero a un puntero a un puntero a algo, etc.

La interpretación usual de 'int ** data' (si data no es un parámetro de función) sería un puntero a la lista de matrices en int (por ejemplo, 'int a [100] [100]').

Así que es necesario asignar primero las matrices INT (estoy usando una llamada directa a malloc() en aras de la simplicidad):

data = (int**) malloc(arrayCount); //allocate a list of int pointers 
for (int i = 0; i < arrayCount; i++) //assign a list of ints to each int pointer 
    data [i] = (int*) malloc(arrayElemCount); 

Answer 8

En lugar de utilizar doble puntero sólo se puede asignar una nuevo puntero y simplemente devolverlo, no es necesario pasar el puntero doble porque no se usa en ninguna parte de la función.

Devuelve void * por lo que se puede utilizar para cualquier tipo de asignación.

void *someFunction (size_t size) { 
    return malloc (size); 
} 

y utilizarlo como:

int *data = someFunction (sizeof(int)); 

Answer 9

Aquí está el patrón general para la asignación de memoria en una función y devolver el puntero a través del parámetro:

void myAllocator (T **p, size_t count) 
{ 
    *p = malloc(sizeof **p * count); 
} 
... 
void foo(void) 
{ 
    T *p = NULL; 
    myAllocator(&p, 100); 
    ... 
} 

Otro método es hacer que el puntero el valor de retorno de la función (mi método preferido):

T *myAllocator (size_t count) 
{ 
    T *p = malloc(sizeof *p * count); 
    return p; 
} 
... 
void foo(void) 
{ 
    T *p = myAllocator(100); 
    ... 
} 

Algunas notas sobre la gestión de memoria:

1. La mejor manera de evitar problemas con la gestión de memoria es evitar la gestión de memoria; no ensucie con memoria dinámica a menos que realmente lo necesite.
2. No eche el resultado de malloc() a menos que esté utilizando una implementación que sea anterior al estándar ANSI de 1989 o tenga la intención de compilar el código como C++. Si olvida incluir stdlib.h o no tiene un prototipo para malloc() en el alcance, el lanzamiento del valor de retorno suprimirá un valioso diagnóstico del compilador.
3. Utilice el tamaño del objeto asignado en lugar del tamaño del tipo de datos (es decir, sizeof *p en lugar de sizeof (T)); esto le ahorrará algo de acidez si el tipo de datos tiene que cambiar (por ejemplo, de int a long o float a double). También hace que el código lea un poco mejor IMO.
4. Aislar las funciones de administración de memoria detrás de las funciones de asignación y desasignación de nivel superior; estos pueden manejar no solo la asignación sino también la inicialización y los errores.

Answer 10

Un error común, especialmente si nos cambiaron la forma de Java a C/C++

Recuerde cuando pasa un puntero, que es paso por valor es decir se copia el valor del puntero. Es bueno para hacer cambios en los datos apuntados por el puntero, pero cualquier cambio en el puntero en sí es solo local ya que es una copia.

El truco es utilizar pasar el puntero por referencia ya que quiere cambiarlo es decir que malloc etc.

** puntero -> va a asustar a un programador de C noobie;)