¿Cómo malloc dentro de una función y devolver el puntero en C?

A continuación hay algo de psudo, pero estoy tratando de lograr esto. El problema está tal como está escrito, devuelve un puntero en blanco.

int testFunction(char *t) {
    int size = 100;
    t = malloc(100 + 1);
    t = <do a bunch of stuff to assign a value>;
    return size;
}

int runIt() {
    char *str = 0;
    int str_size = 0;
    str_size = testFunction(str);
    <at this point, str is blank and unmodified, what's wrong?>
    free(str);
    return 0;
}

Esto funciona bien si tengo un tamaño predefinido, como calle char[100] = “” y no trato de malloc o liberar memoria epílogos. Sin embargo, necesito poder hacer que el tamaño sea dinámico.

También probé esto, pero parece que me encontré con un puntero corrupto de alguna manera.

int testFunction(char **t) {
    int size = 100;
    t = malloc(100 + 1);
    t = <do a bunch of stuff to assign a value>;
    return size;
}

int runIt() {
    char *str = 0;
    int str_size = 0;
    str_size = testFunction(&str);
    <at this point, str is blank and unmodified, what's wrong?>
    free(str);
    return 0;
}

¡Gracias!

Su función de prueba está un poco al revés. El tamaño debe ser un aporte. El puntero asignado debe ser el producción:

char* testFunction(int size) {
    char* p = malloc(size);
    <do a bunch of stuff to assign a value>;
    return p;
}

int runIt() {
    char *str = 0;
    int str_size = 100;
    str = testFunction(str_size);
    <do something>
    free(str);
    return 0;
}

editar

Por comentario, hacer que el tamaño también sea una salida.

char* testFunction(int *size) {
    *size = <compute size>;
    char* p = malloc(size);
    <do a bunch of stuff to assign a value>;
    return p;
}

int runIt() {
    char *str = 0;
    int str_size;
    str = testFunction(&str_size);
    <do something>
    free(str);
    return 0;
}

Estás cerca del segundo ejemplo, pero cambia

int testFunction(char **t) {
  ...
  t = malloc(100 + 1);

Para

int testFunction(char **t) {
  ...
  *t = malloc(100 + 1);

El punto es que estás pasando en un char**un puntero a un puntero, por lo que desea asignar el malloc a lo que apunta (un puntero).

También estoy estudiando c++. Yo tenía la misma pregunta. Entonces, después de hablar con c ++ pro en el trabajo, me sugirió que hiciera algo como esto

int method(char* p) {                 
  if (p) {
    strcpy(p, "I like c++");
  }
  return strlen("I like c++");
}

int main()
{
      char* par = NULL;
      int len = method(par);

      if (len > 0) {
          par = (char*)malloc(len+1);
          memset(par, 0, len + 1);
          method(par);
          cout << "ret : " << par;
      }

      free(par);
}