int i;
switch(i)
{
case 0:
    break;
default:
    return -1;
}
return 0;

int i, ret;
switch(i)
{
case 0:
    ret = 0;
    break;
default:
    ret = -1;
}
return ret;

Слышал, что ретурн из свитча не есть гуд. Почему — не знаю, возможно из-за худшей оптимизации. Развейте, пожалуйста, сомнения по этому поводу

В С++ нельзя полагаться на некую "линейность" хотябы потому что там еще исключения иногда бывают, и написанному коду должно быть пофиг где происходит выход (с учетком нормально вызова деструкторов всяческих гардов)

enum { eDog, eFox, eWolf };
....
std::string SomeEnumToSomeString(int e)
{
    switch(e)
    {
    case eDog:  return "Dog";
    case eFox:  return "Fox";
    case eWolf: return "Wolf";
    }
    throw "Unexpected enum";
}

switch (m_Direction)
{
case 0:
    return GoToSouth();
case 1:
    return GoToWest();
case 2:
    return GoToNorth();
case 3:
    return GoToEast();
default:
    return ERROR_REDCODE;
}

Не делай больших свичей, как и вообще ветви свчиа, густо и сытно наполненные функциональностью.

Извините за выражение, но х.там! "чем сложнее и больше свитч, тем менее желательно использовать" (к) — _такой_ большой и сложный свич вообще!

Код со свичом:
class Walker
{
int m_Direction;
public:
Walker(int direction):m_Direction(direction){};
int Go()
{
switch (m_Direction)
{
case 0:
    return GoToSouth();
case 1:
    return GoToWest();
case 2:
    return GoToNorth();
case 3:
    return GoToEast();
default:
    return ERROR_REDCODE;
}
}
};
Код без:

class IWalker
{
public:
virtual int Go() = 0;
};

class SouthWalker : public IWalker
{
public:
virtual int Go(){return GoToSouth()};
};

class WestWalker : public IWalker
{
public:
virtual int Go(){return GoToWest()};
};

class NorthWalker : public IWalker
{
public:
virtual int Go(){return GoToNorth()};
};

class EastWalker : public IWalker
{
public:
virtual int Go(){return GoToEast()};
};

class Walker {
public:
    enum Direction_t{ Nord, East, South, West };

    Walker()
    {
        setWalker( Nord, &Walker::goNord );
        setWalker( East, &Walker::goEast );
        setWalker( South, &Walker::goSouth );
        setWalker( West, &Walker::goWest );
    }

    int Walk( Direction_t d, int param )
    {
        WalkerMethod walker = getWalker( d );
        assert( walker != 0 );
        return (this->*walker)( param );
    }
private:
    typedef int Walker::*WalkerMethod( int );

    void setWalker( Direction_t, WalkerMethod );  // Реализаия неважна. Например std::map<Direction_t, WalkerMethod>
    WalkerMethod getWalker( Direction_t ) const;

    собственно методы
    int goNord( int );
    int goEast( int );
    int goSouth( int );
    int goWest( int );
}

dir = ( dir + howrs ) % Dir_Count;
Walk( dir );

E>

dir = ( dir + howrs ) % Dir_Count;
E>Walk( dir );

Так хорошо?

dir = ( dir + howrs ) % Dir_Count;
walker[dir]->Go();

class Walker {
public:
   enum Direction_t{ Nord, East, South, West };

   Walker()
   {
       const struct { Direction_t direction; WalkerMethod method; } the_way[] = 
       {
       Nord, &Walker::goNord,
       East, &Walker::goEast,
       South, &Walker::goSouth,
       West, &Walker::goWest
       };

       for (int i = 0; i < sizeof(the_way)/sizeof(the_way[0]); ++i)
         setWalker( the_way[i].direction, the_way[i].method );
   }
   ...
}

dir = ( dir + howrs ) % Dir_Count;
А>walker[dir]->Go();
А>

Ну ведь гдето есть код который выставляет эту переменную в нужные значения в зависимости от неких внешних факторов, которые выражаются не свичом, а логикой более высокого уровня (которую принято называть базнес-логикой) ? Так прямо там и создавать нужный класс.

TL>ЗЫ: описание массива прямо в конструкторе неуклюже и непринципиально — просто чтобы не выдумывать "специальное место для", а принцип проиллюстрировать...

if( ICanJump() ) {
    setWalker( Up, &Walker::goUp );
    setWalker( Down, &Walker::goDown );
}

TL>>>Извините за выражение, но х.там! "чем сложнее и больше свитч, тем менее желательно использовать" (к) — _такой_ большой и сложный свич вообще!

А>>Извинить, не извинить не могу, потому что не пойму что за "х.там" может "х.. там"?

А>>Если я правильно понял, фраза "_такой_ большой и сложный свич вообще! " выражает недовольство большими свитчами. Я тоже не люблю когда много кода. Но когда его мало, босс отказывается платить

TL>Лично я всегда не любил "код идусского типа" — который "много-много строк кода, за которые и будет уплочено". Каждому свое, как говорили одни мои земляки — но не просите меня за эти "много кода" вас и ваш код любить и даже уважать.

"код идусского типа" — который "много-много строк кода, за которые и будет уплочено".

Угу. Если у тебя еще и автомат состояний "вручную описан на больших-больших свичах" — тогда, извините, это не ко мне

Если честно, я злой — невыспался — а ты сам толком не понимаешь что спросить, но спросить хочешь, и спрашиваешь "а как вообще быть-то"? Потому ответ "вообще никак не быть — самое то!" (к) — имхо, самый правильный общий ответ на общий вопрос.

Result StateMachine::HandleStateChange(NewState st)
{
switch (st)
{
case State1: 
    return onSTate1();

case State2: 
    return onSTate2();

case State3: 
    return onSTate3();

case State4: 
    return onSTate4();

case State5: 
    return onSTate5();

case State6: 
    return onSTate6();

case State7: 
    return onSTate7();
............
}
}

Вместо того, чтобы не делать большие свичи, а в легких и прозрачных запросто применять ретурны, ты придумываешь оправдания, почему таки, по твоему скромному мнению, надо делать большие свичи. А их не надо делать _вообще_. Никто не против, если автомат переходов у тебя будет на свичах — но автомат отдельно, а функциональность отдельных состояний — отдельно. "Разделяй и властвуй" — в программировании сей постулат архиприменим как нигде. (политику не будем — там как раз неприменим для целей _созидания_.

ПО сабжу: Камрады, один знакомый все утверждал, что использование switch в C++ вообще... неуместно в принцепи! Мол в C++ надо "как-то иначе". Естесно, на вопрос "Как?" ответ не прозвучал. Может кто нибудь сведующий кашерный стиль кодинга развеет непонимание?