[quote name='snowmanZOMG' timestamp='1354529055' post='5006558']
Almost everyone LOVES Java and hates C, C++,
Try writing a parser in pure C#, you will run into exactly the same issues. It also happens that there are many more parsers available to C++ than there is C#. And those for C# are usually just bindings to a C++ library anyway.
[quote name='NightCreature83' timestamp='1354278416' post='5005667']
how would you replace the goto in this bit with an exception
for (int bar =0; bar < 100; ++bar)
{
for(int foo = 0; foo < 100; ++foo)
{
if (foo * bar == 100)
{
goto loopBreak;
}
}
}
loopBreak:
printf("%d", 100);
int findSomething()
{
for (int bar =0; bar < 100; ++bar)
{
for(int foo = 0; foo < 100; ++foo)
{
if (foo * bar == 100)
{
return 100;
}
}
}
return -1;
}
// Then in your code...
printf("%d", findSomething());
Does anyone still write a parser by hand instead of using yacc, antlr or something ?
Just thought I'd throw an alternative out here (it's kind of hard to give any kind of "proper" alternative, because the original will always print 100, no matter what...):
int findSomething()
{
for (int bar =0; bar < 100; ++bar)
{
for(int foo = 0; foo < 100; ++foo)
{
if (foo * bar == 100)
{
return 100;
}
}
}
return -1;
}
// Then in your code...
printf("%d", findSomething());
I've found that most of the time, deeply nested stuff can be turned into useful, smaller functions. Not always, but a lot of the time.
I recognize multi-level break goto is not a terrible construct, and it's probably necessary in some high performance code, but most of the time you can do this:
I have seen people bending over backwards trying to avoid using goto, doing things like extricating that part of the code, but the function name ends up being some monstrosity with the word "helper" in it, and it ends up getting most of the local variables of the calling function as parameters, some of them by reference. In that case that piece of code has no business being a function, and the goto is preferable.
[&](){ /* may return from inner loop here */ }();
[&](){ /* may return from inner loop here */ }();
Same natural code structure as with the goto solution, but no goto, no contrived names or messy argument lists.[/quote]
The goto solution has the same natural code as with the lambda-expression solution, but no lambda expression and no returns that don't actually return from the function.
