This course is for experienced C programmers who want to program in C++. The examples and exercises require a basic understanding of algorithms and object-oriented software.
4.8 Exceptions
Loading...
Из курса от партнера University of California, Santa Cruz
C++ For C Programmers, Part B
83 оценки
Explore Related Videos
At Coursera, you will find the best lectures in the world. Here are some of our personalized recommendations for you
Из урока
Monte Carlo Hex Program, Further advanced C++ Topics and Patterns
This module shows how to use Monte Carlo evaluation in complex games such as Hex and Go. This had led top championship level play in both these games. The module discusses C++ assertions and exceptions for error handling and the new C++ 11 feature static asserts. Finally, the last part of the module introduces the idea of “Design Pattern”, a feature of modern OO programming.
Познакомьтесь с преподавателями
Ira PohlProfessor
Computer Science
Exceptions in general, let's take up exceptions.
We all know exceptions in the real world, I before E except the after C blah,
blah, blah.
And as somebody who was a bad speller in elementary school,
English is riddled with terrible exception rules so
it gets very very hard to, I was always sort of more of a logicians and
always expecting everything to follow very basic rules.
And then they have to always find that there were always exceptions and
failure, second grade spelling test, very embarrassing.
So exceptions occur in a world.
There's an exception, here's some, okay, wow what's a pear doing there?
It's an exception.
So that's what exceptions are about.
They're typically left in at run time to monitor resource handling.
They also here are characteristics that exceptions that are acceptable.
Again, recall the overarching philosophy is,
do not use them to have spaghetti control structure.
Use them where they really are needed.
Well one of these places are really needed is a nuclear power plant.
You can't have your computers shut down and
all of a sudden, critical things in the power plant get turned off.
You have a radioactive accident.
You can't have on a space mission, your machine shut down.
All of the sudden you lose some enormously expensive piece of equipment.
So in those instances you have to have the ability to make sure that
your computation recovers from an error even an unanticipated error.
And if you think about the space program.
A lot of the space program stuff like Apollo mission,
some of their stuff was built with triplicate hardware and voting hardware.
So the mission would run three programs and at least two of the programs will
have to agree and that meant that there was a fair degree of redundancy.
And even if one of the machines fail, either through a hardware error or
a software error, the other two have the ability to keep the mission on track.
So exceptions are a mechanism to keep the algorithm on track regardless.
And then there is this question of repeating a request,
where there's a user input error, we all know users chronically make input errors
and you can use an exception mechanism.
Now of course you could have your own parsing routine and
you could have, the exceptions aren't absolutely required for this.
So, this isn't a complete argument for using exceptions.
But there, it's enough of an idiom that you might as well use exceptions.
Let's see some basic exception code.
And for those of you who come from other programming languages.
More advanced than C.
So the background was C, but
I know a lot of you there have things like Python and Java in your background,
and in some of those other languages they have an exception handling mechanism
that's quite similar, but you have to know where there's slight differences.
So the basic exception is shown here in this little program, and
this says throw "This will Abort";.
So we're going to have a simple printout, and
then this is going to end the computation.
Obviously pretty damn slowly, computation would otherwise end, but
this is a way to make sure you know that exception mechanism is working.
There are ways in some compilers and
systems to even turn off exceptions and not allow them.
So throw is the way to get an exception, throw you have a throw statement and
you throw an arbitrary value And that can be different.
Some languages don't allow an arbitrary value.
They only allow something that has as its class basis, an exception.
That's probably a good rule but C++ goes back to its roots It's roots are C.
It wants to be able to use anything so throw is just throw some value.
Here shows the full mechanism of the exception handling.
And we have in that mechanism what we call a try block.
The area monitored by the try block is the area monitored.
The exception being thrown.
And the exception being caught.
Think of baseball.
This is a pitcher, this is a catcher.
And this is the mound.
This is the region in which the exception is occurring.
So try open brace, close brace any time you put the keyword try.
That's the area under surveillance.
And then there is some series of catches
that will allow you to handle the exception.
Here's a very simple one, it's again an exception test.
This exception is throwing some string.
It's throwing this string This will Abort.
Catch, this is the ellipses signature.
So anything will be caught by it, anything so
this is the universal signature and this says don't abort.
So an exception was caught and rather than terminating the program,
it says I'm catching that exception and not allowing it to abort and
then of course it would abort anyway because it's the end of the program.
So this is just really to show you all the elements of the program.
It's not what you would call a real example.
Okay so the catch is somewhat special.
In the catch, a catch looks like a function but it's not a function.
First off, it can only have must have, One argument.
Though that argument could be universal.
And catch doesn't have any return time so
there's no return of an expression from catch in an ordinary sense.
The catch is just some code, it could be an arbitrarily large block of code.
In can be something that's in an alternate computation to the existing.
You can catch an exception, say method one didn't work.
Let me go and execute method two, and let me put method two in this catch.
So whatever you want can sit in the catch, but
in itself will not have a return in the expression.
And the throw will raise an exception with a particular value, so
the throw has a particular value.
That value has a type.
That type will match what might be this signature, it will be a match.
The match is the most precise, so
you will have a series of possible things to catch.
You will catch
an nth if there was an nth type before you would use the universal type.
So you'll see some sequence of catches.
And there maybe a sequence of catches because you may have
more than one throw in that body of code.
So more than one throw, there might be different types being thrown.
And also, you may want to do different things.
If you throw something, and then you may want to have a default,
like an ellipsis default universal catch.
And when you do this catch,
much like other kinds of signature matching, you want an exact match.
You want to derived type of a public base class, again we have these, all these
categories of automatic promotions available.
And you can also have convertibility to a pointer type that's in a catch argument.
So, those are all parts of how that
exception gets caught and what order it gets caught.
Which handler, which handler gets used,
you have to get comfortable with which handler gets used.
The other thing I want you to get comfortable with
is the fact that you already have a pre-existing set of exceptions.
And that pre-existing set of exceptions exists in the C++ Standards library.
It's been around for quite awhile, but there are some new types
that are available under C++ 11, so you should go and read up on that.
And there are run type exceptions, different kinds of run type errors,
different types of errors like memory errors and IO errors and
they're all built into a hierarchy that starts with a base
type that itself is sort of your vanilla exception type
And if you want to for your own class develop specialized
exceptions that get built into your own class so
your own class can have resource testing.
Then the kind of code you want to write is based on inheritance.
And so you want to get used to, okay,
I have my exception which I probably want to use for
some reason, possibly connected to my class.
So I might have mytype, and then build an exception related to it.
And I will build that on top of the already pre-existing class,
the exception class.
And for example in the exception class, there is a special
function which can be overloaded called the what function, and the what function
frequently can return a message.
So you can examine if you want.
Based on the exceptions from a message related to that exception being thrown.
And you can package it and build it up yourself using this kind of coding style.
So that's recommended inside the C++ command.
And here is how it might be thrown.
And here is how it might be caught.
So, you would get behavior here, wait a minute, I raise the exception.
This is its catcher.
Why? Because here's its type.
And it's derived, so it could be as well.
We could have added a more specialized type here.
We could have had the type myexception.
But because of the conversion opportunities,
we can catch it using a generalized exception catcher.
And as part of it we want to read out our message.
Maybe that's all we want to do.
We want a message rather.
Ознакомьтесь с нашим каталогом
Присоединяйтесь бесплатно и получайте персонализированные рекомендации, обновления и предложения.
Coursera делает лучшее в мире образование доступным каждому, предлагая онлайн-курсы от ведущих университетов и организаций.
© Coursera Inc., 2019 Все права защищены.
