5

別のスレッドでスローされた例外を実際に処理する意味がないことはわかっていますが、少なくとも例外が発生したことを通知する方法はありますか? たとえば、次のようなもの

#include <QtConcurrentRun>

#include <iostream>
#include <stdexcept>

void MyFunction()
{
//  std::cout << "MyFunction()" << std::endl;
  throw std::runtime_error("Test exception.");
}

int main()
{
  try
  {
    QtConcurrent::run(MyFunction);
  }
  catch(...)
  {
    std::cout << "Exception caught!" << std::endl;
  }

}

例外が発生しても、静かに終了します。これは、コール スタックのどこかの深いところから例外が発生した場合に、非常に混乱することがあります。

- - - - - - 編集 - - - - - - -

UmNyobeが提案したようなラッパーを書き込もうとしましたが、関数ポインターで何か間違ったことをしているに違いありませんか?

#include <QtConcurrentRun>
#include <QFutureWatcher>
#include <QObject>

#include <iostream>
#include <stdexcept>

void MyFunction()
{
//  std::cout << "MyFunction()" << std::endl;
  throw std::runtime_error("Test exception.");
}

template<typename TFirstParam, typename... TParams>
bool ExceptionWrapper(TFirstParam firstParam, TParams&& ...params)
{
  // Here 'firstParam' should be a function pointer, and 'params' are the arguments
  // that should be passed to the function
  try
  {
    firstParam(params...);
  }
  catch(...)
  {
    std::cout << "Exception caught!" << std::endl;
    return false; // failure
  }

  return true; // success
}

struct MyClass : public QObject
{
  Q_OBJECT

  MyClass()
  {
    connect(&this->FutureWatcher, SIGNAL(finished()), this, SLOT(slot_finished()));
  }

  void DoSomething()
  {
    void (*myFunctionPointer)() = MyFunction;
    bool (*functionPointer)(decltype(myFunctionPointer)) = ExceptionWrapper;

    QFuture<bool> future = QtConcurrent::run(functionPointer);
    this->FutureWatcher.setFuture(future);
  }

  QFutureWatcher<void> FutureWatcher;

  void slot_finished()
  {
    std::cout << "Finished" << std::endl;
    if(!this->FutureWatcher.result())
    {
      std::cout << "There was an error!" << std::endl;
    }
  }
};

#include "ExceptionWrapper.moc"

int main()
{
  MyClass myClass = new MyClass;
  myClass->DoSomething();
}

私が得るエラーはこの行にあります：

QFuture<bool> future = QtConcurrent::run(functionPointer);

error: no matching function for call to 'run(bool (*&)(void (*)()))'
4

3 に答える 3

8

別のスレッドでスローされた例外を実際に処理する意味がないことはわかっていますが、少なくとも例外が発生したことを通知する方法はありますか?

から返された future を使用して処理できますQtConcurrent::run。詳しくはこちらのページをご覧ください。future を収集すると、未処理の例外が再スローされます。単純なラッパー クラスを作成して、例外をキャプチャし、受信スレッドで調べることができます。

#include <QtGui>
#include <iostream>
#include <stdexcept>

class MyException : public QtConcurrent::Exception
{
public:
    MyException(std::exception& err) : e(err) {}
    void raise() const { throw *this; }
    Exception* clone() const { return new MyException(*this); }
    std::exception error() const { return e; }
private:
    std::exception e;
};

// first concurrent function
int addFive(int n)
{
    try
    {
        throw std::runtime_error("kablammo!");
        //throw -1;
        return n + 5;
    }
    catch (std::exception& e)
    {
        throw MyException(e);
    }

}

// second concurrent function    
void myVoidFunction()
{
    try
    {
        throw std::runtime_error("oops!");
        //throw -1;
    }
    catch (std::exception& e)
    {
        throw MyException(e);
    }
}

int main(int argc, char* argv[])
{
    QApplication app(argc, argv);

    QFuture<int> f1 = QtConcurrent::run(addFive, 50);
    try
    {
        int r = f1.result();
        std::cout << "result = " << r << std::endl;
    }
    catch (MyException& me)
    {
        std::cout << me.error().what() << std::endl;
    }
    catch (QtConcurrent::UnhandledException&)
    {
        std::cout << "unhandled exception in addFive\n";
    }

    QFuture<void> f2 = QtConcurrent::run(myVoidFunction);
    try
    {
        // result() not available for QFuture<void>, use waitForFinished() to
        // block until it's done.
        f2.waitForFinished();
        std::cout << "myVoidFunction finished\n";
    }
    catch (MyException& me)
    {
        std::cout << me.error().what() << std::endl;
    }
    catch (QtConcurrent::UnhandledException&)
    {
        std::cout << "unhandled exception in myVoidFunction\n";
    }

    QWidget w;
    w.show();

    return app.exec();
}
于 2012-12-05T20:44:15.200 に答える
2

例外がスローされた場合、関連する QFutureWatcher の isCanceled() が true を返すようです。

#include <QApplication>
#include <QtConcurrentRun>
#include <QFutureWatcher>

#include <iostream>
#include <stdexcept>

void MyFunction()
{
  std::cout << "MyFunction()" << std::endl;
  throw std::runtime_error("Test exception.");
}

struct MyClass : public QObject
{
  Q_OBJECT

public:
  MyClass()
  {
    connect(&this->FutureWatcher, SIGNAL(finished()), this, SLOT(slot_finished()));
  }

  void DoSomething()
  {
    QFuture<void> future = QtConcurrent::run(MyFunction);
    this->FutureWatcher.setFuture(future);
  }

  QFutureWatcher<void> FutureWatcher;

public slots:
  void slot_finished()
  {
    std::cout << "Finished" << std::endl;
    if(this->FutureWatcher.isCanceled())
    {
      std::cout << "There was an error!" << std::endl;
    }
    else
    {
      std::cout << "Success!" << std::endl;
    }
  }
};

#include "Exception.moc"

int main(int argc, char*argv[])
{
  MyClass myClass;
  myClass.DoSomething();

  QApplication app(argc, argv);

  return app.exec();
}

--------- 編集 (Gordon Freeman の回答の簡易版) ---------

QtConcurrent::Exception サブクラスを使用しなくても、例外が再スローされるようですか?

#include <QtGui>
#include <iostream>
#include <stdexcept>

// non-void concurrent function
int addFive(int n)
{
  throw std::runtime_error("addFive throw!");
  return n+5;
}

// void concurrent function
void myVoidFunction()
{
   throw std::runtime_error("myVoidFunction throw!");
}

int main(int argc, char* argv[])
{
    QApplication app(argc, argv);

    QFuture<int> f1 = QtConcurrent::run(addFive, 50);
    try
    {
        int r = f1.result();
        std::cout << "result = " << r << std::endl;
    }
    catch (...)
    {
      std::cout << "exception in addFive." << std::endl;
    }

    QFuture<void> f2 = QtConcurrent::run(myVoidFunction);
    try
    {
        // result() not available for QFuture<void>, use waitForFinished() to
        // block until it's done.
        f2.waitForFinished();
        std::cout << "myVoidFunction finished\n";
    }
    catch (...)
    {
       std::cout << "exception in myVoidFunction\n";
    }

    QWidget w;
    w.show();

    return app.exec();
}
于 2012-12-05T18:46:11.560 に答える
0

良い点QtConcurrent::run は、戻り値を持つ関数を受け入れることです。私の2セント：できるだけ早く例外をキャッチしてください...

免責事項：私はc ++の例外が本当に苦手です:D

別のスレッドで呼び出されたコードは、値を返す必要があります。void 関数、または例外をキャッチしない既存の関数の場合、ラッパーを定義できます (ジェネリックかどうかに関係なく)。例えば

 int exceptionwrapper(){
   int exception  = 0;
   try
   {
      myFunction();
   }
   catch(...){
      exception = 1;
      std::cout << "Exception caught!" << std::endl;
   }
   return exception;
 }

じゃあ後で

 QFuture<int> future = QtConcurrent::run(exemptionwrapper);
 futurewatcher.setFuture(future);

関数が終了したときに、後で将来を調べることができるように、将来のウォッチャーを使用するだけです。

于 2012-12-05T16:29:27.040 に答える