do
{
  if () break;

  if () break;

} while(false);

switch(0)
{ case 0:

  if () break; 

}

for(;;)
{
  if () break;
  if () continue;

  break;
}

do
{
  func1();
  if (func2()) break;
  func3();
  if (func4()) break;
  func5();
} while (false);

{
  func1();
  if (func2()) goto end_job;
  func3();
  if (func4()) goto end_job;
  func5();
end_job:
}

E>{
E>  func1();
E>  if (func2()) goto end_job;
E>  func3();
E>  if (func4()) goto end_job;
E>  func5();
E>end_job:
E>}
E>

{
  func1();
  if (func2()) goto end_job;
  std::string name = func3();
  if (name != "ok") goto end_job;
  func5();
end_job:
}

void foo() 
{
    MyObj* theObj = 0;
    {   // Search object
         if( cond1_1 ) {
             theObj = ...;
             goto endOfSearchObj;
         }
         if( cond1_2 ) {
             theObj = ...;
             goto endOfSearchObj;
         }
         if( cond1_3 ) {
             theObj = ...;
             goto endOfSearchObj;
         }
    }
endOfSearchObj: ;
    // тут какой-то хитрый эпилог поиска, из-за которого goto вообще понадобился
    assert( theObj != 0 ); 

    {   // process theObj
         if( cond2_1 ) {
             // process theObj...
             goto endOfProcessObj;
         }
         if( cond2_2 ) {
             // process theObj...
             goto endOfProcessObj;
         }
         if( cond2_3 ) {
             // process theObj...
             goto endOfProcessObj;
         }
    }
endOfProcessObj: ;
    // тут какой-то хитрый эпилог обработки, из-за которого goto вообще понадобился
}

MyObj* findObj()
{
    MyObj* theObj = 0;
    {   // Search object
         if( cond1_1 ) {
             theObj = ...;
             goto endOfSearchObj;
         }
         if( cond1_2 ) {
             theObj = ...;
             goto endOfSearchObj;
         }
         if( cond1_3 ) {
             theObj = ...;
             goto endOfSearchObj;
         }
    }
endOfSearchObj: ;
    // тут какой-то хитрый эпилог поиска, из-за которого goto вообще понадобился
    assert( theObj != 0 ); 
    return theObj;
}

MyObj* processObj( MyObj* theObj ) 
{
    {   // process theObj
         if( cond2_1 ) {
             // process theObj...
             goto endOfProcessObj;
         }
         if( cond2_2 ) {
             // process theObj...
             goto endOfProcessObj;
         }
         if( cond2_3 ) {
             // process theObj...
             goto endOfProcessObj;
         }
    }
endOfProcessObj: ;
    // тут какой-то хитрый эпилог обработки, из-за которого goto вообще понадобился
}
void foo() 
{
    processObj( findObj() );
}

E>Это ЕЩЁ ХУЖЕ для поддержки. Так тебе надо въехать в то, что цикл -- это на самом деле не цикл. А так сначала надо будет найти и понять эти макросы, а потом въехать, что цикл -- это не цикл

BLOCK_BEGIN
{
    if (smth)
        BLOCK_EXIT;
    if (smth_else)
        BLOCK_EXIT;
    do_smth_useful();
}
BLOCK_END

do { // Обработка команд сервера
   if( обычный_случай ) {
       // ...
       break;
   }
} while( 0 );

{ // Обработка команд сервера 
   if( обычный_случай ) {
       // ...
       goto endOfServerCommansProcess;
   }
}
endOfServerCommansProcess:;

do { // Обработка команд сервера
   if( необычный_случай ) {
       // ...
       break;
   }
} while( условие_продолжения );

E>>Это ЕЩЁ ХУЖЕ для поддержки. Так тебе надо въехать в то, что цикл -- это на самом деле не цикл. А так сначала надо будет найти и понять эти макросы, а потом въехать, что цикл -- это не цикл

CF>BLOCK_BEGIN
CF>{
CF>    if (smth)
CF>        BLOCK_EXIT;
CF>    if (smth_else)
CF>        BLOCK_EXIT;
CF>    do_smth_useful();
CF>}
CF>BLOCK_END
CF>

BLOCK_BEGIN
{
    while (condition)
        if (smth)
            BLOCK_EXIT;
    while (another_condition)
        if (smth_else)
            BLOCK_EXIT;
}
BLOCK_END

RT>BLOCK_BEGIN
RT>{
RT>    while (condition)
RT>        if (smth)
RT>            BLOCK_EXIT;
RT>    while (another_condition)
RT>        if (smth_else)
RT>            BLOCK_EXIT;
RT>}
RT>BLOCK_END
RT>

BLOCK_BEGIN(BlockName)
{
    while (condition)
        if (smth)
            BLOCK_EXIT(BlockName);
    while (another_condition)
        if (smth_else)
            BLOCK_EXIT(BlockName);
}
BLOCK_END(BlockName)

E>1) Я подумаю, что эти все макросы -- какой-то замут на тему об обработке ОШИБОК...

E>Соответсвенно, буду ожидать, что условия if'ов -- это какие-то исключительные ситуации...

E>Ну я конечно понимаю, что я старомоден, но перед использованием библиотек я обычно заглядываю сначала в мануал...

#define BEGIN_MESSAGE_MAP(theClass, baseClass) \
    PTM_WARNING_DISABLE \
    const AFX_MSGMAP* theClass::GetMessageMap() const \
        { return GetThisMessageMap(); } \
    const AFX_MSGMAP* PASCAL theClass::GetThisMessageMap() \
    { \
        typedef theClass ThisClass;                           \
        typedef baseClass TheBaseClass;                       \
        static const AFX_MSGMAP_ENTRY _messageEntries[] =  \
        {

E>2) Меня волнуте именно то, что сообщение обрабатывается как-то не там и этот код мне читать НУЖНО. Как во втором случае читать без мануала (не зная что такое карта сообщений) я

E>Карта сообщений делает вполне сложную и нужную функциональность. А вот все эти пляски с do while(0) вокруг goto никакого функционала, IMHO, не добавляют, то есть вредят.

RT>BLOCK_BEGIN
RT>{
RT>    while (condition)
RT>        if (smth)
RT>            BLOCK_EXIT;
RT>    while (another_condition)
RT>        if (smth_else)
RT>            BLOCK_EXIT;
RT>}
RT>BLOCK_END
RT>

namespace ScopeDatails {
    struct Guard { bool False() { return false; } };
}//ScopeDatails
#define SCOPE_GUARD_NAME_( SCOPE_NAME ) guardOf##SCOPE_NAME
#define SCOPE_END_NAME_( SCOPE_NAME ) endOf##SCOPE_NAME
#define SCOPE_BEGIN_NAME_( SCOPE_NAME ) beginOf##SCOPE_NAME

#define SCOPE_START( SCOPE_NAME ) { \ SCOPE_BEGIN_NAME_( SCOPE_NAME ):
    ScopeDatails::Guard SCOPE_GUARD_NAME_( SCOPE_NAME );
#define SCOPE_END( SCOPE_NAME ) SCOPE_GUARD_NAME_( SCOPE_NAME ).False(); } \
    SCOPE_END_NAME_( SCOPE_NAME ):;
#define SCOPE_LEAVE( SCOPE_NAME ) if( SCOPE_GUARD_NAME_( SCOPE_NAME ).False() ) else goto SCOPE_END_NAME_( SCOPE_NAME )

void foo()
{
    SCOPE_START( DetectProcessor )
    {
        if( isProcXXX() ) {
            doXXX();
            SCOPE_LEAVE( DetectProcessor );
        }
        if( isProcYYY() ) {
            doYYY();
            SCOPE_LEAVE( DetectProcessor );
        }
        doCommonCase();
    }
    SCOPE_END( DetectProcessor )

}

do{
};

try {
    if( XXX ) {
        throw 666;
    } 
} catch( int rootOfEvil ) {
        // process XXX
}

while()
{
};

E>Если коротко, то всем

E>Моим подчинённым, например, крайне редко удаётся протащить через меня какой-нибудь макрос...

#define SIZE_CHECK(type,bits)    static_assert (sizeof(type) == bits/8, #type " != " #bits " bit")
#define foreach(it,cont)            for (auto it = (cont).begin (), foreach_end_##it = (cont).end ();it != foreach_end_##it;++it)
#define countof(array)                (sizeof (array)/sizeof (array[0]))

CC>#define countof(array)                (sizeof (array)/sizeof (array[0]))

#include <iostream>
#include <ostream>

#define countof(array) (sizeof (array)/sizeof (array[0]))

int main()
{
    int array[3];
    int* ptr = array;
    std::cout << "array: " << countof(array) // 3
              << " ptr: " << countof(ptr) // implementation-defined, sizeof(int*)/sizeof(int)
              << "\n";
    return 0;
}

#include <iostream>
#include <ostream>

template <typename T, size_t N>
size_t countof(T (&)[N])
{
    return N;
}

int main()
{
    int array[3];
    int* ptr = array;
    std::cout << "array: " << countof(array) // 3
              << " ptr: " << countof(ptr) // compile-time error
              << "\n";
    return 0;
}

CC>>#define countof(array)                (sizeof (array)/sizeof (array[0]))
C>

#define countof(array) (5 / ((sizeof(array) != sizeof(void*))?5:0), (sizeof(array)/sizeof(array[0])))

template <typename T, size_t N>
size_t countof(T (&)[N])
{
    return N;
}

try {
    if( XXX ) {
        throw 666;
    if( YYY ) {
        throw 777;
    if( ZZZ ) {
        throw 888;
    } 
} catch( int rootOfEvil ) {
        // process XXX
}

CF>2. Ну, здесь как и с любым инструментом: если кто-то пихает его, где ни попадя, это значит, что плох программист, а не инструмент. Не знаю, я подобные try-catch применяю в таких случаях, как, например, проверка входных данных.

E>>Соответсвенно, если у тебя эти сомнительные конструкции не используются то и согласовывать ничего не надо

#drfine MAX( A, B ) ((A) > (B) ? (A) : (B))
char* q = "12";
int mx = MAX( *q++. *q++ );

E>>Что касается goto, то по нему нельзя обрулить создание объекта, доступного в точке, куда осуществляется переход...

N_>Вот и говорю что не нужен , потому что слишком много всяких таких "но" и подводных камней в его использовании.

    goto afterA;
    std::string A;
afterA: ;

CC>>#define SIZE_CHECK(type,bits) static_assert (sizeof(type) == bits/8, #type " != " #bits " bit")
CC>>#define foreach(it,cont)      for (auto it = (cont).begin (), foreach_end_##it = (cont).end ();it != foreach_end_##it;++it)
CC>>#define countof(array)        (sizeof (array)/sizeof (array[0]))
CC>>

SIZE_CHECK(char,  8);
SIZE_CHECK(BYTE,  8);
SIZE_CHECK(short, 16);
SIZE_CHECK(WORD,  16);
SIZE_CHECK(int,   32);
SIZE_CHECK(DWORD, 32);
SIZE_CHECK(float, 32);
SIZE_CHECK(void*, 32);
SIZE_CHECK(size_t,32);
SIZE_CHECK(double,64);
SIZE_CHECK(int64, 64);
...

foreach (it, cont)
{
    foo (*it);
}

#define foreach(it,cont)   for (auto it = (cont).begin ();it != (cont).end ();++it)

template<class _InIt, class _Fn1> inline _Fn1 for_each(_InIt _First, _InIt _Last, _Fn1 _Func)
    {    // perform function for each element
    _DEBUG_RANGE(_First, _Last);
    _DEBUG_POINTER(_Func);
    _CHECKED_BASE_TYPE(_InIt) _ChkFirst(_CHECKED_BASE(_First));
    _CHECKED_BASE_TYPE(_InIt) _ChkLast(_CHECKED_BASE(_Last));
    for (; _ChkFirst != _ChkLast; ++_ChkFirst)
        _Func(*_ChkFirst);
    return (_Func);
    }

E>Так что нет все три раза.

CC>SIZE_CHECK(char,  8);
CC>SIZE_CHECK(BYTE,  8);
CC>SIZE_CHECK(short, 16);
CC>SIZE_CHECK(WORD,  16);
CC>SIZE_CHECK(int,   32);
CC>SIZE_CHECK(DWORD, 32);
CC>SIZE_CHECK(float, 32);
CC>SIZE_CHECK(void*, 32);
CC>SIZE_CHECK(size_t,32);
CC>SIZE_CHECK(double,64);
CC>SIZE_CHECK(int64, 64);
CC>...
CC>

foreach( it, readVectorFromFile() );

for( auto it = cont.begin(), it != cont.end(); ++it ) {
}

E>>Так что нет все три раза.

C>#include <iostream>
C>#include <ostream>

C>template <typename T, size_t N>
C>size_t countof(T (&)[N])
C>{
C>    return N;
C>}

C>int main()
C>{
C>    int array[3];
C>    int* ptr = array;
C>    std::cout << "array: " << countof(array) // 3
C>              << " ptr: " << countof(ptr) // compile-time error
C>              << "\n";
C>    return 0;
C>}
C>

template<int N> struct N2Type { 
    char body[N]; 
    operator int() const { return N; } 
};
template <typename T, size_t N>
N2Type<N> countof(T (&)[N])
{
    return N2Type<N>();
}

#define COUNTOF( array ) sizeof countof( array )

sizeof in_items( arr )

int mx = MAX( *q++. *q++ );