Russian Qt Forum

C++ (Qt)
#include <vector>
#include <iostream>
#include "freeFunctions.h"
 
int main()
{
    std::vector<int> arr;
 
    try {
        printArray( arr );
    } catch ( const LogicError &e ) {
        std::cerr << e.what() << std::endl;
        return 1;
    } catch ( ... ) {
        std::cerr << "Error: unknown expection" << std::endl;
        return 1;
    }
 
    return 0;
}
 

C++ (Qt)
#ifndef FREEFUNCTIONS_H
#define FREEFUNCTIONS_H
 
#include <vector>
#include <iostream>
#include "EmptyArgument.h"
 
void printArray( const std::vector<int> &arr )
throw ( EmptyArgument );
 
#endif // FREEFUNCTIONS_H
 

C++ (Qt)
#include "freeFunctions.h"
 
void printArray( const std::vector<int> &arr )
    throw ( EmptyArgument )
{
    std::string functionName = "printArray()";
 
    if ( arr.empty( ) ) {
        throw EmptyArgument( functionName );
    }
 
    for ( std::size_t i = 0; i < arr.size(); ++i ) {
        std::cout << arr[i] << std::endl;
    }
}
 

C++ (Qt)
#ifndef EMPTYARGUMENT_H
#define EMPTYARGUMENT_H
 
#include <string>
#include "LogicError.h"
 
class EmptyArgument : public LogicError
{
public:
    EmptyArgument( const std::string &functionName ) :
        LogicError( functionName )
    {
        m_message = "Error: empty argument in the "
                "function " + m_functionName;
    }
};
 
#endif // EMPTYARGUMENT_H
 

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

C++ (Qt)
    try {
        // ...
    }
    catch ( const FileError &e ) {
        std::cerr << e.what( ) << std::endl;
        return 1;
    } catch ( ... ) {
        std::cerr << "Error: unknown exception" << std::endl;
        return 1;
    }
 

C++ (Qt)
#include <iostream>
#include <vector>
#include <QString>
#include "freeFunctions.h"
#include "Person.h"
 
int main( )
{
    // Person array for saving
    Person david( "David", "White");
    Person ivan( "Ivan", "Green" );
    std::vector<Person> persons;
    persons.push_back( david );
    persons.push_back( ivan );
 
    try {
        // Parse the person array to the string content
        QString content;
        parsePersonsToStrContent( persons, content );
 
        // Save the string content to the file
        QString fileName = "file.txt";
        writeData( fileName, content );
 
        // Read the string content from the file
        QString readContent;
        readData( fileName, readContent );
 
        // Parse the string content to the person array
        std::vector<Person> readPersons;
        parseContentToPersons( readContent, readPersons );
 
        // Print the person array on the screen
        printData( readPersons );
    } catch ( const LogicError &e ) {
        std::cerr << e.what( ) << std::endl;
        return 1;
    } catch ( const FileError &e ) {
        std::cerr << e.what( ) << std::endl;
        return 1;
    } catch ( ... ) {
        std::cerr << "Error: unknown exception" << std::endl;
        return 1;
    }
 
    return 0;
}
 

C++ (Qt)
#ifndef PERSON_H
#define PERSON_H
 
#include <QString>
 
class Person {
public:
 
    Person( const QString &firstName = "",
            const QString &lastName = "" ) :
        m_firstName( firstName ),
        m_lastName( lastName )
    {
 
    }
 
    QString firstName( ) const
    {
        return m_firstName;
    }
 
    QString lastName( ) const
    {
        return m_lastName;
    }
 
    void setFirstName( const QString &firstName )
    {
        m_firstName = firstName;
    }
 
    void setLastName( const QString &lastName )
    {
        m_lastName = lastName;
    }
 
private:
    QString m_firstName;
    QString m_lastName;
};
 
#endif // PERSON_H
 

C++ (Qt)
#ifndef FREEFUNCTIONS_H
#define FREEFUNCTIONS_H
 
#include <vector>
 
#include <QString>
 
#include "FileOpenError.h"
#include "FileReadError.h"
#include "FileWriteError.h"
#include "EmptyArgument.h"
#include "Person.h"
 
void readData( const QString &fileName, QString &content )
throw ( EmptyArgument, FileOpenError, FileReadError );
 
void parseContentToPersons( const QString &content,
                            std::vector<Person> &persons )
throw ( EmptyArgument );
 
void parsePersonsToStrContent( const std::vector<Person> &persons,
                               QString &content)
throw ( EmptyArgument );
 
void writeData( const QString &fileName,
                const QString &content )
throw ( EmptyArgument, FileOpenError, FileWriteError );
 
void printData( const std::vector<Person> &persons )
throw ( EmptyArgument );
 
#endif // FREEFUNCTIONS_H
 

C++ (Qt)
#include <iostream>
#include <string>
#include <QFile>
#include <QRegExp>
#include <QTextStream>
#include <QDebug>
#include "freeFunctions.h"
 
void readData(const QString &fileName, QString &content )
throw ( EmptyArgument, FileOpenError, FileReadError )
{
    std::string functionName = "readData()";
 
    // Check argument
    if ( fileName.isEmpty( ) ) {
        throw EmptyArgument( functionName );
    }
 
    // Open the input file for reading
    QFile file( fileName );
    if( !file.open( QIODevice::ReadOnly ) ) {
        throw FileOpenError( fileName.toStdString( ), functionName );
    }
 
    // Read the content from the file
    QByteArray data = file.readAll( );
    if ( data.isEmpty( ) ) {
        throw FileReadError( fileName.toStdString( ), functionName );
    }
 
    content = QString( data );
}
 
void parseContentToPersons( const QString &content, std::vector<Person> &persons )
throw ( EmptyArgument )
{
    std::string functionName = "parseContentToPersons()";
 
    // Check the input argument
    if ( content.isEmpty( ) ) {
        throw EmptyArgument( functionName );
    }
 
    QRegExp regExp("(\\w+) (\\w+)");
    int pos = 0;
    while ( ( pos = regExp.indexIn( content, pos ) ) != -1 ) {
        QString firstName = regExp.cap( 1 );
        QString lastName = regExp.cap( 2 );
        Person person( firstName, lastName );
        persons.push_back( person );
        pos += regExp.matchedLength( );
    }
}
 
void parsePersonsToStrContent( const std::vector<Person> &persons,
                               QString &content)
throw ( EmptyArgument )
{
    std::string functionName = "parsePersonsToStrContent()";
 
    // Check the input argument
    if ( persons.empty( ) ) {
        throw EmptyArgument( functionName );
    }
 
    for ( std::size_t i = 0; i < persons.size( ); ++i ) {
        QString firstName = persons[i].firstName( );
        QString lastName = persons[i].lastName( );
        QString line = QString( "%1 %2\n" ).arg( firstName ).arg( lastName );
        content.append( line );
    }
}
 
void writeData( const QString &fileName, const QString &content )
throw ( EmptyArgument, FileOpenError, FileWriteError )
{
    std::string functionName = "writeData()";
 
    // Check arguments
    if ( fileName.isEmpty( ) || content.isEmpty( ) ) {
        throw EmptyArgument( functionName );
    }
 
    // Open the output file for writing
    QFile file( fileName );
    if ( !( file.open( QIODevice::WriteOnly ) ) ) {
        throw FileOpenError( fileName.toStdString( ), functionName );
    }
 
    // Write data to the output file
    QTextStream stream( &file );
    stream << content;
    if ( stream.status() != QTextStream::Ok ) {
        throw FileWriteError( fileName.toStdString( ), functionName );
    }
}
 
void printData( const std::vector<Person> &persons )
throw ( EmptyArgument )
{
    std::string functionName = "printData()";
 
    // Check the input argument
    if ( persons.empty( ) ) {
        throw EmptyArgument( functionName );
    }
 
    // Print data
    for ( std::size_t i = 0; i < persons.size( ); ++i ) {
        std::cout << "First Name: " << persons[i].firstName( ).toStdString( ) << std::endl;
        std::cout << "Last Name: " << persons[i].lastName( ).toStdString( ) << std::endl;
        std::cout << std::endl;
    }
}
 

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

C++ (Qt)
#ifndef FILEOPENERROR_H
#define FILEOPENERROR_H
 
#include <string>
#include "FileError.h"
 
class FileOpenError : public FileError {
public:
 
    FileOpenError( const std::string &fileName,
                   const std::string &functionName) :
        FileError( fileName, functionName )
    {
        m_message = "Error: unable to open the file \"" +
                m_fileName + "\" in the function \"" +
                m_functionName + "\"";
    }
};
 
#endif // FILEOPENERROR_H
 

C++ (Qt)
#ifndef FILEREADERROR_H
#define FILEREADERROR_H
 
#include <string>
#include "FileError.h"
 
class FileReadError : public FileError {
public:
 
    FileReadError( const std::string &fileName,
                   const std::string &functionName ) :
        FileError( fileName, functionName )
    {
        m_message = "Error: unable to read the file \"" + m_fileName +
                "\" in the function \"" + m_functionName + "\"";
    }
};
 
#endif // FILEREADERROR_H
 

C++ (Qt)
#ifndef FILEWRITEERROR_H
#define FILEWRITEERROR_H
 
#include <string>
#include "FileError.h"
 
class FileWriteError : public FileError {
public:
 
    FileWriteError( const std::string &fileName,
                    const std::string &functionName ) :
        FileError( fileName, functionName )
    {
        m_message = "Error: unable to write to the file " +
                m_fileName + " in the function " + m_functionName;
    }
};
 
#endif // FILEWRITEERROR_H
 

C++ (Qt)
#ifndef EMPTYARGUMENT_H
#define EMPTYARGUMENT_H
 
#include <string>
#include "LogicError.h"
 
class EmptyArgument : public LogicError {
public:
 
    EmptyArgument( const std::string &functionName ) :
        LogicError( functionName )
    {
        m_message = "Error: empty argument in the "
                "function " + m_functionName;
    }
};
 
#endif // EMPTYARGUMENT_H
 

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

C++ (Qt)
throw OutOfRange<int>( beginOfRange, endOfRange, functionName );

C++ (Qt)
#include <iostream>
#include "Calculator.h"
 
int main()
{
    Calculator<float> calculator;
 
    try {
        float result = calculator.divide( 24.7f, 3.0f );
        std::cout << "Result = " << result << std::endl;
    } catch ( const LogicError &e ) {
        std::cerr << e.what() << std::endl;
        return 1;
    } catch ( ... ) {
        std::cerr << "Error: unknown expection" << std::endl;
        return 1;
    }
 
    return 0;
}

C++ (Qt)
#ifndef CALCULATOR_H
#define CALCULATOR_H
 
#include <string>
#include "DivideByZero.h"
#include "OutOfRange.h"
 
template <typename Type>
class Calculator
{
public:
    // Divide nums from the range [-1000, 1000]
    Type divide( Type a, Type b )
    throw ( DivideByZero, OutOfRange<int> )
    {
        std::string functionName = "Calculator::divide()";
        if ( b == 0 ) {
            throw DivideByZero( functionName );
        }
 
        const int beginOfRange = -1000;
        const int endOfRange = 1000;
 
        if ( ( a < beginOfRange ) || ( a > endOfRange ) ||
             ( b < beginOfRange ) || ( b > endOfRange ) )
        {
            throw OutOfRange<int>( beginOfRange,
                                   endOfRange,
                                   functionName );
        }
 
        return a / b;
    }
};
 
#endif // CALCULATOR_H

C++ (Qt)
#ifndef DIVIDEBYZERO_H
#define DIVIDEBYZERO_H
 
#include <string>
#include "LogicError.h"
 
class DivideByZero : public LogicError
{
public:
    DivideByZero( const std::string &functionName ) :
        LogicError( functionName )
    {
        m_message = "Error: divide by zero in the "
                "function " + m_functionName;
    }
};
 
#endif // DIVIDEBYZERO_H

C++ (Qt)
#ifndef OUTOFRANGE_H
#define OUTOFRANGE_H
 
#include <string>
#include "LogicError.h"
 
template <typename Type>
class OutOfRange : public LogicError
{
public:
    OutOfRange( Type beginOfRange,
                Type endOfRange,
                const std::string &functionName ) :
        LogicError( functionName )
    {
        m_message = "Error: values must be from the range "
                    "[" + std::to_string( beginOfRange ) +
                    ", " + std::to_string( endOfRange ) + "]"
                    " in the function " + m_functionName;
    }
};
 
#endif // OUTOFRANGE_H

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

C++ (Qt)
    // Divide nums from the range [-1000, 1000]
    Type divide( Type a, Type b )
    throw ( DivideByZero, OutOfRange<int> )
    {
        std::string functionName = "Calculator::divide()";
        if ( b == 0 ) {
            throw DivideByZero( functionName );
        }
 
        const int beginOfRange = -1000;
        const int endOfRange = 1000;
 
        if ( ( a < beginOfRange ) || ( a > endOfRange ) ||
             ( b < beginOfRange ) || ( b > endOfRange ) )
        {
            throw OutOfRange<int>( beginOfRange,
                                   endOfRange,
                                   functionName );
        }
 
        return a / b;
    }
};

C++ (Qt)
if (b == 0) throw std::overflow_error("invalid b");  // все, с приветом, др разумной обработки нет
a /= b;
 

C++ (Qt)
template <class T>
T ValidVal( T val, T minV = FUDGE_FACTOR ) 
{
 if (unlikely(fabs(val)) < minV) return minV * (val < 0 ? -1 :  1);
 return val; 
}
...
a /= ValidVal(b);

C++ (Qt)
a /= b;

C++ (Qt)
throw OutOfRange<int>( beginOfRange,
                                  endOfRange,
                                  functionName );

C++ (Qt)
#include <QVector>
#include <iostream>
#include "freeFunctions.h"
 
int main()
{
    QVector<int> arr;
 
    try {
        printArray( arr );
    } catch ( const LogicError &e ) {
        std::cerr << e.what() << std::endl;
        return 1;
    } catch ( ... ) {
        std::cerr << "Error: unknown expection" << std::endl;
        return 1;
    }
 
    return 0;
}
 

C++ (Qt)
#ifndef FREEFUNCTIONS_H
#define FREEFUNCTIONS_H
 
#include <QVector>
#include <iostream>
#include "EmptyArgument.h"
 
void printArray( const QVector<int> &arr )
throw ( EmptyArgument );
 
#endif // FREEFUNCTIONS_H
 

C++ (Qt)
#include "freeFunctions.h"
 
void printArray(const QVector<int> &arr )
    throw ( EmptyArgument )
{
    std::string functionName = "printArray()";
 
    if ( arr.isEmpty() ) {
        throw EmptyArgument( functionName );
    }
 
    for ( std::size_t i = 0; i < arr.size(); ++i ) {
        std::cout << arr[i] << std::endl;
    }
}
 

C++ (Qt)
#ifndef EMPTYARGUMENT_H
#define EMPTYARGUMENT_H
 
#include <string>
#include "LogicError.h"
 
class EmptyArgument : public LogicError
{
public:
    EmptyArgument( const std::string &functionName ) :
        LogicError( functionName )
    {
        m_message = "Error: empty argument in the "
                "function " + m_functionName;
    }
};
 
#endif // EMPTYARGUMENT_H
 

C++ (Qt)
throw OutOfRange<int>( beginOfRange,
                                  endOfRange,
                                  functionName );
 

C++ (Qt)
// использование
if (!ValidRange <int>(value, MIN_VAL, MAX_VAL)) return false;
..
// ф-ция проверки
template <class T>
bool ValidRange( T val, T minV, T maxV, bool useException = true )
{
 if (val >= minV && val <= maxV) return true;
 std::string errText;
  .. // печатаем ошибку
 
 if (useException) 
  throw std::out_of_range(errText);
 else
  printf("error: %s\n", errText.c_str());  // для отладки
 return false;
} 
 

C++ (Qt)
    try {
        // ...
    }
    catch ( const FileError &e ) {
        std::cerr << e.what( ) << std::endl;
        return 1;
    } catch ( ... ) {
        std::cerr << "Error: unknown exception" << std::endl;
        return 1;
    }
 

C++ (Qt)
#include <iostream>
#include <vector>
#include <QString>
#include "freeFunctions.h"
#include "Person.h"
 
int main( )
{
    // Person array for saving
    Person david( "David", "White");
    Person ivan( "Ivan", "Green" );
    std::vector<Person> persons;
    persons.push_back( david );
    persons.push_back( ivan );
 
    try {
        // Parse the person array to the string content
        QString content;
        parsePersonsToStrContent( persons, content );
 
        // Save the string content to the file
        QString fileName = "file.txt";
        writeData( fileName, content );
 
        // Read the string content from the file
        QString readContent;
        readData( fileName, readContent );
 
        // Parse the string content to the person array
        std::vector<Person> readPersons;
        parseContentToPersons( readContent, readPersons );
 
        // Print the person array on the screen
        printData( readPersons );
    } catch ( const LogicError &e ) {
        std::cerr << e.what( ) << std::endl;
        return 1;
    } catch ( const FileError &e ) {
        std::cerr << e.what( ) << std::endl;
        return 1;
    } catch ( ... ) {
        std::cerr << "Error: unknown exception" << std::endl;
        return 1;
    }
 
    return 0;
}
 

C++ (Qt)
#ifndef PERSON_H
#define PERSON_H
 
#include <QString>
 
class Person {
public:
 
    Person( const QString &firstName = "",
            const QString &lastName = "" ) :
        m_firstName( firstName ),
        m_lastName( lastName )
    {
 
    }
 
    QString firstName( ) const
    {
        return m_firstName;
    }
 
    QString lastName( ) const
    {
        return m_lastName;
    }
 
    void setFirstName( const QString &firstName )
    {
        m_firstName = firstName;
    }
 
    void setLastName( const QString &lastName )
    {
        m_lastName = lastName;
    }
 
private:
    QString m_firstName;
    QString m_lastName;
};
 
#endif // PERSON_H
 

C++ (Qt)
#ifndef FREEFUNCTIONS_H
#define FREEFUNCTIONS_H
 
#include <vector>
 
#include <QString>
 
#include "FileOpenError.h"
#include "FileReadError.h"
#include "FileWriteError.h"
#include "EmptyArgument.h"
#include "Person.h"
 
void readData( const QString &fileName, QString &content )
throw ( EmptyArgument, FileOpenError, FileReadError );
 
void parseContentToPersons( const QString &content,
                            std::vector<Person> &persons )
throw ( EmptyArgument );
 
void parsePersonsToStrContent( const std::vector<Person> &persons,
                               QString &content)
throw ( EmptyArgument );
 
void writeData( const QString &fileName,
                const QString &content )
throw ( EmptyArgument, FileOpenError, FileWriteError );
 
void printData( const std::vector<Person> &persons )
throw ( EmptyArgument );
 
#endif // FREEFUNCTIONS_H
 

C++ (Qt)
#include <iostream>
#include <string>
#include <QFile>
#include <QRegExp>
#include <QTextStream>
#include <QDebug>
#include "freeFunctions.h"
 
void readData(const QString &fileName, QString &content )
throw ( EmptyArgument, FileOpenError, FileReadError )
{
    std::string functionName = "readData()";
 
    // Check argument
    if ( fileName.isEmpty( ) ) {
        throw EmptyArgument( functionName );
    }
 
    // Open the input file for reading
    QFile file( fileName );
    if( !file.open( QIODevice::ReadOnly ) ) {
        throw FileOpenError( fileName.toStdString( ), functionName );
    }
 
    // Read the content from the file
    QByteArray data = file.readAll( );
    if ( data.isEmpty( ) ) {
        throw FileReadError( fileName.toStdString( ), functionName );
    }
 
    content = QString( data );
}
 
void parseContentToPersons( const QString &content, std::vector<Person> &persons )
throw ( EmptyArgument )
{
    std::string functionName = "parseContentToPersons()";
 
    // Check the input argument
    if ( content.isEmpty( ) ) {
        throw EmptyArgument( functionName );
    }
 
    QRegExp regExp("(\\w+) (\\w+)");
    int pos = 0;
    while ( ( pos = regExp.indexIn( content, pos ) ) != -1 ) {
        QString firstName = regExp.cap( 1 );
        QString lastName = regExp.cap( 2 );
        Person person( firstName, lastName );
        persons.push_back( person );
        pos += regExp.matchedLength( );
    }
}
 
void parsePersonsToStrContent( const std::vector<Person> &persons,
                               QString &content)
throw ( EmptyArgument )
{
    std::string functionName = "parsePersonsToStrContent()";
 
    // Check the input argument
    if ( persons.empty( ) ) {
        throw EmptyArgument( functionName );
    }
 
    for ( std::size_t i = 0; i < persons.size( ); ++i ) {
        QString firstName = persons[i].firstName( );
        QString lastName = persons[i].lastName( );
        QString line = QString( "%1 %2\n" ).arg( firstName ).arg( lastName );
        content.append( line );
    }
}
 
void writeData( const QString &fileName, const QString &content )
throw ( EmptyArgument, FileOpenError, FileWriteError )
{
    std::string functionName = "writeData()";
 
    // Check arguments
    if ( fileName.isEmpty( ) || content.isEmpty( ) ) {
        throw EmptyArgument( functionName );
    }
 
    // Open the output file for writing
    QFile file( fileName );
    if ( !( file.open( QIODevice::WriteOnly ) ) ) {
        throw FileOpenError( fileName.toStdString( ), functionName );
    }
 
    // Write data to the output file
    QTextStream stream( &file );
    stream << content;
    if ( stream.status() != QTextStream::Ok ) {
        throw FileWriteError( fileName.toStdString( ), functionName );
    }
}
 
void printData( const std::vector<Person> &persons )
throw ( EmptyArgument )
{
    std::string functionName = "printData()";
 
    // Check the input argument
    if ( persons.empty( ) ) {
        throw EmptyArgument( functionName );
    }
 
    // Print data
    for ( std::size_t i = 0; i < persons.size( ); ++i ) {
        std::cout << "First Name: " << persons[i].firstName( ).toStdString( ) << std::endl;
        std::cout << "Last Name: " << persons[i].lastName( ).toStdString( ) << std::endl;
        std::cout << std::endl;
    }
}
 

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

C++ (Qt)
#ifndef FILEOPENERROR_H
#define FILEOPENERROR_H
 
#include <string>
#include "FileError.h"
 
class FileOpenError : public FileError {
public:
 
    FileOpenError( const std::string &fileName,
                   const std::string &functionName) :
        FileError( fileName, functionName )
    {
        m_message = "Error: unable to open the file \"" +
                m_fileName + "\" in the function \"" +
                m_functionName + "\"";
    }
};
 
#endif // FILEOPENERROR_H
 

C++ (Qt)
#ifndef FILEREADERROR_H
#define FILEREADERROR_H
 
#include <string>
#include "FileError.h"
 
class FileReadError : public FileError {
public:
 
    FileReadError( const std::string &fileName,
                   const std::string &functionName ) :
        FileError( fileName, functionName )
    {
        m_message = "Error: unable to read the file \"" + m_fileName +
                "\" in the function \"" + m_functionName + "\"";
    }
};
 
#endif // FILEREADERROR_H
 

C++ (Qt)
#ifndef FILEWRITEERROR_H
#define FILEWRITEERROR_H
 
#include <string>
#include "FileError.h"
 
class FileWriteError : public FileError {
public:
 
    FileWriteError( const std::string &fileName,
                    const std::string &functionName ) :
        FileError( fileName, functionName )
    {
        m_message = "Error: unable to write to the file " +
                m_fileName + " in the function " + m_functionName;
    }
};
 
#endif // FILEWRITEERROR_H
 

C++ (Qt)
#ifndef EMPTYARGUMENT_H
#define EMPTYARGUMENT_H
 
#include <string>
#include "LogicError.h"
 
class EmptyArgument : public LogicError {
public:
 
    EmptyArgument( const std::string &functionName ) :
        LogicError( functionName )
    {
        m_message = "Error: empty argument in the "
                "function " + m_functionName;
    }
};
 
#endif // EMPTYARGUMENT_H
 

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

C++ (Qt)
    try {
        // Parse the person array to the Json-content
        QJsonDocument content;
        parsePersonsToContent( persons, content );
    } catch ( const LogicError &e ) {
        std::cerr << e.what( ) << std::endl;
        return 1;
    }
    catch ( ... ) {
        std::cerr << "Error: unknown exception" << std::endl;
        return 1;
    }

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 + "\"";
    }
    // ...
 

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;
    }
}

C++ (Qt)
#ifndef RECEIVER_H
#define RECEIVER_H
 
#include <QObject>
#include <QString>
#include <QSerialPort>
#include <stdexcept>
#include <string>
#include "PortError.h"
 
class Receiver : public QObject {
    Q_OBJECT
public:
 
    Receiver( const QString &portName = QString( "COM2" ),
              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 );
 
    Receiver( const Receiver &receiver );
 
    ~Receiver();
 
    void run( ) throw( PortError );
 
    QString getPortName() const;
    QSerialPort::BaudRate getBaudRate() const;
    QSerialPort::DataBits getDataBist() const;
    QSerialPort::Parity getParity() const;
    QSerialPort::StopBits getStopBits() const;
    QSerialPort::FlowControl getFlowControl() const;
 
signals:
    void signalReceivedData( QByteArray data );
 
private slots:
    void slotReadyRead( );
 
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 // RECEIVER_H
 

C++ (Qt)
#include "Receiver.h"
 
Receiver::Receiver( 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 )
{
}
 
Receiver::Receiver( const Receiver &receiver )
{
    this->m_portName = receiver.getPortName();
    this->m_baudRate = receiver.getBaudRate();
    this->m_dataBits = receiver.getDataBist();
    this->m_parity = receiver.getParity();
    this->m_stopBits = receiver.getStopBits();
    this->m_flowControl = receiver.getFlowControl();
}
 
Receiver::~Receiver()
{
    m_serialPort.close();
}
 
void Receiver::run( ) throw( PortError )
{
    m_serialPort.setPortName( m_portName );
 
    if ( !m_serialPort.open( QIODevice::ReadOnly ) ) {
        throw PortError( m_portName.toStdString() );
    }
 
    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 );
 
    connect( &m_serialPort, SIGNAL( readyRead( ) ),
             this, SLOT( slotReadyRead( ) ) );
}
 
QString Receiver::getPortName() const
{
    return m_portName;
}
 
QSerialPort::BaudRate Receiver::getBaudRate() const
{
    return m_baudRate;
}
 
QSerialPort::DataBits Receiver::getDataBist() const
{
    return m_dataBits;
}
 
QSerialPort::Parity Receiver::getParity() const
{
    return m_parity;
}
 
QSerialPort::StopBits Receiver::getStopBits() const
{
    return m_stopBits;
}
 
QSerialPort::FlowControl Receiver::getFlowControl() const
{
    return m_flowControl;
}
 
void Receiver::slotReadyRead( )
{
    QByteArray data;
    data = m_serialPort.readAll( );
    emit signalReceivedData( data );
}
 

C++ (Qt)
#ifndef PORTERROR_H
#define PORTERROR_H
 
#include <stdexcept>
#include <string>
 
class PortError : public std::runtime_error
{
public:
    PortError( const std::string &portName ) : std::runtime_error( "" )
    {
        m_message = "Error: unable to open the port \"" +
                portName + "\"";
    }
 
    virtual ~PortError() throw()
    {
 
    }
 
    virtual const char *what() const throw()
    {
        return m_message.c_str();
    }
 
    std::string getMessage()
    {
        return m_message;
    }
 
private:
    std::string m_message;
};
 
#endif // PORTERROR_H
 

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

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;
    }
}
 

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
 

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;
}
 

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
 

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
 

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