ich steht gerade echt auf dem Schlauch: Eine Funktion zum lesen einer Datei wirft einen std::runtime_error, wenn die Datei nicht vorhanden ist. Das Problem ist, obwohl ich der Meinung bin, diesen zu fangen, aborted mein Programm mit der Meldung "terminate called after throwing an instance of 'std::runtime_error'"

Was mach ich hier falsch:

std::string loadFile(const std::string& file_name) throw (std::runtime_error)
{
    if(datei existiert nicht)
    {
        throw std::runtime_error(file_name);
    }
    lese_den_kram_ein();
}

...
Foo::Foo()
{
    std::string config;
    try {
        config = loadFile("pfad/zu/nichtexistenter.datei");
    } catch (std::runtime_error& ex) {
        Log << ex.what() << " wurde nicht gefunden";
        lade_eine_default_config();
        return;
    }
    lade_die_richtig_config(config);
}

Wie gesagt, wenn der runtime_error fliegt, wird er nicht gefangen? Wieso? Hat das was damit zu tun, dass der Error im Konstruktor fliegt und gefangen wird (werden sollte)? Aber es ist ja der Konstruktorbody, keine Elementinitialisierung, also sollte das ja ganz normal funktionieren.

Philipp

#include <stdexcept>
#include <iostream>

class Foo
{
  public:
  Foo();

  private:
  int i;
};

void WerfeException() throw (std::runtime_error)
{
  throw std::runtime_error("abc");
}

Foo::Foo() : i(4)
{
  try
  {
    WerfeException();
  }
  catch (std::runtime_error& e)
  {
    std::cout << "Exception gefangen " << e.what() << std::endl;
  }
}

int main()
{
  Foo f;
}

Der Fehler scheint also woanders zu liegen.

Zwei exceptions zur gleichen Zeit aktiv? Destruktor von std::string ?

Kann es sein das std::ifstream::is_open() selbst eine Exception wirft?

Laut Referenz nicht. Ich hab aber eben auch mal dein Beispiel getestet und das funktioniert wie von dir erwartet.

http://www.cplusplus.com/reference/iostream/ifstream/is_open/

#include <fstream>
#include <string>
#include <stdexcept>
#include <iostream>

std::string loadFile(const std::string& file_name) throw(std::runtime_error)
{
    std::string buf, line;
    std::ifstream in(file_name.c_str(), std::ios_base::in);
    if(!in.is_open())
    {
        throw std::runtime_error(file_name);
    }
    while(std::getline(in,line))
        buf += line;
    return buf;
}

class Foo {
public:
    Foo(const std::string& filename)
    {
        std::string bar;
        try {
            bar = loadFile(filename);
        } catch(std::runtime_error& ex) {
            std::cerr << ex.what() << " konnte nicht geöffnet werden";
            mem = 0;
            return;
        }
        mem = 1;
    }
private:
    int mem;
};

class Other {
public:
    Other():member("blub"){}
private:
    Foo member;
};

int main(int argc, char *argv[])
{
    Other o;
    0;
}

Problem ist, wenn ich genau diesen Code

try {
            bar = loadFile(filename);
        } catch(std::runtime_error& ex) {
            std::cerr << ex.what() << " konnte nicht geöffnet werden";
            mem = 0;
            return;
        }

in meine Software paste, kommts zum abort().

Das kann ja eigentlich nur heißen, das zwei Excpetions fliegen, von denen ich nur eine gefangen kriege. Wenn ich catch(...) mache, ist das Ergebnis aber das gleiche.

Irgendwie steh ich gerade voll auf dem Schlauch.

Philipp

http://www.cplusplus.com/reference/iostream/ifstream/ifstream/
Dritter Absatz der Beschreibung.

std::string loadFile(const std::string& file_name) throw(std::runtime_error)
{
    std::string buf;
    std::string line;
    std::ifstream in(file_name.c_str(), std::ios_base::in);
    if(!in.is_open())
    {
        throw std::runtime_error(file_name);
    }
    while(std::getline(in,line))
        buf += line;
    return buf;
}

void foo() throw (std::runtime_error)
{
    throw std::runtime_error("foo");
}

Folgendes passiert:

try {
        //config = loadFile(config_file_name);  // abort -> in der abort-Meldung steht der korrekte File-name
        foo();  // Exception wird korrekt gefangen
    } catch (std::runtime_error& ex){
        Log() << Log::Fail << "Could not open " << ex.what() << ". SCS does not work without this file." << Log::endl;
        return;
    }

Das heißt, aus loadFile() muss mehr als eine Exception kommen.

Ich vermute mal, dass deine Exception gefangen wird, aber der
Stream nicht geflusht wird.

std::cerr << ex.what() << " konnte nicht geöffnet werden" << std::endl;

} catch(...){

}

danach würde ich dann const std::exception& versuchen zu fangen

In der main hast du kein return drin

Stimmt. Da funktioniert aber auch alles

Ich vermute mal, dass deine Exception gefangen wird, aber der
Stream nicht geflusht wird.

Das logfile wird aber geflusht.
Außerdem, selbst wenn der stream nicht geflusht würde, dürfte ja kein abort() kommen.

kuck mal, ob 'irgendetwas' gefangen wird...

} catch(...){

}

danach würde ich dann const std::exception& versuchen zu fangen

Habe ich gerade probiert. auch die ellipse catcht nix.

Ich vermute mal, dass deine Exception gefangen wird, aber der
Stream nicht geflusht wird.

std::cerr << ex.what() << " konnte nicht geöffnet werden" << std::endl;

Ein std::endl bewirkt ein std::flush und ein '\n'.

XSpille schrieb:

Ich vermute mal, dass deine Exception gefangen wird, aber der
Stream nicht geflusht wird.

std::cerr << ex.what() << " konnte nicht geöffnet werden" << std::endl;

Ein std::endl bewirkt ein std::flush und ein '\n'.

Danke für die Info, allerdings ist mir das klar...
Ein Zeilenumbruch nach einer Meldung kann auch nichts schaden

if (in.fail() || !in.is_open())
    throw bla;

std::string loadFile(const std::string& file_name) throw(std::runtime_error)
{
    std::string buf, line;
    std::ifstream in(file_name.c_str(), std::ios_base::in);
    if(!in)
    {
        throw std::runtime_error(file_name);
    }
    return "";   // das funktioniert

    while(std::getline(in,line))
        buf += line;
    return buf;
}

Man beachte, das die Funktion in jedem Fall einen leeren String zurückgibt.

Das Verhalten ist das erwartete: Für eine existente Datei gibt sie einen leeren String zurück, für eine nicht existente Datei kommt eine Exception, die auch gefangen wird.

Entferne ich das

return "";

wird abort() aufgerufen im Falle einer nicht existenten Datei.

std::string loadFile(const std::string& file_name) throw(std::runtime_error)
{
    std::string buf, line;
    std::ifstream in(file_name.c_str(), std::ios_base::in);
    if(in.fail() || !in)
    {
        throw std::runtime_error(file_name);
        return "";
    } else {
        while(std::getline(in,line))
            buf += line;
        return buf;
    }
}

Kann mir vielleicht einer erklären, wo hier das Problem war?
Ich hab nämlich keinen Schimmer, warum es jetzt geht.

Philipp

std::string loadFile(const std::string& file_name) throw(std::runtime_error)

Da spezifizierst du, dass du nur runtime_error werfen darfst. Wenn eine andere Exception kommt, wird terminiert. Da bringt dir dein catch(...) auch nix mehr. Mach das mal weg und guck DANN mit catch(...) was eigentlich geworfen wird.

Was ist denn mit dem Forum los? Jeder schreibt hier "mach mal catch(...)" aber das kann doch nicht funktionieren wenn die Funktion spezifiziert hat, was sie werfen darf..

std::string loadFile(const std::string& file_name) throw(std::runtime_error)

Da spezifizierst du, dass du nur runtime_error werfen darfst. Wenn eine andere Exception kommt, wird terminiert. Da bringt dir dein catch(...) auch nix mehr. Mach das mal weg und guck DANN mit catch(...) was eigentlich geworfen wird.

Bekenne mich schuldig.
Ich verwende nie throw und war der Meinung, dass sonst eine std::bad_exception
zurückkommt. Die ist allerdings (scheinbar) nur der Fall, wenn throw diese
auch enthält.

Exception-Spezifikationen sind deprecated, weg damit!

Der Beitrag ging verloren.

Exception-Spezifikationen sind deprecated, weg damit!

Stimmt, er hat im Prinzip das gleiche gesagt wie ich. Aber wenn man wie ein Troll schreibt wird man halt nicht ernst genommen

mfg, René~

tja schrieb:

Exception-Spezifikationen sind deprecated, weg damit!

Stimmt, er hat im Prinzip das gleiche gesagt wie ich. Aber wenn man wie ein Troll schreibt wird man halt nicht ernst genommen

mfg, René~

Du meinst also, wenn man ein Clown-Smiley benutzt, dass man damit kennzeichnet ein Troll zu sein?
Dann sollte Marcus++ das Smiley löschen!

XSpille schrieb:

Danke für die Info, allerdings ist mir das klar...

Ist klar...