¿Cómo se "rompe" una función?

Question

Dada una función que devuelve un valor, es posible salir de la función dada una determinada condición sin devolver nada? Si es así, ¿cómo puedes lograr esto?

Ejemplo:

int getNumber() 
{ 
    . . . 
} 

lo tanto, decir que está en esta función. ¿Hay alguna manera de salir sin que haga nada?

Answer 1

Tiene dos opciones: return algo o .

int getNumber() 
{ 
    return 3; 
} 

int getNumber() 
{ 
    throw string("Some Var"); 
} 

---

Si throw, usted tiene que catch del tipo que tiró.

int maint(int argc, char ** argc) 
{ 
    try 
    { 
      getNumber(); 
    } 
    catch(string std) 
    { 
      //Your code will execute here if you throw 
    } 
} 

Answer 2

En C++ una función debe devolver un valor (tipo de valor, referencia o dirección) si se especifica uno en la declaración/definición de la función.

Answer 3

que podría lanzar una excepción especificada y ponerse en consecuencia.

Answer 4

Se podría lanzar una exception. No tendría devolver nada, pero usted tiene que coger la excepción para determinar qué hacer a continuación (siempre se puede tragar la excepción y no hacer nada para conseguir lo que quiere).

Answer 5

Un rediseño de su método es probable que con el fin si tiene que salir de una función que es la intención de devolver un valor ... o simplemente puede devolver un valor "error" de algún tipo.

Answer 6

Usted podría salirse con un return; sin valor devuelto. El compilador advertirá, pero puede no error.

PERO, ¿por qué demonios considerarías esto? ¿Qué estás intentando lograr?

Y qué hace el código de llamada parece? Si es int someVar = getNumber(); entonces el valor de somevar no está definido (que es una mala cosa).

Me parece que quiere devolver dos datos, uno de los cuales le dice si el otro es válido.

intentar algo así como

bool GetNumber(int * outputNumber) 
{ 
    if .... 
    { 
     *outputNumber = ...; 
     return true; 
    } 
    else 
    { 
     return false; // contents of outputNumber are undefined 
    } 
} 

int number; 
bool isNumberValid; 
isNumberValid = GetNumber(&number); 
if (isNumberValid) 
    ... do something with number 

Answer 7

¿Cuál es su caso de uso real?

Si realmente no necesita devolver nada y finalizar la ejecución normal de la función, puede lanzar un exception.

También puede devolver algo que la persona que llama interpreta como un error (o 'no ha devuelto nada').

Cualquiera que sea su solución, la persona que llama debe manejar el caso 'nada devuelto' por separado, p. capte la excepción o verifique el valor devuelto.

Answer 8

Alternativo de las excepciones es el retorno del código de estado:

 

SomeStatusCode YourFunc(int &returnValue) 
{ 
    ... 
    returnValue = SomeValue; 
    return SomeStatusCode.Successful; 
    ... 
    return SomeStatusCode.Fail; 
} 

//in main func 

    if(YourFunc(retValue)==SomeStatusCode.Successful) 
    // work with retValue 
    else 
    // nothing to do, show error, etc. 
</code> 

Answer 9

Usted podría utilizar setjmp/longjmp (ver http://en.wikipedia.org/wiki/Setjmp.h), pero desde una perspectiva de ingeniería de software que es mejor usar cualquiera de las excepciones o códigos de error como han mencionado otros aquí .

Answer 10

Para flotante y doble hay una alternativa pero no para tipos int.

#include <limits> 

double Get() 
{ 
    // no valid return value 
    return std::numeric_limits<double>::quiet_NaN(); 
} 

double val = Get(); 
if(val != val) { 
    // Retrieved no valid return value 
} 
else { 
    // No NaN retrieved 
} 

Tenga cuidado al usar NaN. Cada condición en val será verdadera.

Answer 11

También podría devolver una clase/estructura con alguna conversión mágica que sea útil para su necesidad especial.

Ejemplo de vida real: una vez tuve que devolver dos piezas de información en el mismo valor devuelto, un valor para informar si un mensaje de ventana había sido procesado por completo y el valor devuelto si el procesamiento ya estaba terminado. Así que empaqué todo en una clase como esta:

//This class is used to carry a return value for a window message and a value that indicates if the 
//message has already been completely processed 
class MessageReturnValue 
{ 
public: 
    LRESULT returnValue; 
    bool processed; 
    MessageReturnValue() 
    { 
     processed=false; 
     returnValue=FALSE; 
    }; 
    MessageReturnValue(LRESULT ReturnValue) 
    { 
     processed=true; 
     returnValue=ReturnValue; 
    }; 
    MessageReturnValue(bool Processed) 
    { 
     returnValue=FALSE; 
     processed=Processed; 
    }; 
    inline operator bool() 
    { 
     return processed; 
    }; 
    inline operator LRESULT() 
    { 
     return returnValue; 
    }; 
}; 

Esto me permitió hacer simplemente return false; en una función que devuelve un MessageReturnValue si el mensaje aún no se había procesado, o para return TRUE/15/whatever; si el mensaje había sido completamente procesado y ya tuve un valor de retorno. La persona que llama, por su parte, sólo podía hacer

LRESULT MyWndProc(/* blah blah blah */) 
{ 
    MessageReturnValue ret = MyFunction(/* blah blah blah */); 
    if(!ret) 
    { 
     /* process the message */ 
     return /* something */; 
    } 
    else 
     return (LRESULT)ret; 
} 

Si tiene necesidades más complejas, también se puede considerar el uso de impulso :: tupla.

Answer 12

solución simple:

boost::optional<int> getNumber() 
{ 
    // May now return an int, or may return nothing. 
} 

Answer 13

Que sea un requisito para que el usuario debe comprobar que la cola no está vacía (proporcionar medios para eso).

A continuación, se puede:

• no comprueba nada y simplemente invocar un comportamiento indefinido (de acceso subyacente datos como si estaba allí) - que es culpa del usuario
• cheque y un tiro excepción
• assert (resultado no está definido con NDEBUG)

Verificar y luego invocar el comportamiento indefinido (devolver un valor arbitrario) es lo peor que se puede hacer. Usted obtiene tanto la sobrecarga en tiempo de ejecución del cheque como la persona que llama no es más prudente, ya que el resultado aún no está definido.