¿Cuáles son los enfoques comunes para valores de retorno de función significativos?

Question

Lo sé EXIT_SUCCESS/EXIT_FAILURE se usa típicamente para la salida main() para indicar el éxito de un programa.

¿Pero también se usa (comúnmente o se sugiere) para devoluciones de funciones normales? Intento escribir un código "estándar" para preguntarme si debería usarlos en lugar de 0 o -1 ..

Answer 1

EXIT_SUCCESS es un constant.- simbólico

Puede utilizar EXIT_SUCCESS y EXIT_FAILURE, así como 0 para bien y no para el fracaso 0.

depende de los gustos, también se puede hacer de este

#define WRONG 1 
#define COOL 0 

y volver those.-

Utilice lo que se siente más cómodo, pero mantener su selección hasta el final.

Espero que esto ayude!

Answer 2

Yo diría que no importa.

Answer 3

Si está utilizando códigos de error, usar las mismas constantes para el éxito que usan sus bibliotecas aclara las cosas.

Answer 4

Muchas de las funciones definidas por el estándar POSIX devuelven 0 para el éxito o un código de error distinto de cero para indicar la falla.

Muchas funciones POSIX se definen para devolver 0 para el éxito, -1 para el fracaso y establecer la variable global errno para indicar lo que falló. Pero un errno doesn't work well global en un programa multiproceso.

Answer 5

Nunca debe usar EXIT_SUCCESS o EXIT_FAILURE fuera del contexto de una llamada al exit() o el valor de retorno a main(). Los valores de estos enteros no están especificados por el estándar, por lo que no puede escribir código portátil si supone que son 0 o 1 respectivamente.

El estándar especifica que exit(0) y una return 0 de main() se comportan de la misma manera que exit(EXIT_SUCCESS) y return EXIT_SUCCESS, pero estos valores son "especiales" en el que se han de interpretar de una manera definida por la implementación. Es decir, el valor real pasado al sistema puede no ser 0, y el valor constante de EXIT_SUCCESS es libre de no ser 0 si la implementación lo desea, siempre que return 0 desde main y return EXIT_SUCCESS desde main se comporten de la misma manera.

Si usa estos valores en sus funciones, las personas que llaman tendrán que comparar directamente con EXIT_SUCCESS para determinar si la función fue exitosa, lo que personalmente me parecería muy inconveniente.

int MyFunction1() { /* ... */ return EXIT_SUCCESS; } 
int MyFunction2() { /* ... */ return 0; } 

// Portable: 
if (MyFunction1() == EXIT_SUCCESS) { ... } 
if (MyFunction2() == 0) { ... } 
if (!MyFunction2()) { ... } 

// Not portable: 
if (MyFunction1() == 0) { ... } 
if (!MyFunction1()) { ... } 
if (MyFunction2() == EXIT_SUCCESS) { ... } 

El problema se hace más evidente con EXIT_FAILURE:

int MyFunction1() { /*... */ return EXIT_FAILURE; } 
// Not portable 
if (MyFunction1()) { ... } 
if (MyFunction1() == 1) { ... } 
// The only way to make this portable. 
if (MyFunction1() == EXIT_FAILURE) { ... } 

Answer 6

Yo no uso el EXIT_ * macros para las funciones porque:

• Algunos de mis funciones necesita devolver firmado, errno en falla
• Algunas de mis funciones necesitan devolver el n. ° de bytes leídos o escritos
• prefiero para controlar los errores con un puntero de función de devolución de llamada mecanografiado
• me gusta siguen siendo consistentes

Ahora, llegamos a main():

• POSIX dice que puede salir con un valor de 0 a 255. Es muy, muy útil para devolver un estado de salida significativo en lugar de simplemente éxito o fracaso. Esto ayuda a que los guiones sean más inteligentes. En este sentido, solo EXIT_SUCCESS es útil.

Answer 7

No utilice EXIT_SUCCESS o EXIT_FAILURE para funciones, o para cualquier otra cosa que no sea exit llamadas para el caso.

No dude en definir sus propios tipos para que sus funciones vuelvan, pero eso depende de la situación y el código exacto que está escribiendo.

Algunos enfoques comunes son:

• funciones que devuelven punteros casi siempre devolverá NULL (que es 0 según la norma ANSI C, pero nulo es un nombre más descriptivo para su uso) en caso de errores
• funciones que los índices o posiciones de retorno generalmente devuelven -1 en error (porque no puede ser un índice real, mientras que 0 puede, entonces 0 no es un buen valor de retorno de error)
• En casos más complejos, puede serle útil defina un nuevo tipo de devolución con enum, uno de los cuales es su error, y verifique eso.

Siempre que sea coherente, no se desvíe demasiado de las convenciones y documente todo, debe estar bien.