¿Cómo devuelvo valores múltiples desde una función en C?

Question

Si tengo una función que produce un resultado int y un resultado string, ¿cómo los devuelvo a ambos desde una función?

Por lo que puedo decir, solo puedo devolver una cosa, según lo determinado por el tipo que precede al nombre de la función.

Answer 1

No sé cuál es su string, pero supongo que administra su propia memoria.

Usted tiene dos soluciones:

1: devolver un struct que contiene todos los tipos que necesita.

struct Tuple { 
    int a; 
    string b; 
}; 

struct Tuple getPair() { 
    Tuple r = { 1, getString() }; 
    return r; 
} 

void foo() { 
    struct Tuple t = getPair(); 
} 

2: Utilice los punteros para transmitir valores.

void getPair(int* a, string* b) { 
    // Check that these are not pointing to NULL 
    assert(a); 
    assert(b); 
    *a = 1; 
    *b = getString(); 
} 

void foo() { 
    int a, b; 
    getPair(&a, &b); 
} 

Que uno elige a utilizar depende en gran medida de las preferencias personales en cuanto a lo que sea la semántica más te gusten.

Answer 2

Crea una estructura y establece dos valores dentro y devuelve la variable struct.

struct result { 
    int a; 
    char *string; 
} 

Usted tiene que asignar espacio para el char * en su programa.

Answer 3

Utilice los punteros como sus parámetros de función. A continuación, utilícelos para devolver valores múltiples.

Answer 4

dos enfoques diferentes:

1. Pass en sus valores devueltos por el puntero, y modificarlos dentro de la función. Usted declara su función como nula, pero regresa a través de los valores pasados ​​como punteros.
2. Defina una estructura que agregue sus valores de retorno.

Creo que # 1 es un poco más obvio sobre lo que está pasando, aunque puede ser tedioso si tiene demasiados valores de devolución. En ese caso, la opción n. ° 2 funciona bastante bien, aunque hay algunos gastos generales involucrados en la fabricación de estructuras especializadas para este fin.

Answer 5

Dado que uno de los tipos de resultados es una cadena (y está utilizando C, no C++), recomiendo pasar punteros como parámetros de salida. Uso:

void foo(int *a, char *s, int size); 

y lo llaman así:

int a; 
char *s = (char *)malloc(100); /* I never know how much to allocate :) */ 
foo(&a, s, 100); 

En general, preferimos hacer la asignación en el llamando función, no dentro de la función en sí, por lo que puede ser lo más abierto como sea posible para diferentes estrategias de asignación.

Answer 6

Option 1: Declare una estructura con un int y una cadena y devuelva una variable struct.

struct foo {  
int bar1; 
char bar2[MAX]; 
}; 

struct foo fun() { 
struct foo fooObj; 
... 
return fooObj; 
} 

Option 2: Puede pasar uno de los dos a través de puntero y realizar cambios en el parámetro real a través del puntero y vuelve la otra, como de costumbre:

int fun(char *param) { 
int bar; 
... 
strcpy(param,"...."); 
return bar; 
} 

o

char* fun(int *param) { 
char *str = /* malloc suitably.*/ 
... 
strcpy(str,"...."); 
*param = /* some value */ 
return str; 
} 

Option 3: Similar a la opción 2. Puede pasar ambos a través del puntero y no devolver nada desde la función:

void fun(char *param1,int *param2) { 
strcpy(param,"...."); 
*param2 = /* some calculated value */ 
} 

Answer 7

Pasando los parámetros por referencia a la función.

Ejemplos:

void incInt(int *y) 
{ 
    (*y)++; // Increase the value of 'x', in main, by one. 
} 

también mediante el uso de variables globales, pero no es recomendable.

Ejemplo:

int a=0; 

void main(void) 
{ 
    //Anything you want to code. 
} 

Answer 8

Hey Peter CREO puede volver 2 valores con la ayuda de punteros en C.

Answer 9

Un enfoque es utilizar las macros. Colocar esto en un archivo de cabecera multitype.h

#include <stdlib.h> 

/* ============================= HELPER MACROS ============================= */ 

/* __typeof__(V) abbreviation */ 

#define TOF(V) __typeof__(V) 

/* Expand variables list to list of typeof and variable names */ 

#define TO3(_0,_1,_2,_3) TOF(_0) v0; TOF(_1) v1; TOF(_2) v2; TOF(_3) v3; 
#define TO2(_0,_1,_2) TOF(_0) v0; TOF(_1) v1; TOF(_2) v2; 
#define TO1(_0,_1)  TOF(_0) v0; TOF(_1) v1; 
#define TO0(_0)   TOF(_0) v0; 

#define TO_(_0,_1,_2,_3,TO_MACRO,...) TO_MACRO 

#define TO(...) TO_(__VA_ARGS__,TO3,TO2,TO1,TO0)(__VA_ARGS__) 

/* Assign to multitype */ 

#define MTA3(_0,_1,_2,_3) _0 = mtr.v0; _1 = mtr.v1; _2 = mtr.v2; _3 = mtr.v3; 
#define MTA2(_0,_1,_2) _0 = mtr.v0; _1 = mtr.v1; _2 = mtr.v2; 
#define MTA1(_0,_1)  _0 = mtr.v0; _1 = mtr.v1; 
#define MTA0(_0)   _0 = mtr.v0; 

#define MTA_(_0,_1,_2,_3,MTA_MACRO,...) MTA_MACRO 

#define MTA(...) MTA_(__VA_ARGS__,MTA3,MTA2,MTA1,MTA0)(__VA_ARGS__) 

/* Return multitype if multiple arguments, return normally if only one */ 

#define MTR1(...) {               \ 
    typedef struct mtr_s {             \ 
     TO(__VA_ARGS__)               \ 
    } mtr_t;                 \ 
    mtr_t *mtr = malloc(sizeof(mtr_t));          \ 
    *mtr = (mtr_t){__VA_ARGS__};            \ 
    return mtr;                \ 
    } 

#define MTR0(_0) return(_0) 

#define MTR_(_0,_1,_2,_3,MTR_MACRO,...) MTR_MACRO 

/* ============================== API MACROS =============================== */ 

/* Declare return type before function */ 

typedef void* multitype; 

#define multitype(...) multitype 

/* Assign return values to variables */ 

#define let(...)                \ 
    for(int mti = 0; !mti;)              \ 
    for(multitype mt; mti < 2; mti++)           \ 
     if(mti) {                \ 
     typedef struct mtr_s {            \ 
      TO(__VA_ARGS__)              \ 
     } mtr_t;                \ 
     mtr_t mtr = *(mtr_t*)mt;            \ 
     MTA(__VA_ARGS__)              \ 
     free(mt);                \ 
     } else                 \ 
     mt 

/* Return */ 

#define RETURN(...) MTR_(__VA_ARGS__,MTR1,MTR1,MTR1,MTR0)(__VA_ARGS__) 

Esto hace que sea posible para volver hasta cuatro variables a partir de una función y asignarlos a un máximo de cuatro variables. A modo de ejemplo, se puede utilizar como esto:

multitype (int,float,double) fun() { 
    int a = 55; 
    float b = 3.9; 
    double c = 24.15; 

    RETURN (a,b,c); 
} 

int main(int argc, char *argv[]) { 
    int x; 
    float y; 
    double z; 

    let (x,y,z) = fun(); 

    printf("(%d, %f, %g\n)", x, y, z); 

    return 0; 
} 

Esto es lo que se imprime:

(55, 3.9, 24.15) 

La solución puede no ser tan portátil, ya que requiere C99 o posterior para macros variadic y para- declaraciones de variables de declaración. Pero creo que fue lo suficientemente interesante para publicar aquí. Otro problema es que el compilador no le advertirá si les asigna los valores incorrectos, por lo que debe tener cuidado.

Ejemplos adicionales, y una versión basada en pila del código que usa uniones, están disponibles en mi github repository.