exception and global variable

Hello everyone,


Bjarne mentioned in his book, that there is no way to catch exceptions from the initialization of global variables (section 14.7). But I do not think it is true, because we can add function try block to its constructor, and catch appropriate types of exceptions or using catch(...) to catch all exceptions.

Am I correct? Any comments?


thanks in advance,
George

Yes, but it's not guaranteed, as it only works if:
1. You are providing the constructor (and write appropriate code).
2. The throw happens inside something called by the constructor, and not as part of the runtime initialization "before main" itself.

--
Mats

Thanks Mats,


I agree with (2). What do you mean (1) -- "are providing the constructor"? Means I owns the code (can access and modify) of constructor?

Quote:

---

Originally Posted by matsp

Yes, but it's not guaranteed, as it only works if:
1. You are providing the constructor (and write appropriate code).
2. The throw happens inside something called by the constructor, and not as part of the runtime initialization "before main" itself.

--
Mats

---

regards,
George

Yes, you need to own (and be able to arbitrarily modify) the source of the constructor.

The next question is of course what you actually DO if you catch an exception during construction of a global object... Not an entirely easy one to solve, unless you just "log it and exit".

--
Mats

Besides, a constructor function try block cannot swallow exceptions.

You mean that a constructor is not allowed to accept a thrown exception without also forwarding it to the next level down the call-stack?

--
Mats

Correct.

Code:

---

void throws() { throw 0; }

struct foo
{
  foo() try { throws(); } catch(int) {}
};

int main()
{
  try {
    foo f;
  } catch(int) {
    std::cout << "Still caught.\n";
  }
}

---

So the solution to the "can't use exceptions in global construction" is to use a (global) pointer that is initialized in main or some such.

--
Mats

Quote:

---

Originally Posted by CornedBee

Correct.

Code:

---

void throws() { throw 0; }

struct foo
{
  foo() try { throws(); } catch(int) {}
};

int main()
{
  try {
    foo f;
  } catch(int) {
    std::cout << "Still caught.\n";
  }
}

---

---

mmm, that is strange syntax never seen a constructor, or any other function, like that.
first I thought you mistyped but when I compiled it, it worked!
so why when I write the constructor like below the exception is not caught?

Code:

---

void throws() { throw 0; }

struct foo
{
  foo() { try { throws(); } catch(int) {} }
};

int main()
{
  try {
    foo f;
  } catch(int) {
    std::cout << "Still caught.\n";
  }
}

---

Because a normal try block inside a constructor is allowed to swallow exceptions. Only a function try block is not. The reason is that a function try block catches exceptions from embedded sub-object constructors, and if they threw, the object cannot be fully constructed; thus its constructor cannot be allowed to finish normally.
If there is a try block inside the constructor body, though, all sub-objects have been constructed when it is entered, so it would be permissible to catch exceptions occuring in the try block and doing something different in the catch block, as long as the resulting object is still valid.

Thanks CornedBee, I understand. Good to know.

So great analysis, CornedBee!

Quote:

---

Originally Posted by CornedBee

Because a normal try block inside a constructor is allowed to swallow exceptions. Only a function try block is not. The reason is that a function try block catches exceptions from embedded sub-object constructors, and if they threw, the object cannot be fully constructed; thus its constructor cannot be allowed to finish normally.
If there is a try block inside the constructor body, though, all sub-objects have been constructed when it is entered, so it would be permissible to catch exceptions occuring in the try block and doing something different in the catch block, as long as the resulting object is still valid.

---

regards,
George

Thanks Mats,


My question is ansered.

Quote:

---

Originally Posted by matsp

Yes, you need to own (and be able to arbitrarily modify) the source of the constructor.

The next question is of course what you actually DO if you catch an exception during construction of a global object... Not an entirely easy one to solve, unless you just "log it and exit".

--
Mats

---

regards,
George