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

Un escollo común, especialmente si se movió de Java a C / C++

Recuerde que cuando pasa un puntero, es pasar por valor, es decir, el valor del puntero se copia. Es bueno para hacer cambios a 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 usar pasar el puntero por referencia ya que desea cambiarlo, es decir, malloc, etc.

* * pointer will > asustará a un programador noobie C;)

Debe pasar un puntero al puntero si desea modificarlo.

Ie. :

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

Editar : Agregado ARRAY_SIZE, en algún momento tienes que saber cuántos enteros quieres asignar.

Esto se debe a que los datos del puntero se pasan por valor a 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;
}

SomeFunction() toma su parámetro como int*. Así que 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 fuera. Como otros sugirieron, puede usar int * * para que los cambios se reflejen en los datos. Otra forma de hacerlo es devolver int * desde someFunction ().

Aparte de usar la técnica doublepointer, si solo hay 1 retorno param necesario reescribir es como sigue:

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

Y úsalo:

 int *data = someFunction ();

Aquí está el patrón general para asignar 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 sea 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 la memoria:

1. La mejor manera de evitar problemas con la gestión de la memoria es evitar la gestión de la memoria; no estropee la memoria dinámica a menos que realmente la necesite.
2. No lanzar el resultado de malloc() a menos que esté utilizando una implementación anterior al estándar ANSI de 1989 o tenga la intención de compilar el código como C++. Si olvidó incluir stdlib.h o de lo contrario no tienen un prototipo para malloc() en el alcance, lanzar el valor devuelto suprimirá un valioso diagnóstico del compilador.
3. Use el tamaño del objeto que se asigna 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 gestión de memoria detrás de las funciones de asignación y desasignación de nivel superior; estas pueden manejar no solo la asignación, sino también la inicialización y los errores.

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

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

Respondiendo a su pregunta adicional que editó en:

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

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

Así que primero necesitas asignar tus arrays int (estoy usando una llamada directa a malloc () por el bien de 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);

En lugar de usar doble puntero, podemos asignar un nuevo puntero y simplemente devolverlo, sin necesidad de pasar doble puntero porque no se usa en ninguna parte de la función.

Return void * so se puede utilizar para cualquier tipo de asignación.

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

Y usarlo como:

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