Re: Simple question!
"Alex Blekhman" <xfkt@oohay.moc> skrev i meddelandet
news:OatG0vOpGHA.3288@TK2MSFTNGP03.phx.gbl...
"Bo Persson" <bop@gmb.dk> wrote:
I can see that many attribute some inherently evil properties to
`goto' statement. Michael K. O'Neill already posted good article
in this thread. I'd second his opinion. There is nothing wrong
with `goto' per se. All of us have seen horrible code without
single `goto'. This is not that `goto' (or any other language
construct) that makes code bad; it's quite the opposite: bad,
stupid coders produce filthy code (no matter what the language the
use for that). Any feature in a programming language is just a
tool. Use it wisely and you'll get beautiful elegant code. I just
can't get all these rumbles about `goto'.
Because it is an inherently unstructured way to get from one
arbitary point in the program to another? :-)
First, it is not so arbitrary. It must be within the same function.
And the function can be large, like a thousand lines (see below).
Second, the whole engineering thing is about tradeoffs. Sometimes
maintaining 100% pureness of whatever concept has unacceptable cost.
At that point smart thing to do is to permit reasonable tradeoff.
But sometimes you can be too smart for your own good. Using gotos is
almost always in that category.
Not so smart thing to
do is to fight reality for sake of academic "correctness". In my
experience better engineer is that one who knows where to draw the
line rather who knows a lot of techniques (though, it's also
important).
When 99.9% of the uses are bad, the general advise to students is:
"Don't use it"!
I'm not so sure about the percentage. Just grep CRT sources for
`goto'.
So I did, and now wish I hadn't. I found this 1000+ line function
containing a HUGE switch statement, sprinkled with lots of 'goto
failure' statements. In this case I definitely don't trust the authors
judgement.
Most of the other cases were of the kind:
if (some condition)
goto end;
do_someting;
if (some condition)
goto end;
do_more;
etc.
These could trivially be rewritten as:
if (!failed)
do_something;
if(!failed)
do_more;
if(!failed)
do_even_more;
etc.
and finally, when required
if(failed)
do_cleanup;
Also, I'm not comfortable with general advices to students. Too
often we can see fresh graduates with heads full of such do's and
dont's:
When you really, really know what you are doing you can sometimes
break the rules, because you have learned the very few exceptions.
When you are a fresh graduate, you just don't. There is really a lot
of good stuff to learn, and no reason to focus on these corner cases.
Instead of stuffing students' heads with its own idiosyncrasies,
academy should encourage in them inquiring spirit, readiness and
willingness to think before applying learned by heart methods.
You have to learn the rules first, before learning the exceptions.
When you are at a driving school, the instructor says "Don't drive
against a red light, ever". He doesn't say "..., except if you are
driving a fire truck with sirens and blue lights flashing". That's a
corner case!
`goto' statement is like litmus paper that instantly shows two kinds
of developers: those who immediately say "Don't!" and those who say
"Let's see what's the situation."
But you must first learn to judge "the situation". Until then, follow
the guidelines. And don't use goto.
Bo Persson