3.3.2 Оператор goto



Презираемый оператор goto все-таки есть в С++:

goto идентификатор;

идентификатор: оператор

Вообще говоря, он мало используется в языках высокого уровня, но
может быть очень полезен, если текст на С++ создается не человеком,
а автоматически, т.е. с помощью программы. Например,
операторы goto используются при создании анализатора по заданной
грамматике языка с помощью программных средств.
Кроме того, операторы goto могут пригодиться в тех случаях,
когда на первый план выходит скорость работы программы. Один из
них — когда в реальном времени происходят какие-то вычисления во
внутреннем цикле программы.
Есть немногие ситуации и в обычных программах, когда применение
goto оправдано. Одна из них — выход из вложенного цикла или
переключателя. Дело в том, что оператор break во вложенных циклах
или переключателях позволяет перейти только на один уровень выше.
Приведем пример:

           void f()
           {
             int i;
             int j;

             for ( i = 0; i < n; i++)
                 for (j = 0; j<m; j++)
                     if (nm[i][j] == a) goto found;
                 // здесь a не найдено
                 // ...
             found:
                 //  nm[i][j] == a
           }

for (...) {
  if (...) break;
}
// а тут надо что-то сделать в случае, если выход из цикла был не по break

for(int i=0;i<n1;++i) {
  for(int j=0;j<n2;++j) {
    if(come_condition1) goto next1;
    for(int k=0;k<n3;++k) {
      if(come_condition2) goto next2;
    }
    // some code
  }
  next2:
  // some code
}
next1:
// some code

state_1:
  switch (signal) {
    case 1: goto state_5;
    case 2: goto state_10;
    case 3: goto state_8;
  }
state_2:
  switch (signal) {
    case 7: goto state_37;
    case 10: goto state_1;
    case 9: goto state_100;
  }

_>Напишите этот кусочек кода не криво плиз, а то я никак не соображу как

_>for(int i=0;i<n1;++i) {
_>  for(int j=0;j<n2;++j) {
_>    if(come_condition1) goto next1;
_>    for(int k=0;k<n3;++k) {
_>      if(come_condition2) goto next2;
_>    }
_>    // some code
_>  }
_>  next2:
_>  // some code
_>}
_>next1:
_>// some code
_>

doSomeActivityInFor();
//someCode;

inline void doSomeActivityInFor() {
  for(int i=0;i<n1;++i) {
    for(int j=0;j<n2;++j) {
      if(come_condition1) return;

      if (some_condition3(i,j) {
         break;
      }
     // some code
   }
   // some code
}

inline bool some_condition3(i,j) {
   for(int k=0;k<n3;++k) {
      if(come_condition2()) return true;
   }
   return false;
}

_>Приведите пример красивого рефакторинга Дабы увеличить читабельность кода.

_>Откуда число 99.95%?, до боли знакомая рекламная константа

for(int i=0;i<n1;++i){for(int j=0;j<n2;++j){if(c1)goto next1;for(int k=0;k<n3;++k){if(c2)goto next2;}}next2:;}next1:;

template< class ValueType >
void EstimateContour(
  const TGL::Point< ValueType,2 > *pPoints,
  int nPoints,
  const TGL::Polygon< ValueType,2 > &rPolygon,
  const CirclesCondition &rCirclesCond,
  const PointsCondition &rPointsCond) {

  msg_assert(nPoints>0,"Множество точек пусто");

  std::vector< TGL::Circle< ValueType > > Circles;
  TGL::Point< ValueType,2 > Inv1,Inv2;
  TGL::Circle< ValueType > c;

  Inv1=Inv2=pPoints[0];

  for(int i=0;i<nPoints;++i) {
    // отбрасываем точки вне оболочки
    if(!rPolygon.IsPointIn(pPoints[i])) continue;

    for(int j=i+1;j<nPoints;++j) {
      // первое условие двойственности
      if(!rCirclesCond.CheckFirst(pPoints[i],pPoints[j],rPointsCond)) goto next1;
      rPointsCond.Invert(Inv1,pPoints[j]);

      for(int k=j+1;k<nPoints;++k) {
        // второе условие двойственности
        if(!rCirclesCond.CheckSecond(pPoints[j],pPoints[k],rPointsCond)) goto next2;
        rPointsCond.Invert(Inv2,pPoints[k]);

        c.Estimate(pPoints[i],pPoints[j],pPoints[k]);
        c.Refine(Inv1,Inv2);
        // сохраняем если центр окружности принадлежит оболочке
        // и найденные параметры входят в заданный диапазон
        if(rPolygon.IsPointIn(c.Center())&&
           rCirclesCond.Check(c)) Circles.push_back(c);
      }
      
    }
    next2:;
  }
  next1:;
  EstimateHull(Circles,pPoints,nPoints);
}

NBN>for(int i=0;i<n1;++i){for(int j=0;j<n2;++j){if(c1)goto next1;for(int k=0;k<n3;++k){if(c2)goto next2;}}next2:;}next1:;
NBN>

for( int i = 0; i < n; ++i )
{
}

for( int i=0; i<n; ++i ) {
}

for(int i=0;i<n;++i)
{
}

const char* strnstr(const char* pStr,int nStrLength,const char* pSubStr,int nSubStrLength)
{
    nStrLength-=nSubStrLength;
    for(int i=0;i<=nStrLength;++i,++pStr)
    {
        for(int j=0;j<nSubStrLength;++j)
           if(pSubStr[j]!=pStr[j]) goto NEXT;//a)Можно было бы использовать "break"

        //b)А здесь мог бы быть "if(j>=nSubStrLength)"
        return pStr;

        NEXT:;//c)Ну и само собой, этой метки здесь тоже могло бы не быть
    }
    return 0;
}

bool add(int a,int b,int& c)
{
  c=a+b;

  //А теперь проверим - было ли переполнение?
  __asm
  {
    jc CarryFlag 
  }

  //no carry
  return 0;

  CarryFlag:;

  //carry
  return 1;
}

pozicionN:
///////
switch()
{  case 1: goto pozicion1;
///////////////////////
}

__>for (...) {
__>  if (...) break;
__>}
__>// а тут надо что-то сделать в случае, если выход из цикла был не по break
__>

for(... ;; ...)
{  if(end())
   { /* а тут надо что-то сделать в случае, если выход из цикла был не по */      break;
   }
   .................
   if (...) break;
   ..............
}

__>disclaimer: я не призываю всегда в этих случаях пользоваться goto

void foo()
{  DoSDELATb_VSE();
   DoSDELATb_IS4E_RAZ();
   DoZAKON4ITb();
}

Connect:
  ...
  goto Connect;

Глава 13. Целое и части
…
Проектирование без ошибок
…
Структурное программирование
…
В основе, несомненно, лежат здравые мысли. При обсуждении сделано много критических замечаний — в частности, большое удобство представляют дополнительные управляющие структуры, такие как n-вариантный переход (так называемый оператор CASE) для различения среди нескольких случаев и аварийный выход (GO TO ABNORMAL END). Кроме того, некоторые догматически избегают всех GO TO, что представляется чрезмерным.

_>template< class ValueType >
_>void EstimateContour(
_>

_>Исключения не используем вообще, и более того, открою страшный секрет

_>Мы два года назад отказались от проверок на ошибки выделения памяти

NBN>>for(int i=0;i<n1;++i){for(int j=0;j<n2;++j){if(c1)goto next1;for(int k=0;k<n3;++k){if(c2)goto next2;}}next2:;}next1:;
NBN>>

_>

_>И знаешь что удивительно? Никто никогда не жаловался на плохую читабельность

template< class ValueType >
class ContourEstimator
{
    typedef TGL::Point< ValueType, 2 >  TPoint;
    typedef TGL::Polygon< ValueType, 2 >TPolygon;
    typedef TGL::Circle< ValueType >    TCircle;
    typedef std::vector<TCircle>        TCircles;
public:

    ContourEstimator(
        const TPoint* points,
        int count_of_points,
        const TPolygon& polygon,
        const CirclesCondition& circlesCond,
        const PointsCondition& pointsCond
        )
        : points(points)
        , count_of_points(count_of_points)
        , polygon(polygon)
        , circlesCond(circlesCond)
        , pointsCond(pointsCond)
        , inv1(points[0])
        , inv2(points[0])
    {
        circles.reserve( count_of_points );
    }

    void EstimateContour()
    {
        for(int i = 0; i < count_of_points; ++i)
        {
            // отбрасываем точки вне оболочки
            if( !polygon.IsPointIn( points[i] ) )
                continue;
            if ( !EstimateContourDim2( i ) )
                break;
        }
        EstimateHull( circles, points, count_of_points );
    }

private:
    TCircles        circles;
    TPoint          inv1, inv2;
    const TPoint*   points;
    size_t          count_of_points;
    const TPolygon& polygon;

    const CirclesCondition& circlesCond;
    const PointsCondition&  pointsCond;


    bool EstimateContourDim2(int i)
    {
        for(int j = i + 1; j < count_of_points; ++j)
        {
            // первое условие двойственности
            if( !circlesCond.CheckFirst( points[i], points[j], pointsCond ) )
                return false;

            if( !EstimateContourDim3( i, j ) )
                return false;
        }
        return true;
    }

    bool EstimateContourDim3(int i, int j)
    {
        pointsCond.Invert( inv1, points[j] );

        for(int k = j + 1; k < count_of_points; ++k)
        {
            // второе условие двойственности
            if( !circlesCond.CheckSecond( points[j], points[k], pointsCond ) )
                return false;
            pointsCond.Invert( inv2, points[k] );

            TCircle circle;
            circle.Estimate( points[i], points[j], points[k] );
            circle.Refine( inv1, inv2 );
            // сохраняем если центр окружности принадлежит оболочке
            // и найденные параметры входят в заданный диапазон
            if( polygon.IsPointIn( circle.Center() ) && circlesCond.Check( circle ) )
                circles.push_back( c );
        }
        return true;
    }
};

P>Если даже на это не смотреть, то область видимости расширилась на другие методы. И потом исходный код на экран помещался а этот 2 раза перелистывать нужно В общем ф топку

template< class ValueType >
struct ContourEstimator {
 typedef TGL::Point< ValueType, 2 >TPt;
 typedef TGL::Polygon< ValueType, 2 >TPn;
 ContourEstimator(const TPt* p,size_t cp,const TPn& pn,const CirclesCondition& cc,const PointsCondition& pc)
 : points(p), cpoint(cp), polygon(pn), circlesCond(cc), pointsCond(pc), inv1(p[0]), inv2(p[0]) {}
 void EstimateContour(){
  for(size_t i=0; i<cpoint; ++i){
   // отбрасываем точки вне оболочки
   if( !polygon.IsPointIn( points[i] ) )continue;
   if( !EstimateContourDim2( i ) )break;
  }
  EstimateHull( circles, points, cpoint );
 }
 std::vector<TGL::Circle< ValueType >> circles;
 TPt inv1, inv2;
 const TPt* points;
 size_t cpoint;
 const TPn& polygon;
 const CirclesCondition& circlesCond;
 const PointsCondition&  pointsCond;
 bool EstimateContourDim2(size_t i){
  for(size_t j=i+1; j<cpoint; ++j){
   // первое условие двойственности
   if(!circlesCond.CheckFirst(points[i],points[j],pointsCond)||!EstimateContourDim3(i,j))return false;
  }
  return true;
 }
 bool EstimateContourDim3(size_t i, size_t j){
  pointsCond.Invert( inv1, points[j] );
  for(size_t k=j + 1; k<cpoint; ++k){
   // второе условие двойственности
   if( !circlesCond.CheckSecond( points[j], points[k], pointsCond ) )return false;
   pointsCond.Invert( inv2, points[k] );
   TGL::Circle< ValueType > c;
   c.Estimate( points[i], points[j], points[k] );
   c.Refine( inv1, inv2 );
   // сохраняем если центр окружности принадлежит оболочке
   // и найденные параметры входят в заданный диапазон
   if( polygon.IsPointIn( c.Center() ) && circlesCond.Check( c ) )circles.push_back( c );
  }
  return true;
 }
};

Н>>  c=a+b;

Н>>  //А теперь проверим - было ли переполнение?
Н>>  __asm
Н>>  {
Н>>    jc CarryFlag 
Н>>  }

Н>>}
Н>>

d = a + b + c;
leftfunc(d);
c = a + b;
__asm { jc... }

__asm {
  mov eax,[a]
  add eax,[b]
  jc CarryFlag
}

inline
bool // 0 - нет переполнения, 1 - переполнение
unsigned_check_add(unsigned a, unsigned b)
{
  unsigned r;
  asm(
    "mov eax,%1\n"
    "add eax,%2\n"
    "mov eax,0\n"
    "rol eax,1"
    : "=a"(r) // результат брать из eax
    : "m"(a), "m"(b) // входные данные могут быть в памяти или в стеке, не важно
    : "cc" // побочный эффект - модификация Flags
  );
  return r;
}

input:
    data - a set of observed data points
    model - a model that can be fitted to data points
    n - the minimum number of data values required to fit the model
    k - the maximum number of iterations allowed in the algorithm
    t - a threshold value for determining when a data point fits a model
    d - the number of close data values required to assert that a model fits well to data
output:
    bestfit - model parameters which best fit the data (or nil if no good model is found)

iterations := 0
bestfit := nil
besterr := infinity
while iterations < k 
    maybeinliers := n randomly selected values from data
    maybemodel := model parameters fitted to maybeinliers
    alsoinliers := empty set

    for every point in data not in maybeinliers 
        if point fits maybemodel with an error smaller than t
             add point to alsoinliers
    
        if the number of elements in alsoinliers is > d 
        (this implies that we may have found a good model now test
        how good it is)
        bettermodel := model parameters fitted to all points in maybeinliers and alsoinliers
        thiserr := a measure of how well model fits these points
        if thiserr < besterr 
            bestfit := bettermodel
            besterr := thiserr
     
    increment iterations

return bestfit

"... в этом участке кода я не буду юзать goto, хотя при этом код был бы в 100 понятнее, короче и быстрее... я лучше нафигачу 15-ть if-ов, да пару функций... потому что я гдето слышал(не помню где) что goto это плохо и мой код будет кривой..."

class A
{
  private:
      int _i;
    public:
      int& I { 
          get { return _i; }
            set { _i = value * 2;}
        }
}


A a;
a.I = 1; // что здесь будет выполнено? Присваивание по ссылке или вызов метода?
int k = 2;
a.I = k; // а здесь?

Type 
  A = class
    private
      _i: Integer;
        procedure SetI(aValue: Integer);
    public
      property I read _i write SetI;
    end;

public class A
{
  private int _i;
    public int I
    {
      get { _i = value; }
        set { return _i; }
    }
}

S>public class A
S>{
S>  private int _i;
S>    public int I
S>    {
S>      get { _i = value; }
S>        set { return _i; }
S>    }
S>}
S>

    public class Conflict
    {
        private int m_IntValue;

        public int IntValue
        {
            get { return m_IntValue; }
            set { m_IntValue = value; }
        }

        public int get_IntValue()
        {
            return 0;
        }
    }

_>Как говорил наш препод, главное при оптимизации кода, не изменить результат его работы

if( !EstimateContourDim3( i, j ) )
    break;