Stop code execution on error (C++)

Question

I have a library written in C++. The library has a function which accepts commands as a string and executes them. If an error is encountered (either in the command or while running the command) an "error function" is called which does some cleanup and finally calls exit(1). I am now trying to implement a graphical user interface (using Qt) to the library. The problem is that when an error is encountered, exit is called and my application crashes. I have access to the library source code but I would like to keep modifying the source code to minimum.

I am thinking of rewriting the error function such that it just stops executing code and stays in an idle state until another command is passed to the library from the user-interface. The problem is I am not sure how to go about doing it. I am basically looking for a function call equivalent to exit system call (so that the error function never returns to the code which generated the error) except that I do not want the application to exit but instead just go to an idle state and wait for calls from the user interface.

If there is another way to implement this please let me know. Please also let me know if you need more details.

Thanks in advance,

Here is some code which shows what my problem is

#include <iostream>
#include <string>
#include <cstdlib>
using namespace std;

void error_func(string error); 
void create_sphere(float radius); 
void create_rect(float length, float width); 

int main()
{
  string command; 
  while(1)  {
    cout << "Enter command: "; 
    cin >> command; 

    if(command.compare("create_sphere") == 0)  {
      float radius; 
      cout << "Enter radius: "; 
      cin >> radius;
      create_sphere(radius); 
    }
    else if(command.compare("create_rect") == 0)  {
      float l, w; 
      cout << "Enter length and width: "; 
      cin >> l >> w; 
      create_rect(l, w); 
    }
    else if(command.compare("quit") == 0)
      break; 
  } 
}

void create_sphere(float  radius)
{
  if(radius < 0)
    error_func(string("Radius must be positive")); 

  cout << "Created sphere" << endl; 
}

void create_rect(float length, float width)
{
  if(length < 0)
    error_func(string("Length must be positive")); 

  if(width < 0)
    error_func(string("Width must be positive")); 

  cout << "Created rectangle" << endl;
} 

void error_func(string error)
{
  // do some cleanup
  cout << "ERROR: " << error << endl; 
  exit(1); 
}

Assume that create_sphere, create_rect and error_func are provided by the library. I can modify error_func as required but not the other functions (since there are many such functions).

Now when an error is encountered, I would like to go back to the while loop in main so that I can keep accepting other commands.

Answer 1

I am basically looking for a function call equivalent to exit system call (so that the error function never returns to the code which generated the error) except that I do not want the application to exit but instead just go to an idle state and wait for calls from the user interface.

Basically, you are looking for an event loop. The typical minimal Qt program is as follows:

#include <QApplication>
#include <QMainWindow>

int main(int argc, char **argv)
{
    QApplication(argc, argv);
    QMainWindow w;
    w.show();
    return application.exec(); // What you want instead of exit
}

Now, you could replace QMainWindow with your own class, and declare a slot in that which gets called when you are trying to handle a command from the user interface.

#include <QWidget>

...

class MyWidget : public QWidget
{
    Q_OBJECT
    public:
        explicit MyWidget(QWidget *parent) : QWidget(parent)
        {
            connect(sender, SIGNAL(mySignal()), SLOT(handleCommand()));
        }
    public slots:
        void handleCommand()
        {
            // Handle your command here.
            // Print the error code.
            qDebug() << error_func(string("Radius must be positive"));
            // or simply:
            qDebug() << "Radius must be positive";
        } // Leaving the scope, and getting back to the event loop
}

As for the bogus library, well, if it exits, it does. There is not much you can do about that without fixint the library. It is a very bad behavior from most of the libraries.

The modification would be not to exit, but return an error code - which is a general practice in Qt software - and leave it with the application when to exit if they wish.

The application would not quit in your case. Again, It is a very bad idea for a library function to exit. Even Qt does not do except 1-2 times in a few million LOC.

I would suggest not to throw an exception. It is generally not common in Qt software, and you could make your software consistent by just using error codes like the rest of Qt does for you.

Answer 2

Invent an error state (idle state) and make the function never fail. The error state should become visible and be resolvable by some means.

If you can not reach a resolvable error state, it might be possible to rollback to some prior (initial) state.

If the options above are not possible you have some serious failure (software, hardware, data) and you might terminate the program.

All above can be achieved with return values or a getter function (indicating the current state) and a setter manipulating the current state - an exit call is a poor solution in a library. If you have an unresolvable state or can not rollback to a prior state you might throw an exception, catch it in the user interface and terminate the program after displaying the issue.

Answer 3

You should install a message handler which will automatically reduce a lot of your work. Additionally it will help in reducing your debugging too. Here is my message handler for my Qt5 application. It will need a little tweaking if you are using Qt4:

QFile *logFile = NULL;//The file in which you will output the debug info to
QTextStream *logStream = NULL;//text stream for your log file
QMutex *mutex = NULL;//Always use mutex if you are multi threading your application
bool *debugMode = NULL;//it just a flag in case you want to turn off debugging
bool errorMsg = false;//use the value of this variable after QApplication::exec() if you need to show an error message

void myMessageOutput(QtMsgType type, const QMessageLogContext &context, const QString &msg)
 {
    if(((logFile != NULL) && (debugMode != NULL)))
    {
        mutex->lock();
         switch (type)
         {
         case QtDebugMsg:
             if(!*debugMode)
             {
                 mutex->unlock();
                 return;
             }
             *logStream << msg;
             logStream->flush();
             break;
         case QtWarningMsg:
             if(!((QString)context.function).contains("setGeometry"))
             {
                 *logStream << "\n*** Warning ***\n";
                 *logStream << msg << endl;
                 *logStream << "Category: " << context.category << endl;
                 *logStream << "File: " << context.file << endl;
                 *logStream << "Function: " << context.function << endl;
                 *logStream << "Line: " << context.line << endl;
                 *logStream << "Version: " << context.version;
                 *logStream << "\n*** Warning Complete ***\n";
                 logStream->flush();
                 errorMsg = true;
                 SessionManager::get_obj()->saveCurrentSession();
             }
             break;
         case QtCriticalMsg:
             *logStream << "\n*** Critical ***\n";
             *logStream << msg << endl;
             *logStream << "Category: " << context.category << endl;
             *logStream << "File: " << context.file << endl;
             *logStream << "Function: " << context.function << endl;
             *logStream << "Line: " << context.line << endl;
             *logStream << "Version: " << context.version;
             *logStream << "\n*** Critical Complete ***\n";
             logStream->flush();
             errorMsg = true;
             SessionManager::get_obj()->saveCurrentSession();
             break;
         case QtFatalMsg:
             *logStream << "\n*** Fatal ***\n";
             *logStream << msg << endl;
             *logStream << "Category: " << context.category << endl;
             *logStream << "File: " << context.file << endl;
             *logStream << "Function: " << context.function << endl;
             *logStream << "Line: " << context.line << endl;
             *logStream << "Version: " << context.version;
             *logStream << "\n*** Fatal Complete ***\n";
             logStream->flush();
             errorMsg = false;
             SessionManager::get_obj()->saveCurrentSession();
             ShowErrorMsg(SessionManager::getSessionName());
             exit(0);
         }
         mutex->unlock();
    }
 }

To install a message handler add the following code in the main() of your GUI.

qInstallMessageHandler(myMessageOutput);

You can ignore the check for setGeometry if you want to but I find that this warning is emitted unnecessarily. So you can keep it. Also you may want to have a Session Manager which will automatically save the current session whenever an error is encountered.

When you have done this, you can safely call qFatal() when you want to terminate your application, or else use qCritical() if you want some other functionality.