Re: on goto

Richard wrote:
[snip]


Nicely put. If I will ever be tempted enough to actually start a
"poesiealbum" for little pieces of wisdom, this little gem would be
among the ten first entries (why, it would probably the first).

Just to add my 2 cents:
Your statement says that break-statements (I really like the term
"goto in disguise", thank you, James) can keep the loop condition
short and sweet. I think that this is probably not the most convincing
argument for the usage of break-statements, but the readability of
code should not be underestimated. That's why I'd suggest that also
the use of continue-statements can increase the readability a lot. If
you have a look at the following piece of code (from actual production
environment):

// Iterate through all interfaces from the type library.
UINT uiNumberOfTypes = spTypeLib->GetTypeInfoCount ();
for (int i = 0; i < uiNumberOfTypes; i++)
{
  ITypeInfoPtr spCurrTypeInfo;
  spTypeLib->GetTypeInfo (i, &spCurrTypeInfo);
  if (!(bool) spCurrTypeInfo)
    return false;

  // We only want to process interface definitions, so if we encounter
anything
  // else (for example enums), we skip the rest of the loop.
  TYPEATTR* pCurrentTypeAttr;
  VERIFY (SUCCEEDED (spCurrTypeInfo->GetTypeAttr
(&pCurrentTypeAttr)));
  if (pCurrentTypeAttr->typekind != TKIND_DISPATCH &&
      pCurrentTypeAttr->typekind != TKIND_INTERFACE)
    continue;

  : // here comes a quite lengthy loop rest of the loop body (about
130 lines)
}

The same code without a continue-statement would add an if-statement,
which would indent the quite lengthy loop body one more time. Most
people would probably ask "So what?" In my opinion too much indented
code is almost as unreadable as a goto-ridden spaghetti code. When you
have a quite lengthy loop/if body, it's quite easy to forget under
which which conditions the code will actually run (which is why many
people repeat the condition of an if-statement as comment in the else-
part). Keeping this information as small as possible (in above case
the user has only to remember: "we are iterating through the type
library" instead of "we are iterating through all elements of the type
library that are actually interfaces") is, in my eyes, one of the
keypoints of writing readable code: it kind of better matches the
"information flow" of the human brain (I'm probably sticking my neck
out with this thesis, it'd be really interesting to find out whether
this can be backed up scientifically).

As you can see, I couldn't put it as short as you could.

Regards,
Stuart