C / C++ / MFC

George_George wrote:

code like this.

George_George wrote:

what is the life cycle of the exception object which reference variable e binded to?

// global:
std::exception e;
void Test()
{
  try {
    throw std::exception();
  }
  catch(std::exception& e) {
    // Watch the address of local e reference with the debugger:
    // Compare with ::e
    __asm int 3
  }
}

Maxwell Chen wrote:

Not sure if some text is missing in your post??

George_George wrote:

I posted below in my question. Just the simple catch bracket, have found it?

George_George wrote:

What does int 3 mean?

George_George wrote:

3.

int* p = NULL;
void SetN(int& r)
{
  p = &r; // address of arg to global.
}
void Test()
{
  try {
    throw 5;
  }
  catch(int& v) {
    SetN(v);
  }
}

George_George wrote:

do you think it is still safe to refer to global variable p after function Test returns?

class MyClass
{
public:
  int a; // If comment this member out, everything is fine.
         // But if leave it here, you get a runtime error when this app launches.
  ~MyClass() {
    printf("~MyClass \n");
  }
};
MyClass* p = NULL;
void SetN(MyClass& r)
{
  p = &r;
}
void Test()
{
  try {
    MyClass m; // local obj.
    throw m; // throw local obj.
  } // dtor called once.
  catch(MyClass& v) {
    SetN(v);
  } // dtor again.
}
void main()
{  // Runtime error.
  Test(); // You won't have a chance to run this.
  (*p).a;
}

George_George wrote:

Looks like you proved that it is not safe to access the exception object outside of the catch block? Right?

void Test()
{
  try {
    MyClass* p = new MyClass(); // why declr a pointer because for observe with debugger.
    p->a = 3;
    throw *p;
  }
  catch(MyClass& v) {
    SetN(v);
  }
}
void main()
{
  Test();
  p->a; // watch. Yes you get 3.
}

George_George wrote:

1. I think you mean if the exception object is allocated on heap, it should be safe to address it later;

George_George wrote:

And if in your previous sample, it is local object, we are not safe to address it later.

class Foo {
public:
	Foo(int input)
	{
		this->a = input;
		cout << this << endl;
	}

	Foo (const Foo& input)
	{
		this->a = input.a;
		cout << this << endl;
	}
	int a;
};

void foo()
{
	try {
		Foo *f = new Foo (100);
		throw *f;
	} catch (const Foo& e)
	{
		cout << e.a << endl;
	}
}

int main()
{
	foo();
}

George_George wrote:

Looks like we only get a temporary exception object in catch block?

CString str=_T("foo");
const TCHAR * psz = str; // implicit call to CString (LPCTSTR) cast operator

CPallini wrote:

On the other hand, if you need a standard pointer, then you can't avoid using CString::GetBuffer method (and you have to be careful).

TCHAR * psz;

LPCTSTR pcsz;

MyCombo->SetCurSel(0);