_>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;
}