fehler zurueck geben

Meep Meep

hi all

ich schreib grad mehrere funktionen die in einer dll liegen. nun kann es zu unterschiedlichen fehlern kommen. z.b. system-fehler, http-fehler oder auch mysql-fehler. was waere da eine intelligente art den fehler zurueckzufuehren, damit man auch weiß um welchen es sich handelt ? die fehler codes koennen sich naemlich unterscheiden. im normalfall wuerd ich unterschiedliche exceptions werfen: system_Error, internet_Error, mysql_error. geht aber ueber dll grenzen nicht.
jemand eine idee ?

Meep Meep

Meep Meep schrieb:

geht aber ueber dll grenzen nicht.

In dieser allgemeinen Form ist das falsch.

Meep Meep

ueber dll grenzen hibweg funktioniert das nur unter bestimmten umstaenden. die dll wird wahrscheinlich nie mhr angeruehrt und das hostprogramm wird nicht unbedingt mit dem selben compiler compiliert. also sag ich einfach mal: geht nicht

Du kannst doch auch einfach den Rückgabewert testen.

Meep Meep

hab mich verschrieben. sollte ueberschneiden und nicht unterscheiden heissen.
z.b. koennte ein fehlercode 50 von der mysql api oder vom system sein.

Kann man nicht allein schon aus dem Kontext des Codes nachvollziehen um welchen Fehlercode es sich handelt?

Ansonsten kannst du doch bestimmt irgendwie noch andere Typen aus der DLL rumreichen. Dann kannst du wohl doch noch eine Exception benutzen.

SeppJ

Wenn du keine Exceptions nutzen kannst, dann bleiben dir ja eigentlich nur Fehlercodes. Egal ob als direkter Rückgabewert oder als globaler Indikator, diese Fehlercodes sind in irgendeiner Form Zahlencodes. Wenn die Codes nicht eindeutig sind, musst du sie eindeutig machen. Maskieren oder einen zweiten Code hinzufügen.

Biolunar

std::error_code ? Musst nur zusehen, dass du nur ein einziges std::error_category Objekt in deiner DLL hast, damit std::error_code funktioniert.

Meep Meep

ich denk ich weiß wie ich es machen werde.

ungefaehr so:

struct api_error
{
   int system_error_code;
   int internet_error_code;
   int http_error_code;
   int mysql_error_code;

   auto has_error(void) -> bool
   {
      return system_error_code | internet_error_code | http_error_code | mysql_error_code;
   }

   auto clear(void) -> void
   {
      system_error_code = 0;
      internet_error_code = 0;
      http_error_code = 0;
      mysql_error_code = 0;
   }
};

enum class api_error_mask : int
{
   none = 0,
   system = 1,
   internet = 2,
   http = 4,
   mysql = 8,
   all = system | internet | http | mysql
};

ADD_OPERATORS_TO_ENUM(api_error_mask)

class throw_on_error
{
   public:
      throw_on_error(api_error &err) noexcept : m_error(&err) 
      { 
      )

      ~throw_on_error(void) noexcept(false)
      {
         if(m_error->has_error())
         {
            if(m_mask & api_error_mask::system) throw system_error(m_error->system_error_code);
            if(m_mask & api_error_mask::internet) throw internet_error(m_error->sinternet_error_code);
            if(m_mask & api_error_mask::http) throw http_error(m_error->http_error_code);
            if(m_mask & api_error_mask::mysql) throw mysql_error(m_error->mysql_error_code);
         }
      }

   private:
      api_error *m_error;
      api_error_mask m_mask;
};

dann kann ich folgendes machen:

api_error err{api_error_mask::system & api_error_mask::internet};

try
{
   call_api_function(..., throw_on_error(err));

   if(err.mysql_error_code != 0)
   {
      ...
   }

   ...
}
catch(const system_error &e)
{
   ...
}
catch(const internet_error &e)
{
   ...
}