goto statement

[Pablo Aliskevicius]

If you don't think that GOTO is an interesting topic of conversation, try the Duff device. http://www.lysator.liu.se/c/duffs-device.html[^]

Pablo. "Accident: An inevitable occurrence due to the action of immutable natural laws." (Ambrose Bierce, circa 1899). "You are to act in the light of experience as guided by intelligence" (Rex Stout, "In the Best Families", 1950).

[PIEBALDconsult]

:thumbsup: I'd never seen that before. Awesome.

[PIEBALDconsult]

altomaltes wrote:

your exit from work will be no too structured

That's an interrupt.

[PIEBALDconsult]

It's fine when it's the only tool in the box (very old BASIC, DCL, DOS batch files, etc.), but I've never needed it in languages that support structured programming.

[Tarek Elqusi]

Could this be written by C# ?

[Forogar]

After using FORTRAN for far too long (up to Fortran-77) with it's use of GOTO and, even more obfuscating, computed gotos, I started using C. However, I was self-taught and was therefore never was taught by anybody that there was a GOTO in the language! I used C for several years, then C++ and now I am firmly in the C# camp. I personally have never used GOTO in any of that code and was shocked one day to find a GOTO residing in someone else's code I had to fix. It was a revelation as big as finding out that one is allowed to use guns during a penalty kick-off. I didn't even know the syntax existed! The whole point of my argument is that I never felt the need for a GOTO at any time, ever - so I didn't miss it. I didn't make artificial constructs to get around using GOTO; I didn't deliberately re-write my code to avoid using one; it just came about naturally that I didn't ever need one. Having said that, I am sure that GOTO may be useful in some real-time code somewhere for performance reasons. My real bug-bear is with multiple RETURNs. I do actually go out of my way to avoid them and re-write them out of existence wherever I find them. I have not yet found any instance where multiple RETURNs from a method has been necessary. I miss allowing the drop through of CASE statements in a switch that has been removed in C#, forcing me to put BREAK at the end of each part and leading me to repeat code unnecessarily now and then so I am not always in favour of compiler/syntax restrictions in a language but I wish multiple RETURNs had been proscribed in the same way.

- I would love to change the world, but they won’t give me the source code.

[OriginalGriff]

I disagree to an extent with you about multiple returns: I'd rather see a method with validations at the top, each with it's own error report and a return than some "faffing about" code to avoid it. I just think it makes the code look cleaner.

The only instant messaging I do involves my middle finger. English doesn't borrow from other languages. English follows other languages down dark alleys, knocks them over and goes through their pockets for loose grammar.

[Forogar]

I always structure things to do validation at the top a bit like:

private bool SomeMethod(string someStingArg, int anIntArg)
{
bool workedOK = false;
if (IsValidForThisFunction(somString) && IsAlsoValid(anIntArg))
{
// Do stuff here...
workedOK = true;
}
return workedOK;
}

...or, if individual validations are necessary...

private bool SomeMethod(string someStingArg, int anIntArg)
{
bool workedOK = false;
if (IsValidForThisFunction(somString))
{
if (IsAlsoValid(anIntArg))
{
// Do stuff here...
workedOK = true;
}
}
return workedOK;
}

That way I still have only one exit - and I have all the validations at the top. Obviously there are try...catch blocks involved but I wanted to put a simple layout.

- I would love to change the world, but they won’t give me the source code.

[CPallini]

There is few number of bad developers, like me, thinking the goto is not evil. :)

Veni, vidi, vici.

[Forogar]

Getting past the denial stage is the first step towards a cure. :laugh:

- I would love to change the world, but they won’t give me the source code.

[CPallini]

You know, now I have to use the goto on you... ;P

Veni, vidi, vici.

[Bill_Hallahan]

The book, "Classics In Software Engineering" has Dijkstra's excellent paper, "The Case Against The Goto". There was also another paper by another author in that book stating situations where the goto is useful. A goto is worthwhile in some very limited contexts. I found a related very short paper by Dijkstra online that is titled, "A Card Against The Goto" at http://www.cs.utexas.edu/users/EWD/transcriptions/EWD02xx/EWD215.html[^]. It is more of a philosophical outlook about the issue and doesn't go into the depth of the article in the book. It's also worthwhile reading the paragraphs under "Considered Harmful" at http://blogs.perl.org/users/erez_schatz/2011/07/rewriting-the-language.html[^]. That section tells about how when Dijkstra's article, "The Case Against The Goto" was submitted to the ACM magazine, the editor changed the title [to "Gotos Considered Harmful"] and created a furor! Two key sentences at the link above are: "It should cease to exist. Nothing in programming is definite. There is no single element that is either a silver bullet or the Antichrist." However, it is true that, in the vast majority of cases, using a goto can and should be avoided. But it's also a mistake to revile any code that contains a goto merely because the code contains one. By the way, I also agree with another poster that multiple returns in a function are undesirable, although I can see exceptions for this too. A single return in a function makes debugging so much easier. I make a serious effort to have only a single return, however, I have broken this guideline at times, particularly when working on critical legacy code where I wanted to minimize changes to the code. Here's a construct in pseudo-code that I've used in both C and C++ programs to avoid the need for gotos for multiple error cases. (By the way, I also always put the parenthesis in a statement, even for only one-line statements, because it makes the code easier to maintain. Typically, 85% of the cost, or time, spent on code is maintenance, so typically, code should be written to make it easy to maintain, as opposed to making

[Forogar]

I prefer:

// Some code here. Entering a section with lots of error checking.
// Some code goes here that sets an error condition.
if (!error)
{
// Some more code that sets an error condition.
if (!error)
{
// Even more code that sets an error condition.
if (!error)
{
// etc.
}
}
}
// The code continues here.

No "do...while" required. This also has the advantage that excessive indenting reminds the programmer that they need to break the code out into method calls to simplify the layout. Once it gets past four or five indents this becomes obvious. Better would be:

// Some code here. Entering a section with lots of error checking.
// Some code goes here that sets an error condition.
if (error)
{
// Report error details here.
}
else
{
// Some more code that sets an error condition.
if (error)
{
// Report error details here.
}
else
{
// Even more code that sets an error condition.
if (error)
{
// Report error details here.
}
else
{
// etc.
}
}
}
// The code continues here.

This way each error can be reported as necessary, perhaps with some cleanup or roll-back code.

- I would love to change the world, but they won’t give me the source code.

[Tarek Elqusi]

I remember that when I started learning programming in 1985 or before that the version of the language I started with was build with no loop statements, except the FOR loop. This made it relied heavily on GOTO statement in the case of conditional loops. I think for languages,if any, with such structure one HAVE to use it, with care.

[Bill_Hallahan]

That code is you showed is fine, and I also prefer the the nested form of error checking when it is manageable. That isn't always the case. (Note the comment in my last message, there is no "silver bullet!") As I wrote in my code example, "That construct avoids the extreme indenting that can occur with a lot of nested error checks." The key words are "can" and "nesting". Deep nesting cannot always be easily avoided by breaking into functions, and when that is the case, the loop construct is useful. For the example below I used the nested form to compare 8 keys, where the values of the 8 keys form a single key to a dictionary (or a map). Each item in the map is sorted in lexicographic order. (This code snippet is taken from the article Generic Sparse Array and Sparse Matrices in C#[^]

    public int CompareTo(ComparableTuple8 group)
    {
        int result = this.Item0.CompareTo(group.Item0);

        if (result == 0)
        {
            result = this.Item1.CompareTo(group.Item1);

            if (result == 0)
            {
                result = this.Item2.CompareTo(group.Item2);

                if (result == 0)
                {
                    result = this.Item3.CompareTo(group.Item3);

                    if (result == 0)
                    {
                        result = this.Item4.CompareTo(group.Item4);

                        if (result == 0)
                        {
                            result = this.Item5.CompareTo(group.Item5);

                            if (result == 0)
                            {
                                result = this.Item6.CompareTo(group.Item6);

                                if (result == 0)
                                {
                                    result = this.Item7.CompareTo(group.Item7);
                                }
                            }
                        }
                    }
                }
            }
        }

        return result;
    }

    #endregion
}

That is 8 keys.

[Richard Andrew x64]

ERROR: Symbol "workedOK" is undefined in this context

The difficult we do right away... ...the impossible takes slightly longer.

[Marc Clifton]

I have never needed to use a GOTO statement in any language since BASIC. And when I wrote a recursive extension to the GOSUB function (along with a couple other snazzy enhancements) in Commodore PET's BASIC, I never needed one again either. Marc

Day 1: Spider Database Navigator Unit Testing Succinctly

[Joe Woodbury]

Bur they aren't, and that's really the point. If all someone did was goto a label at the very end of a function, that would be ugly but not terribly problematic. The problem is that the goto ends up going to other logic. With many C developers, it was cleanup code (the destructors, so to speak) which wasn't so bad, but then someone would add more labels until you had a stack of exit conditions, sometimes intertwined. Then, inevitably, you'd find a goto from one scope to the middle of another and that's when you end up with really bad problems. EDIT: To be very clear, the problem with goto is not, and never really has been, with exiting a context abruptly, especially with RAII, but in entering another context at an arbitrarily point.

[Joe Woodbury]

I'll repeat an edit to my reply to Harold up above: The problem with goto is not, and never really has been, with exiting a context abruptly, especially with RAII, but in entering another context at an arbitrarily point.

[Christian Graus]

Because it's so easy to misuse and because other constructs make it much easier to write readable code.

Christian Graus Driven to the arms of OSX by Vista. Read my blog to find out how I've worked around bugs in Microsoft tools and frameworks.