[SOLVED] C++ exception - what is wrong?

The e.what() prints rubbish. Why is that?

#include <iostream>
#include <sstream>
#include <exception>

class myexception : public std::exception
{
public:
    virtual const char* what() const throw()
    {
        return sstr.str().c_str();
    }
    std::ostringstream sstr;
};

int main() {
    try
    {
        myexception ex;
        ex.sstr << "very good";
        throw ex;
    }
    catch (std::exception& e)
    {
        std::cout << e.what() << '\n';  // <-breakpoint
    }
    return 0;
}

I can still see "very good" at the breakpoint, but the output is just rubbish. Why is that?

Another question is, when is ex destroyed? Does it make sense to catch a reference rather than a copy?

ex is only defined in the try block. Declare it at before that at the beginning of main

You have a dangling pointer. c_str is returning a pointer to the buffer in a temporary object - the return value of str().

If you changed ostringstream to a std::string and assigned to it you'd find the c_str() points to valid memory.

Originally Posted by smallpond ex is only defined in the try block. Declare it at before that at the beginning of main

Cannot. 'Attempting to reference a deleted function' at throw.

What is the right way of doing it?

this might help

class myexception : public std::exception
{
public:
    virtual const char* what() const throw()
    {
        return sstr.str().c_str();
    }
    std::ostringstream sstr;
}ex; <---- declare here.

per http://www.cplusplus.com/doc/tutorial/exceptions/

class myexception: public exception
{
  virtual const char* what() const throw()
  {
    return "My exception happened";
  }
} myex;

Originally Posted by SoftSprocket You have a dangling pointer. c_str is returning a pointer to the buffer in a temporary object - the return value of str(). If you changed ostringstream to a std::string and assigned to it you'd find the c_str() points to valid memory.

I cannot understand the rationale behind combining the answer of both of you.
ex is declared only inside the try-block, then the content is destroy after reaching the catch-block. In that case neither ostringstream nor string is valid.

I have also tried catch(std::exception e) but it's not helping. ex is not copied to e.

Originally Posted by BW-userx this might help class myexception : public std::exception { public: virtual const char* what() const throw() { return sstr.str().c_str(); } std::ostringstream sstr; }ex; <---- declare here. per http://www.cplusplus.com/doc/tutorial/exceptions/ class myexception: public exception { virtual const char* what() const throw() { return "My exception happened"; } } myex;

Same. 'Attempt to reference a deleted function'. And it doesn't make sense to declare a global variable.

I cannot find any satisfactory example of throwing an object derived from std::exception on the Internet.
Anyone knows the right way of doing it? and perhaps explain why std::string works but std:stringstream won't.

Originally Posted by Jerry Mcguire I cannot understand the rationale behind combining the answer of both of you. ex is declared only inside the try-block, then the content is destroy after reaching the catch-block. In that case neither ostringstream nor string is valid. I have also tried catch(std::exception e) but it's not helping. ex is not copied to e.

The exception is copied to the catch clause. Try it and see:

#include <exception>
#include <string>
#include <iostream>
                                                                                                                        
class myexception : public std::exception
{
public:
    virtual const char* what() const throw()
    {
        return str.c_str();
    }
    std::string str;
};

int main() {
    try
    {
        myexception ex;
        ex.str = "very good";
        throw ex;
    }
    catch (std::exception& e)
    {
        std::cout << e.what() << '\n';                                                                                      
    }
    return 0;
}

This demonstrates the dangle :

#include <sstream>
#include <iostream>

class Dangle {
        std::ostringstream ss;
public:
    Dangle (const char* s) {
        ss << s;
        std::cout << ss.str().c_str() << "\n";
    }

    const char* str() {
        return ss.str().c_str();
    }
};

int main () {
    Dangle d("Hello, world");
    std::cout << d.str() << "\n";

    return 0;
}
                                                                                                             ~

Originally Posted by Jerry Mcguire Same. 'Attempt to reference a deleted function'. And it doesn't make sense to declare a global variable.

I have not delt with exceptions other than the default catching them.

Yet, having been investigating this issue I do not think OP is being written properly at all. trying to pass in a string into the exception via a data type declared within the class, then return it in that function that takes in no pharms even though it has a declared data type but no real means to return that in the function itself.

that example itself I posted in that link it does not do this, try to take an assignment then return it.

Where that exception return value within the exception function is suppose to be the error itself as defined by the programmer, to be return in that exception class function itself and not taking in from elsewhere so that it maybe over written by another means.

that sounds logical to me .

that is not to say one cannot over ride another exception catch to return the programmers error message rather then the "build in" one for an external means.

The answer to what is wrong is in my earlier post - a dangling pointer.

A, perhaps canonical, example for extending exception:

#include <iostream>
#include <exception>

class TestException : public std::exception {
	std::string m_msg;
public:
	explicit TestException (std::string msg) : m_msg(msg) {}
	virtual ~TestException () throw () {}

	virtual const char* what () const throw () { return m_msg.c_str(); } 
};

int main () {
	try {
		throw TestException ("Hello, World");
	}
	catch (TestException& e) {
		std::cout << e.what() << "\n";
	}

	return 0;
}

The dynamic content I try passing from the try-block to the catch-block is perhaps another info from an given API, or __FILE__,__LINE__ values. It could take several forms depending on the situations. That's why I try to format the what() content using the ostringstream. It should be a legitimate reason.

In the Dangle class example, I will interpret the problem as: the ss.str().c_str() returns a pointer pointing to the ss.str() instance, but which is destroyed after const char* str() {} exits.

    Dangle(const char* s) {
        ss << s;
        std::cout << ss.str().c_str() << "\n";
        std::cout << str() << "\n"; // <- This is what is wrong.
    }

The OP is modified to this to work:

#include <iostream>
#include <sstream>
#include <exception>

class myexception : public std::exception
{
public:
    virtual const char* what() const throw()
    {
        s = std::move(sstr.str());
        return s.c_str();
    }
    std::ostringstream sstr;
    mutable std::string s; // <-
};

int main() {

    try
    {
        myexception ex;
        ex.sstr << "very good";
        throw ex;
    }
    catch (std::exception& e)
    {
        std::cout << e.what() << '\n';
    }
    return 0;
}

Thanks all.

Off: I don't know about C++ or exceptions, but I would start learning here: https://yosefk.com/c++fqa/exceptions.html

My apologies for misleading you. The original program was correct that the exception was still valid in the catch block and that e was a proper reference to it. I learned today that the str() returned from ostringstream is a temporary std::string.