switch statement optimizations

[Rob Adelberg]

I have a single switch statement with about 30 case statements.

I could break the single switch into 3 or 4 switchs, which logically
would be more efficient.

switch()
{
switch() // only 10 cases

switch() // only 10 cases
}
But with compiler optimizations would it make any difference? Would
one way be better than the other?

I'm using MSVC 6

[Alf P. Steinbach]

On 18 Sep 2003 09:12:42 -0700, ro************* @gd-decisionsystems .com (Rob Adelberg) wrote:

I have a single switch statement with about 30 case statements.
Perhaps you're stuck with someone else's code.
I could break the single switch into 3 or 4 switchs, which logically
would be more efficient.
Nope, no logic in that.
switch()
{
switch() // only 10 cases

switch() // only 10 cases
}
But with compiler optimizations would it make any difference? Would
one way be better than the other?
The C++ standard has nothing to say about that.
I'm using MSVC 6

Then ask in a Microsoft group (use news.microsoft. com if necessary),
it's off-topic here (see the FAQ).

[Buster Copley]

Rob Adelberg wrote:

I have a single switch statement with about 30 case statements.

I could break the single switch into 3 or 4 switchs, which logically
would be more efficient.
Huh?
switch()
{
switch() // only 10 cases

switch() // only 10 cases
}
But with compiler optimizations would it make any difference? Would
one way be better than the other?

I'm using MSVC

Switch is often a computed goto, especially if the cases are
reasonably contiguous. (Ooh, deja vu. I must be paraphrasing
someone, but I can't remember whom.) So with a single switch
you get a single computation and a single goto. In any case,
it's the compiler's job to choose the most efficient
implementation.

Regards,
Buster.

[Buster Copley]

Buster Copley wrote:

Rob Adelberg wrote:

I have a single switch statement with about 30 case statements.

I could break the single switch into 3 or 4 switchs, which logically
would be more efficient.

Huh?

switch()
{
switch() // only 10 cases

switch() // only 10 cases
}
But with compiler optimizations would it make any difference? Would
one way be better than the other?

I'm using MSVC

Switch is often a computed goto, especially if the cases are
reasonably contiguous.

Switch _is_ a computed goto, obviously. Sorry. The person I was
paraphrasing was saying that it's often implemented using a jump
table.

[red floyd]

Rob Adelberg wrote:

I have a single switch statement with about 30 case statements.

I could break the single switch into 3 or 4 switchs, which logically
would be more efficient.

switch()
{
switch() // only 10 cases

switch() // only 10 cases
}
But with compiler optimizations would it make any difference? Would
one way be better than the other?

I'm using MSVC 6

Don't worry about efficiency. IMHO, the difference would be minimal. Go with what's
more readable and maintainable. Remember, either you or somebody else will probably
have to look at this a couple of years down the line, and if you make it easier to
deal with then, you've got a win.

[Ron Natalie]

"Rob Adelberg" <ro************ *@gd-decisionsystems .com> wrote in message news:f3******** *************** **@posting.goog le.com...

I have a single switch statement with about 30 case statements.

I could break the single switch into 3 or 4 switchs, which logically
would be more efficient.

That would probably not help. If the number of possible values versus
the number of cases is manageable, the compiler just generates a jump
table in most dcases.