c++ - usar - Captura de excepción: dividir por cero

try catch ejemplo

Question

El siguiente código no capta una excepción cuando trato de dividir por 0. ¿Tengo que lanzar una excepción, o la computadora lanza automáticamente una en el tiempo de ejecución?

int i = 0;

cin >> i;  // what if someone enters zero?

try {
    i = 5/i;
}
catch (std::logic_error e) {

    cerr << e.what();
}

Answer 1

Debe lanzar la excepción manualmente usando throw keyword.

Ejemplo:

#include <iostream>
using namespace std;

double division(int a, int b)
{
   if( b == 0 )
   {
      throw "Division by zero condition!";
   }
   return (a/b);
}

int main ()
{
   int x = 50;
   int y = 0;
   double z = 0;

   try {
     z = division(x, y);
     cout << z << endl;
   }catch (const char* msg) {
     cerr << msg << endl;
   }

   return 0;
}

Answer 2

Debe verificarlo usted mismo y lanzar una excepción. La división de enteros por cero no es una excepción en C ++ estándar.

Tampoco el punto flotante se divide por cero, pero al menos eso tiene medios específicos para manejarlo.

Las excepciones enumeradas en el estándar ISO son:

namespace std {
    class logic_error;
        class domain_error;
        class invalid_argument;
        class length_error;
        class out_of_range;
    class runtime_error;
        class range_error;
        class overflow_error;
        class underflow_error;
}

y pensarías que overflow_error sería ideal para indicar una división por cero.

Pero la sección 5.6 (de C++11 , aunque no creo que esto haya cambiado respecto a la iteración anterior) establece específicamente:

Si el segundo operando de / o % es cero, el comportamiento no está definido.

Por lo tanto, podría arrojar esa (o cualquier otra) excepción. También podría formatear su disco duro y reírse burlonamente :-)

Si desea implementar tal bestia, podría usar algo como intDivEx en el siguiente programa:

#include <iostream>
#include <stdexcept>

// Integer division, catching divide by zero.

inline int intDivEx (int numerator, int denominator) {
    if (denominator == 0)
        throw std::overflow_error("Divide by zero exception");
    return numerator / denominator;
}

int main (void) {
    int i = 42;

    try {
        i = intDivEx (10, 2);
    } catch (std::overflow_error e) {
        std::cout << e.what() << " -> ";
    }
    std::cout << i << std::endl;

    try {
        i = intDivEx (10, 0);
    } catch (std::overflow_error e) {
        std::cout << e.what() << " -> ";
    }
    std::cout << i << std::endl;

    return 0;
}

Esto produce:

5
Divide by zero exception -> 5

y puede ver que arroja y atrapa la excepción de la división por cero.

El % equivalente es casi exactamente el mismo:

// Integer remainder, catching divide by zero.

inline int intModEx (int numerator, int denominator) {
    if (denominator == 0)
        throw std::overflow_error("Divide by zero exception");
    return numerator % denominator;
}

Answer 3

Debería verificar si i = 0 y luego no.

(Opcionalmente, después de verificarlo, puede lanzar una excepción y manejarla más adelante).

Más información en: http://www.cprogramming.com/tutorial/exceptions.html

Answer 4

Por lo que sé, las especificaciones de C ++ no mencionan nada acerca de dividir por cero excepción. Creo que debes hacerlo tú mismo ...

Stroustrup dice, en "El diseño y la evolución de C ++" (Addison Wesley, 1994), "se supone que los eventos de bajo nivel, como los desbordamientos aritméticos y la división por cero, son manejados por un mecanismo dedicado de nivel inferior en lugar de por excepciones Esto permite que C ++ haga coincidir el comportamiento de otros lenguajes cuando se trata de aritmética, y también evita los problemas que ocurren en las arquitecturas de gran cantidad de pipas donde eventos como dividir por cero son asincrónicos ".

Answer 5

Puedes hacer assert(2 * i != i) que arrojará una afirmación. Puedes escribir tu propia clase de excepción si necesitas algo más elegante.

Answer 6

do i need to throw an exception or does the computer automatically throws one at runtime?

O necesita throw la excepción y catch . p.ej

try {
  //...
  throw int();
}
catch(int i) { }

O catch la excepción que arroja tu código.

try {
    int *p = new int();
}
catch (std::bad_alloc e) {
    cerr << e.what();
}

En su caso, no estoy seguro de si existe alguna excepción estándar para dividir por cero. Si no existe tal excepción, entonces puede usar,

catch(...) {  // catch ''any'' exception
}

Answer 7

Actualizado con comentarios de ExcessPhase

GCC (al menos la versión 4.8) le permitirá emular este comportamiento:

#include <signal.h>
#include <memory>
#include <iostream>

int main() {
    std::shared_ptr<void(int)> handler(
        signal(SIGFPE, [](int signum) {throw std::logic_error("FPE"); }),
        [](__sighandler_t f) { signal(SIGFPE, f); });

    int i = 0;

    std::cin >> i;  // what if someone enters zero?

    try {
        i = 5/i;
    }
    catch (std::logic_error e) {
        std::cerr << e.what();
    }
}

Esto configura un nuevo manejador de señal que arroja una excepción y un shared_ptr al antiguo manejador de señal, con una función de "eliminación" personalizada que restaura el controlador anterior cuando se sale del alcance.

Necesitas compilar con al menos estas opciones:

g++ -c Foo.cc -o Foo.o -fnon-call-exceptions -std=c++11

Visual C ++ también te permitirá hacer algo similar:

#include <eh.h>
#include <memory>

int main() {
    std::shared_ptr<void(unsigned, EXCEPTION_POINTERS*)> handler(
        _set_se_translator([](unsigned u, EXCEPTION_POINTERS* p) {
            switch(u) {
                case FLT_DIVIDE_BY_ZERO:
                    throw std::logic_error("Divide by zero");
                ...
                default:
                    throw std::logic_error("SEH exception");
            }
        }),
        [](_se_translator_function f) { _set_se_translator(f); });

    int i = 0;

    try {
        i = 5 / i;
    } catch(std::logic_error e) {
        std::cerr << e.what();
    }
}

Y, por supuesto, puede omitir todo el C ++ 11-ishness de esto y ponerlos en una estructura de gestión de RAII tradicional.