Thread: exception try, catch

Code:

#include <stdexcept>

try
{
  throw std::runtime_error("Help, it won't work!");
}
catch(std::exception& Exception)
{
  std::cout << Exception.what();
}

If you really want to use char*'s perhaps two cathes after each other, one char* the other const char*?

A function with a const char * argument can handle char * as well. A char * argument means that the function may attempt to change the string while a const char * means it will not. Functions with a char * argument shouldn't accept a const char * pointer because attempting to alter a constant will result in a segmentation fault.

And the same goes for catch-blocks. A catch block:

Code:

try { ... } catch(sometype e) {}

Catches any exception of a type that is convertible to sometype.
When you throw a string literal, the thrown type is const char*, which is not convertible to char*; thus, the catch won't catch it.

That said, you shouldn't throw string literals anyway. Best practice is to always throw a class that somehow derives from std::exception.

Just to add to what was said: when the compiler sees any string literal(which is something between double quotes like "Array Index Out Of Bounds"), the compiler slaps a '\0' onto the end of it and stores it in memory, and then returns it's address. So, you are throwing the address in memory of that string literal. Additionally, the string literal stored in memory is const(that's just the way it is), so you cannot change it. For instance you can't do this:

Code:

char* str = "Hello World.";
str[0] = 'a';

It will compile, but it will crash.

So, you are throwing a pointer to a const char array. That means if you list the parameter of your catch statement as a char*, it cannot catch a const char*. A function or catch statement can modify the value that is being pointed to if it is stored in a char* parameter variable. However, an argument that is of type const char* says that the value pointed to shall not be changed under any circumstances. So, the argument will hurry by your catch statement in fear--lest it gets changed by just looking in the catch statement's general direction.

As was pointed out above, a parameter variable that is declared as a const char* can catch a char* as well. If the argument is pointing to a non-const char, the argument doesn't care whether its modified: change it, don't change it, it's all good. So if a function says it will not modify the value by declaring the function parameter const, the non-const argument could care less, and it will gladly stop and visit that waypoint along its journey.