fegetexceptflag() function in C/C++

The fegetexceptflag function is part of the C standard library, specified explicitly in the <fenv.h> header. It is used for working with floating point exceptions in C programs. Floating point exceptions occur when certain arithmetic operations, such as overflow or invalid operations, result in exceptional conditions.

Syntax of the fegetexceptflag() function:

It has the following syntax:

int fegetexceptflag(fenv_t *envp, int excepts);

It takes two arguments that are envp and excepts

envp: It is a pointer to an object of the type fenv_t.

excepts: It is an integer bitmask specifying the floating-point exceptions to be tested. It is the combination of the following constants defined in <fenv.h> header

FE_DIVBYZERO: Divide-by-zero exception.

FE_INEXACT: Inexact (rounded) result exception.

FE_INVALID: Invalid operation exception.

FE_OVERFLOW: Overflow exception.

FE_UNDERFLOW: Underflow exception.

FE_ALL_EXCEPT: Bitmask representing all exceptions.

It returns zero on success and a non-zero value on failure.

The fenv_t type represents the entire floating-point environment, which includes control flags, status flags, and possibly other implementation-specific information related to floating-point operations.

Advantages of using fegetexceptflag:

There are several advantages of the fegetexceptflag. Some main advantages of the fegetexceptflag are as follows:

Control over floating-point exceptions:

It allows the program to query and control the state of the floating-point exceptions. It is used to handle exceptional conditions in a customized way.

Precision in Exception Handling:

By knowing the state of exceptions, the program can take precise actions based on the exception that occurred during the floating-point arithmetic operation.

Portability:

It provides a standardized way to work with floating point exceptions, making the code more portable across different systems and compilers that support the C standard.

Example:

Let us take a C++ program to illustrate the fegetexceptflag() function:

#include <iostream>
#include <cfenv>
#include <cmath>
using namespace std;
int main() {
 // Set up the floating-point environment
 fenv_t current_env, modified_env;
 fegetenv(�t_env);
 double income = 1000.0;
 double expenses = 0.0;
 // Check for division by zero
 if (expenses == 0.0) {
 cerr << "Error: Division by zero is not allowed." << endl;
 return 1; // Exit with an error code
 }
 double netProfit = income / expenses; // This will cause a division by zero exception
 double investment = -100.0;
 double returns = sqrt(investment); // This will cause an invalid operation exception
 // Use fexcept_t instead of fenv_t for fegetexceptflag
 fexcept_t excepts;
 fegetexceptflag(&excepts, FE_ALL_EXCEPT);
 cout << "Initial state of all exceptions: " << hex << excepts << endl;
 if (fetestexcept(FE_DIVBYZERO)) {
 cout << "Division by zero exception occurred!\n";
 }
 if (fetestexcept(FE_INVALID)) {
 cout << "Invalid operation exception occurred!\n";
 }
 fesetenv(�t_env);
 return 0;
}

Output:

Explanation:

In this example, this program establishes a floating-point environment and checks for potential division by zero, issuing an error message if detected. After that, it attempts a division operation that might trigger the "Division by zero" exception and calculates the square root of a negative number, potentially causing an "Invalid operation" exception. The program captures the initial state of exception flags using fegetexceptflag and prints them in hexadecimal format. Specific checks for "Division by zero" and "Invalid operation" exceptions are performed, with corresponding messages displayed. Finally, the floating-point environment is reset before the program concludes.

Example:

Let us take a C program to illustrate the fegetexceptflag() function:

#include <stdio.h>
#include <fenv.h>
#include <math.h>
int main() {
 // Set up the floating-point environment
 fenv_t current_env, modified_env;
 fegetenv(�t_env);
 // Example 1: Divide-by-zero exception (FE_DIVBYZERO)
 double result_divbyzero = 1.0 / 0.0;
 // Example 2: Inexact (rounded) result exception (FE_INEXACT)
 double result_inexact = sqrt(2.0);
 // Example 3: Invalid operation exception (FE_INVALID)
 double result_invalid = sqrt(-1.0);
 // Example 4: Overflow exception (FE_OVERFLOW)
 double result_overflow = exp(1000.0);
 // Example 5: Underflow exception (FE_UNDERFLOW)
 double result_underflow = exp(-1000.0);
 // Use fegetexceptflag to check for exceptions
 fexcept_t excepts;
 fegetexceptflag(&excepts, FE_ALL_EXCEPT);
 printf("Initial state of all exceptions: %X\n", excepts);
 // Check and print specific exceptions
 if (fetestexcept(FE_DIVBYZERO)) {
 printf("Divide-by-zero exception occurred!\n");
 }
 if (fetestexcept(FE_INEXACT)) {
 printf("Inexact (rounded) result exception occurred!\n");
 }
 if (fetestexcept(FE_INVALID)) {
 printf("Invalid operation exception occurred!\n");
 }
 if (fetestexcept(FE_OVERFLOW)) {
 printf("Overflow exception occurred!\n");
 }
 if (fetestexcept(FE_UNDERFLOW)) {
 printf("Underflow exception occurred!\n");
 }
 feclearexcept(FE_ALL_EXCEPT);
 fegetexceptflag(&excepts, FE_ALL_EXCEPT);
 printf("State of all exceptions after clearing: %X\n", excepts);
 fesetenv(�t_env);
 return 0;
}

Output:

Explanation:

In this example, the program demonstrates the usage of the floating-point environment functions in the C standard library (<fenv.h>) to handle different floating-point exceptions. It sets up the current environment, performs various arithmetic operations that may trigger exceptions (such as division by zero, square root of a negative number, etc.), and checks for these exceptions using fegetexceptflag and fetestexcept. The program prints the initial state of all exceptions in hexadecimal format, identifies and prints specific exceptions that occurred, clears all exceptions with feclearexcept, and then prints the state of exceptions after clearing. Finally, it resets the floating-point environment to its original state using fesetenv.

Next Topicforward_list::emplace_front() in C++

← prev next →