15

For the following program:

int DivZero(int, int, int); int main() { try { cout << DivZero(1,0,2) << endl; } catch(char* e) { cout << "Exception is thrown!" << endl; cout << e << endl; return 1; } return 0; } int DivZero(int a, int b, int c) { if( a <= 0 || b <= 0 || c <= 0) throw "All parameters must be greater than 0."; return b/c + a; }

Using char* e will give

terminate called after throwing an instance of 'char const*'

According to C++ Exception Handling , the solution is to use const char* instead.

Further reading from function (const char *) vs. function (char *) said that

The type of "String" is char*', not const char*'

(this is a C discussion I think...)

Additional reading on Stack Overflow char* vs const char* as a parameter tells me the difference. But none of them address my questions:

  1. It seems like both char* and string* have limit on the numbers of characters. Am I correct?
  2. How does adding the keyword const to char* eliminates that limit? I thought the only purpose of const is to set a flag that said "unmodifiable". I understand that const char* e means " the pointer which points to unmodifiable char type".

The solution to that error is to use const char* e.

Even const string* e doesn't work. (just for the sake of testing...)

Can anyone explain, please? Thank you!

By the way, I am on Ubuntu, compiled by GCC, on Eclipse.

Improve this question

2 Answers 2

Reset to default
23

The email you linked to about "String" is wrong (and confusing).

Basically:

char* is a pointer to an unbounded array of characters. Traditionally we consider such an array to be a C-string if it contains a set of valid characters followed by a \0. There's no limit to the size of the array.

const char* is a pointer to an unbounded array of immutable characters.

string* is a pointer to a std::string object, and is entirely different. This is a smart object that encapsulates a string. Using std::string instead of C-strings can make your life loads easier, even though they've got some rough edges and a lot of nasty gotchas; they're well worth looking into, but they're not relevant to the question.

"String" is a special expression that returns a const char* pointing at the specific C-string (note: this is not actually true, but it's a simplification that lets me answer the question concisely).

A char* can be automatically cast to a const char*, but not vice versa. Note that old C++ compilers had a special exception to the type rules to let you do this:

char* s = "String";

...without producing a type error; this was for C compatibility. Modern C++ compilers won't let you do it (such as recent gccs). They require this:

const char* s = "String";

So. The problem here is that you've got:

throw "All parameters must be greater than 0.";

...but then you're trying to catch it with:

catch(char* e)

This doesn't work, because the throw is throwing a const char*, which can't be cast to the type specified in the catch, so it isn't getting caught.

This is why changing the catch to:

catch (const char* e)

...makes it work.

Improve this answer
Sign up to request clarification or add additional context in comments.

4 Comments

+1, but every compiler I know of (including recent GCCs) lets you do char* s = "String"; without error. Some may give a warning, on the other hand... (Demo)
Well explained. I wish I can mark everyone, but I can't. He answered before you did. That's okay I guess. Your explanation was very helpful. I really like it. Thanks, David. I actually have found more on const.... wiki article called "const-correctness". :]
@ildjarn +1 for your great comment and demo. :]
@JohnWong Glad to be of help (the sweet, sweet reputation points are nice too, muhahaha). Const correctness is well worth learning about; C++ is a very picky and extremely subtle language, and getting const correctness right may be a pain in the arse at times but will be hugely helpful when saving you from shooting your foot off later. C++ is not my favourite language...
18

Why are you throwing and catching strings anyway?

You should throw and catch exceptions, e.g. std::runtime_error

The answer to your question is that whenever you insert a string in quotes in the code it returns a null terminated const char*

The reason your code doesn't work as above is because it's the wrong type, so that catch, isn't catching what you're throwing. You're throwing a const char*.

There is no limit to the number of characters in a char array beyond the size of your stack/heap. If you're referring to the example you posted, that person had created a fixed size array, so they were limited.

Improve this answer

5 Comments

@Salgar This is a sample code from the book Fundamental of Data Structure (2ed). So if I insert int [] it will return as const int* ???? (with the const keyword)?
Agreed, derive all exceptions from std::exception. throwing basic types leads to trouble. ensuring that everything derives from std::exception lets you be sure that catch(std::exception e) will catch everything. You want to reserve catch(...) for the most extreme cases, such as DLL boundaries. Throwing basic types often will lead to the need to catch(...) often. use throw std::runtime_error("All parameters must be greater than 0.");
yes, lets you be sure that a catch(const std::exception& e) will catch everything.
@JongWong no, the type of the code "foo" is a const char*, the type of int[] is int[] and the type of int* is int*
I'm pretty sure a string literal has type const char[N], with N being the string length+` (for the '\0'), not const char*, it just decays to that.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.