Результатом осмысления опыта, является осмысленный опыт, позволяющий осознанно принимать решения.

А интуиция это нечто совершенно другое.
Есть автоматизм, который приходит с опытом и тренировками, а есть интуиция.

Это только у википедиков интуиция есть результат осмысления опыта. В жизни все по другому.

Интуиция это и есть наш опыт в неявной форме. Профессиональный строитель забьёт гвоздь 1 ударом. Профессиональный портной сделает закройку парой движений. Профессиональный инженер даже без уровня заценит размер помещения с точностью до 20 см и увидит кривизну. А профессиональный программист при просмотре кода зацепится за несоответствие и закроет баг, не дожидаясь слива в интернете.

Закроем тему интуиции.

Не спорю далее я с вами,
Не мне вас в этом убеждать.
Когда нибудь поймёте сами,
Где интуицию вам взять

Какой-то Вы неумелый провокатор Если, по-Вашему, я не разбираюсь, то зачем же Вам слушать мои объяснения? Я могу удобно соскочить: "если Вы такой умный - Вы и объясните". Ну да ладно, попробую поддержать конструктив, но будете еще фыркать - перестану отвечать

Плохо здесь то что классов наворочено много, а толку никакого. Каждый класс посвящен печати - а это 10 раз поменяется в том же проекте. А про повторное использование и говорить нечего. Правильно планировать так чтобы было удобно обработчику который поймал catch и общается с юзверем. Напр чтение/запись файла. Какие случаи меня интересуют?

1) Файл отсутствует
2) открыт по записи др приложением
3) диск переполнен

Все остальное - какая-то "общая ошибка", все равно мне нечего предпринять. От "испустившего" мне нужен КОД ОШИБКИ, а разбираться с ним я буду сам. Напр в случае "3" возможно "Try Again" (юзер почистит trash и нажмет). Зачем было городить класс на каждый случай - хз. Тот клаcc все равно ничего путного не сделает, т.к. он не знает что нужно - это знает "ловящий"

Это потому, что ТС не смог объяснить для чего же нужны деревья разных исключений, а вы их начали воспринимать в меру своих знаний.

Я уже писал, что C++ это промышленный язык, для разработки больших систем, поэтому когда мы разрабатываем подсистему, мы хотим сделать ее максимально универсальной, что бы было возможно использовать ее без переделки и дублирования во многих местах системы. Поэтому, мы должны учесть и сообщать исключениями о совершенно разных событиях, которые могут произойти при работе. Мы не знаем, где, когда, кто и как эти события будет обрабатывать.
В одном месте системы при использовании подсистемы Storage мне хватит одной общей ошибки StorageError, в другом месте системы, мне понадобиться детально разобраться, а что же происходит с хранилищем и принять меры. Причем, у меня разные исключения могут обрабатываться не то, что в одной функции (или в методах одного класса), а на разных логических уровнях. Какие-то я обработаю в самом низу (нет хранилища - ничего, попробую другое из доступных), какие-то будут обрабатываться уровнем выше (нет данных в хранилище - я попробую обойтись значениями по умолчанию, если получиться), а если хранилища разрушены - то мне ничего не остается, как завершить процесс с выводом диагностики оператору в функции main.

Мне нужны развесистые деревья исключений (да и не только мне), поэтому не стоит рассказывать, что это какие-то ошибки и нормальные программисты так не сделают. Кто тут у нас решает кто нормальный программист, а кто нет?

Тем более не нужно отвечать за всю отрасль, как вы любите говорить: "Обычно делают так". Вы понятия не имеете как это делается на самом деле. Честнее писать "Что так делаете именно вы", ну собственно как все на форуме и делают.

Ну почему из Вас постоянно прет заносчивость и спесь? Так Вы ничего не достигаете и никого не убеждаете, только себе вредите.

Практически это вся аргументация. "Я так делаю", а кто делает иначе - неграмотный, понятия не имеет...  Вот давайте сделаем на каждый чих класс исключения, и тогда нам будет гораздо легче поддерживать сложную систему. Да с какой стати? Каждый новый шаг разработки создает новые ситуации - значит новые классы. У меня впечатление что Вы просто злоупотребляете исключениями - тогда да, без "ветвистости" не обойтись.

Ладно, раз пошел переход на личности - тема себя исчерпала (впрочем и была дохленькая). Умолкаю

Очень важный момент. Хотелось бы не упустить. Давайте не сразу всё, а немного уточним до этого момента: "вы перекрыли виртуальный метод Qt-класса". Что значит: "Qt работает после вашего исключения"? После моего обработанного исключения? Или необработанного? Вроде после необработанного исключения приложение падает. Не всегда? Я думаю, что в стандарте C++ должен быть ответ, но врядли я найду. Прошу прощения, но Qt и C++ я изучаю (по-настоящему и серьёзно) меньше года и сейчас с боем прорываюсь всеми методами, в том числе и провакационными темами и вопросами. На войне лучше всего узнаёшь людей. Кто действительно дело говорит, а кто самоутверждается за счёт унижения других

"Qt работает после вашего отловленного исключения". Я готов предположить, что имеется ввиду ситуация, когда я перебрасываю исключение на уровень выше. Просто уточните: да или нет. Я обязательно напишу пример. Только помогите разобраться или натолкните на мысль

"Также яркий пример - исключения их слотов (не допустимы). "
Если можно, то чуть подробнее

Покажу, какой я сделал класс "Receiver". А вы напишите, хорош ли он с точки зрения обработки ошибок и в какой ситуации он может быть плох. И какие меры предпринять, чтобы убрать эту "плохость", если она есть. У этого класса есть метод "run()", который запускаем приём данных от COM-порта. Если посылка пришла, то высылается сигнал с данными QByteArray. Этот метод "run()" выбрасывает исключение моего типа "PortError":

C++ (Qt)
class PortError : public std::runtime_error
{
public:
    PortError( const std::string &portName ) : std::runtime_error( "" )
    {
        m_message = "Error: unable to open the port \"" +
                portName + "\"";
    }
    // ...
 

Вот таким образом я вызываю метод "run()"

C++ (Qt)
void MainWindow::runReceiver()
{
    try {
        m_receiver->run();
        connect( m_receiver, SIGNAL( signalReceivedData( QByteArray ) ),
                 this, SLOT( slotReceivedData( QByteArray ) ) );
    } catch ( const PortError &e ) {
        QString message( e.what() );
        QMessageBox::information( this, tr( "Error" ), message );
        return;
    } catch( ... ) {
        QString message( "Error: unknown exception" );
        QMessageBox::information( this, tr( "Error" ), message );
        return;
    }
}

Я придумал отличный пример из жизни вокруг которого можно построить статью. Займусь переделкой статьи позже. А пока изложу суть

Задача отправлять данные в COM-порт. COM-порт может быть закрыт. Либо он может быть отрыт, но данные в него нельзя отправить

Класс Sender имеет два метода:
- open() - для открытия порта
- void send( const QByteArray &data ) - для отправки данных в порт

Пользователь класса Sender открывает порт так:

C++ (Qt)
    try {
        m_sender->open();
    } catch( const PortOpenError &e ) {
        QString message( e.what() );
        QMessageBox::critical( this, tr( "Error" ), message );
        return;
    }
 

Метод open выбрасывает исключение PortOpenError с текстом:



Метод send выбрасывает два исключения PortOpenError, PortSendDataError. Второе исключение с текстом: Error: unable to send data to the port "COM7" in the fucntion "Sender::send()" Оба исключения наследуются от базового класса PortError, поэтому пользотелю класса Sender достаточно написать один catch для PortError, а второй catch( ... ) (для всех исключений), на всякий случай:

C++ (Qt)
void MainWindow::on_sendButton_clicked()
{
    QByteArray data = "Hello!";
 
    try {
        m_sender->send( data );
    } catch( const PortError &e ) {
        QString message( e.what() );
        QMessageBox::critical( this, tr( "Error" ), message );
        return;
    } catch( ... ) {
        QMessageBox::critical( this, tr( "Error" ),
                               tr ( "Error: unknown exception." ) );
        return;
    }
}
 

Sender.h

C++ (Qt)
#ifndef SENDER_H
#define SENDER_H
 
#include <QSerialPort>
#include <QString>
#include "PortOpenError.h"
#include "PortSendDataError.h"
 
class Sender
{
public:
    Sender( const QString &portName = QString( "COM1" ),
            QSerialPort::BaudRate baudRate = QSerialPort::Baud9600,
            QSerialPort::DataBits dataBits = QSerialPort::Data8,
            QSerialPort::Parity parity = QSerialPort::NoParity,
            QSerialPort::StopBits stopBits = QSerialPort::OneStop,
            QSerialPort::FlowControl flowControl = QSerialPort::NoFlowControl );
 
    Sender( const Sender &sender );
 
    ~Sender();
 
    void setPortName( const QString &portName );
 
    QString getPortName() const;
    QSerialPort::BaudRate getBaudRate() const;
    QSerialPort::DataBits getDataBits() const;
    QSerialPort::Parity getParity() const;
    QSerialPort::StopBits getStopBits() const;
    QSerialPort::FlowControl getFlowControl() const;
 
    void open() throw( PortOpenError );
 
    void send( const QByteArray &data )
    throw( PortOpenError, PortSendDataError );
 
private:
    QSerialPort m_serialPort;
    QString m_portName;
    QSerialPort::BaudRate m_baudRate;
    QSerialPort::DataBits m_dataBits;
    QSerialPort::Parity m_parity;
    QSerialPort::StopBits m_stopBits;
    QSerialPort::FlowControl m_flowControl;
};
 
#endif // SENDER_H
 

Sender.cpp

C++ (Qt)
#include "Sender.h"
 
Sender::Sender( const QString &portName,
                QSerialPort::BaudRate baudRate,
                QSerialPort::DataBits dataBits,
                QSerialPort::Parity parity,
                QSerialPort::StopBits stopBits,
                QSerialPort::FlowControl flowControl ) :
    m_portName( portName ),
    m_baudRate( baudRate ),
    m_dataBits( dataBits ),
    m_parity( parity ),
    m_stopBits( stopBits ),
    m_flowControl( flowControl )
{
}
 
void Sender::open() throw( PortOpenError )
{
    m_serialPort.setPortName( m_portName );
 
    std::string functionName = "Sender::open()";
 
    // Open the port
    if ( !m_serialPort.open( QIODevice::WriteOnly ) ) {
        throw PortOpenError( m_serialPort.portName().toStdString(),
                             functionName );
    }
 
    // Set settings
    m_serialPort.setBaudRate( m_baudRate );
    m_serialPort.setDataBits( m_dataBits );
    m_serialPort.setParity( m_parity );
    m_serialPort.setStopBits( m_stopBits );
    m_serialPort.setFlowControl( m_flowControl );
}
 
void Sender::send( const QByteArray &data )
throw( PortOpenError, PortSendDataError )
{
    std::string functionName = "Sender::send()";
 
    // Check opened or not
    if ( !m_serialPort.isOpen() ) {
        throw PortOpenError( m_serialPort.portName().toStdString(),
                             functionName );
    }
 
    // Write data to the port
    if ( m_serialPort.write( data ) == -1 ) {
        throw PortSendDataError( m_serialPort.portName().toStdString(),
                                 functionName );
    }
}
 
Sender::Sender( const Sender &sender )
{
    this->m_portName = sender.getPortName();
    this->m_baudRate = sender.getBaudRate();
    this->m_dataBits = sender.getDataBits();
    this->m_parity = sender.getParity();
    this->m_stopBits = sender.getStopBits();
    this->m_flowControl = sender.getFlowControl();
}
 
Sender::~Sender()
{
    m_serialPort.close();
}
 
void Sender::setPortName( const QString &portName )
{
    m_portName = portName;
}
 
QString Sender::getPortName() const
{
    return m_portName;
}
 
QSerialPort::BaudRate Sender::getBaudRate() const
{
    return m_baudRate;
}
 
QSerialPort::DataBits Sender::getDataBits() const
{
    return m_dataBits;
}
 
QSerialPort::Parity Sender::getParity() const
{
    return m_parity;
}
 
QSerialPort::StopBits Sender::getStopBits() const
{
    return m_stopBits;
}
 
QSerialPort::FlowControl Sender::getFlowControl() const
{
    return m_flowControl;
}
 

PortOpenError.h

C++ (Qt)
#ifndef PORTOPENERROR_H
#define PORTOPENERROR_H
 
#include "PortError.h"
 
class PortOpenError : public PortError
{
public:
    PortOpenError( const std::string &portName,
                   const std::string &functionName ) :
        PortError( portName, functionName )
    {
        m_message = "Error: unable to open the port \"" +
                m_portName + "\"" + " in the function " +
                "\"" + m_functionName + "\"";
    }
};
 
#endif // PORTOPENERROR_H
 

PortSendDataError.h

C++ (Qt)
#ifndef PORTSENDDATAERROR_H
#define PORTSENDDATAERROR_H
 
#include "PortError.h"
 
class PortSendDataError : public PortError
{
public:
    PortSendDataError( const std::string &portName,
                       const std::string &functionName ) :
        PortError( portName, functionName )
    {
        m_message = "Error: unable to send data to the port \"" +
                m_portName + "\"" + " in the function " +
                "\"" + m_functionName + "\"";
    }
};
 
#endif // PORTSENDDATAERROR_H
 

PortError.h

C++ (Qt)
#ifndef PORTERROR_H
#define PORTERROR_H
 
#include <stdexcept>
#include <string>
 
class PortError : public std::runtime_error
{
public:
    PortError( const std::string &portName,
               const std::string &functionName ) : std::runtime_error( "" ),
        m_portName( portName ),
        m_functionName( functionName )
    {
    }
 
    virtual ~PortError() throw()
    {
    }
 
    virtual const char *what() const throw()
    {
        return m_message.c_str();
    }
 
protected:
    std::string m_message;
    std::string m_portName;
    std::string m_functionName;
};
 
#endif // PORTERROR_H