res fn(p1,p2,p3,p4){

//1)блок проверки параметров: параметры функции
//параметры функции обычно правильные
[rare]::if (!p1) throw;
[rare]::if (!p2) throw;
[rare]::if (p3<p4) throw;

//2)блок проверки параметров: индекс массива
//индекс обычно ожидается внутри массива
[rare]::if( (idx < base )||( idx >= top) )throw;

//3)обычный цикл
//в данном цикле обычно ожидается один или более повторов
[often]::for (; *p1; --(*p1)){}

//4)обычный цикл
//только одна точка обычно ожидается вне достаточно большого окна после начала вывода линии
[often]::for (;;){ [rare]::if (point_out_of_window) break; }
}

//5)
//класс h_p32h_
//объекты которого хранят (h) монопольное владение динамической памятью (h), адресуемой 32 битным указателем (p32)

template <class T>
struct h_p32h_{

p32h_<T> ptr;

//подразумеваем "двухстадийные конструкторы",
//исключения второй стадии генерируются из кода {} как из обычных функций
//(деструктор объекта вызывается)
//
//исключения первой стадии "подготовки объекта к деструкции" генерируются
//при инцициализации каждого поля ("после каждой запятой"), при этом частично
//созданные поля деструктируются автоматически (деструктор объекта не вызывается)
//
nothrow h_p32h_():ptr(0){}
nothrow h_p32h_(const p32h_<T> p_data):ptr(p_data){}

//копирование запрещено

...

//деструктор такого объекта вызывает функцию delete для своих данных очень часто,
//деструкция всегда связана с освобождением ресурса
//подразумеваем стек исключений, деструкторы могут бросать исключения
~h_p32h_() throw(ex_alloc) { [often]::if(ptr){ delete_h ptr; ptr=0; } }
};


//класс w_p32h_, RAII wrapper (w)
//объекты которого монопольно владеют динамической памятью (h), адресуемой 32 битным указателем (p32)
//new возвращает такой wrapper
//подразумеваем семантику перемещения (operator move <-<)

template <class T>
struct w_p32h_{

p32h_<T> ptr;

nothrow w_p32h_():ptr(0){}
nothrow w_p32h_(const p32h_<T> p_data):ptr(p_data){}

//
nothrow w_p32h_(const moveable w_p32h_& obj):ptr(<-<obj.ptr){}

...

//деструктор такого объекта вызывает функцию delete для своих данных довольно редко,
//обычно деструкция связана только с передачей владения другому указателю или с переходом указателя по стекам функций
~w_p32h_() throw(ex_alloc) { [rare]::if(ptr){ delete_h ptr; ptr=0; } }
};


//класс ha_p32h_
//объекты которого хранят (h) во фреймах стека_A (a) владение динамической памятью (h), адресуемой 32 битным указателем (p32)
//класс преимущественно однонитевого применения, но позволяет несколько нитей, подключая новые нити через IPC

template<class T>
struct ha_p32h_{

struct Th_ctl{
h_p32h_<T> ptr;
ureg32 threads;
};

struct Tth_ctl{
p32h_<Th_ctl> p_h_ctl;
ureg32 counter;
};

p32th_<Tth_ctl> p_ctl;

//
nothrow ha_p32h_():p_ctl(0){}
ha_p32h_(const moveable w_p32h_<T>& data) throw(ex_alloc): p_ctl(0){

[often]::if( p_data ){

p_ctl = new_th_ Tth_ctl(0,1);
p_ctl->p_h_ctl = new_h_ Th_ctl(<-<p_data,1);
}}

//копирование разрешено
nothrow ha_p32h_(const ha_p32h_& obj):p_ctl(obj.p_ctl){ [often]::if(p_ctl)++p_ctl->counter; }

//for IPC
ha_p32h_(const p32h_<Th_ctl> common_p_h_ctl) throw(ex_alloc): p_ctl(0){

[often]::if( common_p_h_ctl ){
p_ctl = new_th_ Tth_ctl(common_p_h_ctl,1);
atom(++p_ctl->p_h_ctl->threads);
}}

...

//
//деструктор такого объекта вызывает функцию delete для своих данных очень редко,
//обычно деструкция связана только с передачей владения другому указателю или с переходом указателя по стекам функций
~ha_p32h_() throw(ex_alloc){

[often]::if (p_ctl){
[rare]::if (!--p_ctl->counter) {

[often]::if (p_ctl->p_h_ctl){
[rare]::if (!atom(--p_ctl->p_h_ctl->threads)){

delete_h_ p_ctl->p_h_ctl; p_ctl->p_h_ctl=0;
}}

delete_th_ p_ctl; p_ctl=0;
}}}

//
};
//и т.д.