Herzlich Willkommen, lieber Gast!
  Sie befinden sich hier:

  Forum » C / C++ (ANSI-Standard) » "Exception-Tagging"

Forum | Hilfe | Team | Links | Impressum | > Suche < | Mitglieder | Registrieren | Einloggen
  Quicklinks: MSDN-Online || STL || clib Reference Grundlagen || Literatur || E-Books || Zubehör || > F.A.Q. < || Downloads   

Autor Thread - Seiten: > 1 <
000
11.12.2009, 20:32 Uhr
0xdeadbeef
Gott
(Operator)


Moin,

Aaalso, ich schreib ja gelegentlich mal an C++-Bibliotheken (das hab ich bestimmt schon mal erwähnt), und dabei fliegen auch mal Exceptions in der Gegend rum. Prinzipiell möchte ich natürlich, dass die von den entsprechenden Standard-Exceptions erben (meistens std::invalid_argument), aber auch, dass ich von meiner Bibliothek geschmissene Exceptions als solche identifizieren kann. Ich habe mir dazu was ausgedacht, und ich wüsste gern, was ihr von dem Ansatz haltet.

Also, das ganze sieht etwa so aus: (ml stehe für "my library")

C++:
#ifndef INCLUDED_ML_ML_EXCEPTION_HH
#define INCLUDED_ML_ML_EXCEPTION_HH

namespace ml {
  class ml_exception {
  public:
    virtual ~ml_exception() throw();
    virtual char const *what() const throw() = 0;
  };

  template<typename base_exception_t>
  class ml_exception_tag
    : public base_exception_t,
      public ml_exception
  {
    // In C++0x mit variadic templates wird das natürlich schöner
    template<typename init_param_t>
    ml_exception_tag(init_param_t const &p)
      : base_exception_t(p) { }

    virtual ~ml_exception() throw() { }

    virtual char const *what() const throw() {
      return base_exception_t::what();
    }
  };
}

#endif



C++:
#include "ml_exception.hh"

namespace ml {
  ml_exception::~ml_exception() throw() { }
}


und soll dann so benutzt werden:

C++:
#include "ml_exception.hh"
#include <stdexcept>

namespace ml {
  class invalid_id
    : public ml_exception_tag<std::invalid_argument>
  {
  public:
    // ...
  };  
}


Damit kann ml::invalid_id sowohl als std::invalid_argument und Basisklassen als auch als ml::ml_exception gefangen werden. Dreckiger Hack oder elegante Lösung?
--
Einfachheit ist Voraussetzung für Zuverlässigkeit.
-- Edsger Wybe Dijkstra

Dieser Post wurde am 11.12.2009 um 20:38 Uhr von 0xdeadbeef editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
001
11.12.2009, 20:58 Uhr
FloSoft
Medialer Over-Flow
(Administrator)



Zitat von 0xdeadbeef:

Dreckiger Hack oder elegante Lösung?

Wüsste jetzt so auf Anhieb nicht wie man das noch schöner machen könnte.
Find ich jetzt relativ elegant.
--
class God : public ChuckNorris { };
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
002
11.12.2009, 21:25 Uhr
0xdeadbeef
Gott
(Operator)


Um Mehrfachvererbung kommt man da nicht herum, und von mehreren Standardexceptions kann man nicht ableiten, weil sie nicht virtuell voneinander erben. Was mir etwas missfällt, aber für den use case derzeit nicht entscheidend ist, ist, dass ich auf die Art nur ein Tag an die Exception ranklatschen kann. Mit C++0x wird das wohl zu

C++:
template<typename    base_exception_t,
         typename... tags>
class exception_tags
  : public base_exception_t,
    public tags...
{
public:
  template<typename... init_params>
  exception_tags(init_params const&... params)
    : base_exception_t(params...) { }

  virtual ~exception_tags() throw() { }

  virtual char const *what() const throw() {
    return base_exception_t::what();
  }
};


...aber das ist derzeit noch Zukunftsmusik.
--
Einfachheit ist Voraussetzung für Zuverlässigkeit.
-- Edsger Wybe Dijkstra

Dieser Post wurde am 11.12.2009 um 21:25 Uhr von 0xdeadbeef editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
003
11.12.2009, 21:34 Uhr
0xdeadbeef
Gott
(Operator)


Hmm...wo ich da grad dran denke, wahrscheinlich mach ich das besser so:

C++:
    template<typename base_exception_t,
             typename   ml_exception_t = ml_exception>
    class ml_exception_tag
      : public base_exception_t,
        public   ml_exception_t
    {
    public:
      template<typename base_exception_init_t>
      ml_exception_tag(base_exception_init_t const &p)
        : base_exception_t(p) { }

      virtual ~ml_exception_tag() throw() { }

      virtual char const *what() const throw() {
        return base_exception_t::what();
      }
    };


...dann kann ich nachher Kram von ml_exception virtuell ableiten, zusammenführen, wie ich lustig bin, und da reinschmeißen.
--
Einfachheit ist Voraussetzung für Zuverlässigkeit.
-- Edsger Wybe Dijkstra

Dieser Post wurde am 11.12.2009 um 21:34 Uhr von 0xdeadbeef editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
Seiten: > 1 <     [ C / C++ (ANSI-Standard) ]  


ThWBoard 2.73 FloSoft-Edition
© by Paul Baecher & Felix Gonschorek (www.thwboard.de)

Anpassungen des Forums
© by Flo-Soft (www.flo-soft.de)

Sie sind Besucher: