class MyGeneralException {
//   тут что-то, например функция, проверяющая, что эта ошибка соответсвует CErrorDescription 
};

class MyFileException : public MyGeneralException{
//   тут что-то на тему о файлах
};

class MyErrorException : public MyGeneralException {
//   тут конструктор от CErrorDescription;
};
//  Ну и т. д.

потом пишешь типа

extern CErrorDescription MyDictionaryOverflow;

// где-то в работе со словарём пишешь так:
void add_word( const char* word )
{
    if(is_dic_owerflow() ) // для этого удобно завести функцию или макрос. Например CheckError
        throw MyErrorException( MyDictionaryOverflow, get_dictionary_name() );
    //  тут код
}

А где-то снаружи, пишешь:
void do_it( const char* text )
{
    try {
        // тут вызов какой-то обработки, в том чисели и add_word
    } catch( MyGeneralException& e ) {
        if( e.IsItOneOf( MyDictionaryOverflow ) ) {
            //  тут какая-то обработка.
        } else {
             throw;
        }
    }
}

#pragma warning(disable: 4290)

/** 
    Реализует базовый тип исключения.\n 
*/
class x_Ception
{
public:
    enum Codes
    {
        ERROR_OPERATION    = 1,
        ERROR_PARAMS    = 2,
    };

private:
    std::string Msg;    ///< Сообщение об ошибке.
    std::string Func;    ///< Название функции в которой сгенерировано исключение.
    std::string File;    ///< Название файла в которой сгенерировано исключение.
    int Line;        ///< Номер строки, в которой сгенерировано исключение.
    int Code;        ///< Код ошибки.

    static std::string CutFilename(std::string fn)
    {
        size_t s = fn.rfind('\\');
        if (s != std::string::npos)
            fn.replace(0, s + 1, "");

        return std::string(fn);
    }

public:
    x_Ception(const std::string& msg, 
              const std::string& func,
              const std::string& file, 
              const int line,
              const int code) :
    Msg(msg), Func(func), File(CutFilename(file)), Line(line), Code(code)
    {}

    x_Ception(const std::string& msg, 
              const std::string& func,
              const std::string& file, 
              const int line) :
    Msg(msg), Func(func), File(CutFilename(file)), Line(line), Code(0)
    {}

    x_Ception(const std::string& msg, 
              const std::string& func) :
    Msg(msg), Func(func), Line(0), Code(0)
    {}

    x_Ception(const std::string& msg) :
    Msg(msg), Line(0), Code(0)
    {}

    virtual ~x_Ception()
    {}

    std::string what() const
    {
        std::ostringstream os;
        os << Msg << ", " << Func << ", " << File << ", " << Line << " ln.";
        return os.str();
    }

    std::string whatMessage() const
    {
        return Msg;
    }

    int whatCode() const
    {
        return Code;
    }

    std::string whereError() const
    {
        std::ostringstream os;
        os << Func << ", " << File << ", " << Line << " ln.";
        return os.str();
    }

    std::string whereFunction() const
    {
        std::ostringstream os;
        os << Func;
        return os.str();
    }
};

class MyStatisticsCollector {
public:
   class x_Ception : public ::x_Ception {
      // тут чего-то ещё
   };
   // тут какие-то методы.
};

class MyDataProcessor {
public:
   class x_Ception : public ::x_Ception {
      // тут чего-то ещё
   };
   // тут какие-то методы.
   //   В том числе и такой:
   int GetDataQuility() const
   {
       MyStaticticsCollector dst;
       for_each_data( curData ) {
           if( !curData->IsValid() )
                THROW_X_CEPTION( "Invalid data detected" );
           dst.AddToStatistics( curData->SomeParam() );
       }
       return dst.GetDispersion();
   }
};

// и теперь я пишу клиента:
bool CompareData( const MyDataProcessor &left, const MyDataProcessor &right )
{
    try {
        return left.GetDataQuility() < right.left.GetDataQuility();
    } catch( x_Ception& e ) {// Какие исключения тут ждать? 
        // тут обработка
    }
}

А>class MyDataProcessor {
А>public:
А>      // У каждого класса индивидуальный тип исключений, производный от базового
А>   class DPError : public ::x_Ception {
А>      // тут чего-то ещё
А>   };
А>};
А>

А>// непосредственный клиент. не очень высокий уровень
А>bool CompareData( const MyDataProcessor &left, const MyDataProcessor &right )
А>{
А>    // Пытаемся обработать в этом контексте
А>    try {
А>        return left.GetDataQuility() < right.left.GetDataQuility();
А>    } catch( MyDataProcessor::DPError& e ) {// Какие исключения тут ждать? 
А>        // тут обработка
А>    }
А>}
А>

MyData data;
do {
    data.AskFromUser();
} while( !dataProc.IsCorrect( data ) );
dataProc.ProcessData( data );

А>// Где-то на самом верху
А>    try {
А>          // вызов функции (мы не знаем, что она сгенерит, но полюбому что-то производное от x_Ception) 
А>          call_method();   
А>        } catch( x_Ception& e ) 
А>       {
А>        // тут обработка
А>       }
А>

class My
{
public:
class Error {};

void Calculate() throw(Error)
{
...
throw Error(...);
}

};

// 1
class Foo
{
void Bar() throw(int);
};
//2
class Foo
{
void Bar() //throw(int); 
};
//3
class Foo
{
void Bar(); // ничего не написано, да же этого
};

function is declared using exception specification, which Visual C++ accepts but does not implement. Code with exception specifications that are ignored during compilation may need to be recompiled and linked to be reused in future versions supporting exception specifications.

Такой подход ужасен!!!

class MyDataProcessor {
public:
      // У каждого класса индивидуальный тип исключений, производный от базового
   class DPError : public ::x_Ception {
      // тут чего-то ещё
   };
   // тут какие-то методы.
   //   В том числе и такой:
   int GetDataQuility() const
   {
       MyStaticticsCollector dst;
       for_each_data( curData ) {
           if( !curData->IsValid() )
                throw DPError( "Invalid data detected" );
           dst.AddToStatistics( curData->SomeParam() );
       }
       return dst.GetDispersion();
   }
};

// непосредственный клиент. не очень высокий уровень
bool CompareData( const MyDataProcessor &left, const MyDataProcessor &right )
{
    // Пытаемся обработать в этом контексте
    try {
        return left.GetDataQuility() < right.left.GetDataQuility();
    } catch( MyDataProcessor::DPError& e ) {// Какие исключения тут ждать? 
        // тут обработка
    }
}

// Где-то на самом верху

    try {
          // вызов функции (мы не знаем, что она сгенерит, но полюбому что-то производное от x_Ception) 
          call_method();   
        } catch( x_Ception& e ) 
       {
        // тут обработка
       }