Russian Qt Forum

void MyDialog::OnButtonOk()
{
    if (...) throw std::logic_error("some error");
}

try
{
   MyDialog dlg(this);
   dlg.exec();
}
catch(const std::exception& e)
{
// Вывод сообщения
}

void MyDialog::OnOkButtonClick()
{
    QWidget* propertyControl = lineEdit1;
    try {
        businessLogic.setProperty1(lineEdit1->text());  // throws at error

        propertyControl = lineEdit2;
        businessLogic.setProperty2(lineEdit2->text());  // throws at error
        ....
    }
    catch (const BusinessLogicError& e) {
        QMessageBox::warning(... e.what() ...);
        propertyControl->setFocus();
    }
}

try
{
   MyDialog dlg(this);
   dlg.exec();
}
catch(const std::exception& e)
{
// Вывод сообщения
}

#include <QtGui/QDialog>
#include <stdexcept>

// Dialog

class Dialog : public QDialog
{
	Q_OBJECT

public:
	Dialog()
	{
		QMetaObject::invokeMethod(this, "handler", Qt::QueuedConnection);
	}

private:
	Q_SLOT void handler()
	{
		throw std::runtime_error("Error message for user");
	}
};

#include "MainWindow.h"
#include <QtGui/QApplication>
#include <QtGui/QMessageBox>
#include <stdexcept>

// Application

class Application : public QApplication
{
public:
	Application(int argc, char *argv[]) : QApplication(argc, argv)
	{
	}

protected:
	virtual bool notify(QObject * o, QEvent * e)
	{
		try {
			return QApplication::notify(o, e);
		}
		catch (const std::exception& e) {
			QMessageBox::critical(0, QApplication::instance()->applicationName(),
				e.what(), QMessageBox::Ok, QMessageBox::NoButton);
		}
		catch (...) {
			QMessageBox::critical(0, QApplication::instance()->applicationName(),
				"Unexpected application error", QMessageBox::Ok, QMessageBox::NoButton);
		}

		return false;
	}
};

// Entry

int main(int argc, char *argv[])
{
	Application app(argc, argv);
	Dialog dialog;
	dialog.exec();  // исключение выбрасывается здесь, здесь же оно и обрабатывается
	return 0;
}

void connectToDataBase()
{
    try {
        connect();
    }
    catch (const NetworkError& e) {
        // здесь выполняем локальную обработку
        throw DataBaseConnectionError(e.what());          
    }
}

class EvenNumber
{
    int value() const { ... }
    void setValue(int value)
    {
        if (value % 1)
            throw InvalidParameterException(UserReadableAndLocalizedDescrioptionOfTheProglem);
        ....
    }
    void setValue(const QString& value)
    {
        int intValue = convertStringToInt(value);  // throws InvalidConversionError
        setValue(value);
    }
}

class Dialog : public Dialog
{
public: 
    Dialog(EventNumber& dataToBeModified) : dataToBeModified_(dataToBeModified) { ... }

private:
    EventNumber& dataToBeModified_;
    void lineEditEditingFinished()
    {
        dataToBeModified_.setValue(lineEdit->text());
    }
};

class EvenNumber
{
    int value() const { ... }
    void setValue(int value)
    {
        if (value % 1)
            throw InvalidParameterException(UserReadableAndLocalizedDescrioptionOfTheProglem);
        ....
    }
    void setValue(const QString& value)
    {
        int intValue = convertStringToInt(value);  // throws InvalidConversionError
        setValue(value);
    }
}

class Dialog : public Dialog
{
public: 
    Dialog(EventNumber& dataToBeModified) : dataToBeModified_(dataToBeModified) { ... }

private:
    EventNumber& dataToBeModified_;
    void lineEditEditingFinished()
    {
        dataToBeModified_.setValue(lineEdit->text());
    }
};

      
if (value % 1)
    emit error();

	QApplication a(argc, argv);
	PlatformManager pmgr(NULL, Qt::Window);

	try
	{
		pmgr.show();
		a.exec();
	}
	catch(ml::Exception& e)
	{
		ml::qt::ErrorBoxDialog::show("Калибратор", e.title().c_str(), e.what().c_str(), &pmgr);

		return 0;
	}

if (ui.spinBox->value() < 20) // вот это ошибочная проверочка
{
emit error(); // или окно с ошибочкой
return;
}
int x[20];
x[ui.spinBox->value()] = 0;

emit error();
return;

throw std::logic_error("Error");

int QEventLoop::exec(ProcessEventsFlags flags)
{
    Q_D(QEventLoop);
    if (d->threadData->quitNow)
        return -1;

    if (d->inExec) {
        qWarning("QEventLoop::exec: instance %p has already called exec()", this);
        return -1;
    }
    d->inExec = true;
    d->exit = false;
    ++d->threadData->loopLevel;
    d->threadData->eventLoops.push(this);

    // remove posted quit events when entering a new event loop
    QCoreApplication *app = QCoreApplication::instance();
    if (app && app->thread() == thread())
        QCoreApplication::removePostedEvents(app, QEvent::Quit);

#if defined(QT_NO_EXCEPTIONS)
    while (!d->exit)
        processEvents(flags | WaitForMoreEvents | EventLoopExec);
#else
    try {
        while (!d->exit)
            processEvents(flags | WaitForMoreEvents | EventLoopExec);
    } catch (...) {
        qWarning("Qt has caught an exception thrown from an event handler. Throwing\n"
                 "exceptions from an event handler is not supported in Qt. You must\n"
                 "reimplement QApplication::notify() and catch all exceptions there.\n");

        // copied from below
        QEventLoop *eventLoop = d->threadData->eventLoops.pop();
        Q_ASSERT_X(eventLoop == this, "QEventLoop::exec()", "internal error");
        Q_UNUSED(eventLoop); // --release warning
        d->inExec = false;
        --d->threadData->loopLevel;

        throw;
    }
#endif

    // copied above
    QEventLoop *eventLoop = d->threadData->eventLoops.pop();
    Q_ASSERT_X(eventLoop == this, "QEventLoop::exec()", "internal error");
    Q_UNUSED(eventLoop); // --release warning
    d->inExec = false;
    --d->threadData->loopLevel;

    return d->returnCode;
}

	class Exception : public boost::exception
	{
	public:
		std::string title()		const;
		std::string message()	const;
		long		code()		const;
		std::string function()	const;
		std::string file()		const;
		int			line()		const;

		std::string what()		const;
	};

#define ML_ASSERT(exp) ((exp)? ((void)0): ml::AssertionFailed("Ошибка времени выполнения", #exp, BOOST_CURRENT_FUNCTION, __FILE__, __LINE__))

#define ML_THROW(msg) throw ml::Exception()			\
	<< ml::__title__("Ошибка времени выполнения")	\
	<< ml::__message__(msg)							\
	<< ml::__function__(BOOST_CURRENT_FUNCTION)		\
	<< ml::__file__(__FILE__)						\
	<< ml::__line__(__LINE__)

	class Reader : public boost::noncopyable
	{
	private:
		bifstream m_fileStream;			///< Файловый поток
		std::vector<Point> m_points;	///< Буфер прочитанных значений
		std::string m_caption;			///< Название
		unsigned int m_channels;		///< Число каналов
		unsigned int m_frequency;		///< Частота

	private:
		void readHeader();
		void readPoints();

	public:
		Reader(const boost::filesystem::path& filename);
		std::string caption() const;
		unsigned int channels() const;
		unsigned int frequency() const;
		size_t size() const;

		std::vector<Point> read(size_t base, size_t num);
		std::vector<double> read(size_t base, size_t num, unsigned int channel);

		Point operator[](size_t index) const;
	};

std::vector<Point> Reader::read(size_t base, size_t num)
{
using namespace std;

vector<Point> result;

	if (base >= 0 && base < m_points.size() && (base + num) <= m_points.size())
	{
		result.reserve( num );

		copy(m_points.begin() + base,
			 m_points.begin() + base + num,
			 back_inserter(result));
	}
	else
	{
		boost::format msg("illegal read interval: \"[%1%; %2%]\"");
		msg % base % (base + num);
		ML_THROW(msg.str());
	}

return result;
}

std::vector<double> Reader::read(size_t base, size_t num, unsigned int channel)
{
using namespace std;
using namespace boost::phoenix;

vector<double> result;

	if (channel >= channels() )
	{
		boost::format msg("channel value \"%1%\" is not correct. Channels number: \"[%2%\"");
		msg % channel % channels();
		ML_THROW(msg.str());
	}

	if (base < 0 || base >= m_points.size() || (base + num) > m_points.size())
	{
		boost::format msg("illegal read interval: \"[%1%; %2%]\"");
		msg % base % (base + num);
		ML_THROW(msg.str());
	}

	result.reserve(num);

	transform(m_points.begin() + base, m_points.begin() + base + num, back_inserter(result),
		boost::phoenix::bind<double>(&Point::operator[], _1, channel));

return result;
}

Point Reader::operator[](size_t index) const
{
	if (index > m_points.size() - 1)
	{
		boost::format msg("index value \"%1%\" out of range: \"[%2%; %3%]\"");
		msg % index % 0 % (m_points.size() - 1);
		ML_THROW(msg.str());
	}

	return m_points[index];
}

class PlayerWD : public InternalWD
{
	friend class AbstractWD;

	osc::ReadStream m_stream;				///< Поток для чтения
	boost::shared_ptr<ml::thread> m_thread;	///< Внутренний поток
	double m_frequency;					///< Частота следования измеренных значений из файла
	Buffer m_buffer;						///< Буфер последних значений
	bool fIsEof;							///< Флаг конца файла
	bool fIsFailed;						///< Флаг ошибки

private:
	void routine();

private:
	PlayerWD(const std::string& filename);

public:
	~PlayerWD();

	AbstractWD::Sample Weight();
};

PlayerWD::PlayerWD(const std::string& filename) : 
m_buffer(SAMPLE_BUFFER_SIZE), m_frequency(0), fIsEof(false), fIsFailed(false)
{
using namespace boost;
using namespace boost::filesystem;

path p(filename);

	shared_ptr<osc::Reader> reader(new osc::Reader( p ));
	m_stream.setReader(reader);
	m_frequency = reader->frequency();

	if (m_frequency == 0)
		ML_TITLE_THROW(MSG__PLAYERWD_ERROR, "Invalid file");

	// Запускаем цикл выборки значений из файла
	m_thread.reset( new ml::thread(boost::bind(&PlayerWD::routine, this)) );
	m_thread->start();
}

void PlayerWD::routine()
{
	try
	{
		Sample s;

		m_stream >> s;

		m_buffer.put( s );
	}
	catch(osc::eof&)
	{
		fIsEof = true;

		// Помещаем в буфер пустой сэмпл
		// Нужно чтобы выпустить клиентский поток, 
		// читающий в данный момент из буфера, если буфер пуст
		m_buffer.put( Sample() );

		m_thread->stop();
	}
	catch (ml::Exception& e)
	{
		// Проблема копирования считанного значения в селектор
		fIsFailed = true;
		Log::out() << e.what() << endl;

		// Помещаем в буфер пустой сэмпл
		// Нужно чтобы выпустить клиентский поток, 
		// читающий в данный момент из буфера, если буфер пуст
		m_buffer.put( Sample() );

		m_thread->stop();
	}

	// Выдавать измерения нужно с заданной частотой
	sleep_us( int(1000 / m_frequency) );
}