#include <iostream>
#include <exception>

class MyException : public std::exception
{
public:
	MyException() {};
	~MyException() throw() {};
	const char * what() { return "Test"; };
};

int main(int argc, char **argv)
{
	try
	{
		MyException exeption;
		throw exeption;
	}
	catch(std::exception &ex)
	{
		std::cout << ex.what() << std::endl;
	}
	return 0;
}

Ich dachte, dass es durch das erben von möglich sein sollte , aber als Output krieg ich "nur":

std::exception

anstatt "test".

Wo liegt da mein Denkfehler?

So sollte es gehen ^^

bb

Mit deinem Programm bekomme ich folgenden Output beim Compilieren:

../main.cpp: In constructor »MyException::MyException(const char*)«:
../main.cpp:7: Fehler: keine passende Funktion für Aufruf von »std::exception::exception(const char*&)«
/usr/include/c++/4.1.3/exception:57: Anmerkung: Kandidaten sind: std::exception::exception()
/usr/include/c++/4.1.3/exception:55: Anmerkung: std::exception::exception(const std::exception&)
../main.cpp: In function »int main(int, char**)«:
../main.cpp:14: Fehler: expected primary-expression before »;« token
Build error occurred, build is stopped
Time consumed: 784 ms.

Weil ichs gerade sehe, liegts vll am g++ 4.1.3?

Wo liegt da mein Denkfehler?

Ich glaube, die Signatur deiner what() Methode stimmt nicht, da fehlt noch ein "const throw()". Deswegen wird deine Methode nicht aufgerufen, sondern die der Basisklasse.

nicht

throw MyException;

squall23 schrieb:

Wo liegt da mein Denkfehler?

Ich glaube, die Signatur deiner what() Methode stimmt nicht, da fehlt noch ein "const throw()". Deswegen wird deine Methode nicht aufgerufen, sondern die der Basisklasse.

Du bist mein Held!

Genau das wars! Also so funktionierts:

#include <iostream>
#include <exception>

class MyException : public std::exception
{
public:
    MyException() {};
    ~MyException() throw() {};
    const char * what() const throw() { return "Test"; };
};

int main(int argc, char **argv)
{
    try
    {
        throw MyException();
    }
    catch(std::exception &ex)
    {
        std::cout << ex.what() << std::endl;
    }
    return 0;
}

Danke für die schnelle Hilfe

#include <exception>

class MyException : public std::exception
{
public:
    MyException() {};
    ~MyException() throw() {};
    const char * what() const throw() { return "Test"; };
};

das is doch doof ><

dann musste es au ne ableiten...

meine klassen sehen alle so aus... fehlte nur noch nen const vorhin. sry ^^

#include <exception> 

class MyException : public std::exception 
{ 
public: 
    MyException (const char * const string = NULL) : std::exception (string) {}; 
};

bb

meine klassen sehen alle so aus... fehlte nur noch nen const vorhin. sry ^^

#include <exception> 

class MyException : public std::exception 
{ 
public: 
    MyException (const char * const string = NULL) : std::exception (string) {}; 
};

Öhh... Seit wann hat std::exception einen Konstruktor mit char* als Parameter?

Evtl. wäre es aber nicht verkehrt, bspw. von std::runtime_error abzuleiten, statt direkt von std::exception. Dessen Konstruktor nimmt nämlich einen std::string, der dann von what() ausgegeben wird:

struct MyException : public std::runtime_error
{
    MyException(std::string const & w)
      : std::runtime_error(w) { }
};

Öhh... Seit wann hat std::exception einen Konstruktor mit char* als Parameter?

Lass mich kurz überlegen ... Schon immer? Mir wäre es neu, dass der Konstruktor keinen Parameter annimmt, sonst müssten nämlich alle meine Exceptions nicht funktionieren.

Grüssli

dooooomi schrieb:

Öhh... Seit wann hat std::exception einen Konstruktor mit char* als Parameter?

Lass mich kurz überlegen ... Schon immer? Mir wäre es neu, dass der Konstruktor keinen Parameter annimmt, sonst müssten nämlich alle meine Exceptions nicht funktionieren.

Also, zumindest beim gcc (4.1.2) gibt es den Konstruktor nicht. std::exception sieht so aus:

class exception 
{
public:
  exception() throw() { }
  virtual ~exception() throw();
  virtual const char* what() const throw();
};

Mehr ist da nicht. Das Beispiel von unskilled läßt sich dementsprechend auch nicht kompilieren.

ich weiß nicht genau, wie es im standard vorgeschrieben ist - aber ich weiß nur, dass es da auch schon vor paar jährchen gegangen ist ^^

bb

Gut, dann ist die vorgeschlagene Lösung schon richtig. Nur ist glaub ich das throw() nicht nötig anzugeben, const alleine sollte wohl reichen.

Grüssli

Aber ich fänd es wirklich ziemlich doof, wenn das nicht gänge ^^

Aber da ich eh bei VS bleib... ;oP

bb