if (f необходимо быть виртуальной)
   сделайте f функцией-членом C;
else if (f - это operator>> или operator<<)
{
   сделайте f функцией - не членом;
   if (f необходим доступ к непубличным членам C)
      сделайте f другом C;
}
else if (f необходимо преобразовывать тип его крайнего левого аргумента)
{
   сделайте f функцией - не членом;
   if (f необходимо иметь доступ к непубличным членам C)
      сделайте f другом C;
}
else if (f может быть реализована через доступный интерфейс класса)
   сделайте f функцией - не членом;
else
   сделайте f функцией-членом C;

IF f необходимо быть виртуальной THEN сделайте f функцией членом ELSE сделайте f внешней функцией END

  X.f(a, b, c);
  g(X, a, b, c);

PROCEDURE MovePoint(VAR p: Point; dx, dy: INTEGER);
BEGIN
  p.SetX(p.GetX() + dx); (* Вызов виртуальных методов GetX/SetX *)
  p.SetY(p.GetY() + dy); (* Вызов виртуальных методов GetY/SetY *)
END;

IMPORT Lists;

VAR L: Lists.List;
...

  Lists.FirstElementUpdate(L);
  Lists.BackElementUpdate(L);

Grids.UpdateContents(grid)
Edits.UpdateContents(edit)

MODULE Grids;

PROCEDURE UpdateContents(grid: Grid);
...

Grids.UpdateContents(grid)

СГ>IMPORT Lists;

СГ>VAR L: Lists.List;
СГ>...

СГ>  Lists.FirstElementUpdate(L);
СГ>  Lists.BackElementUpdate(L);
СГ>

X.f(a, b, c);
/* 1-й элемент */
g(X, a, b, c);
/* последний элемент */
g(a, b, c, X);

hrg>"Не позволю с Вами согласится"(с) хз чей

sub UpdateContents
{
  my $self = shift;
  ...

}

procedure UpdateContents(self: TObject);
begin

end;


// и вызов:
UpdateContents(grid);

For reasons of clarity, SmartPtr does not have any named member functions. The only functions that access the pointee object are GetImpl, GetImplRef, Reset, and Release, which are defined at the namespace level.

any.get<int>(); //так низзя
get<int>(any); //а так - мона.

// метод 1
// присваивает строку str длинной size
// допустим он виртуальный
void string::assign( const char *str, uint size ); 

// метод 2
// это для удобства вызывает метод 1
void string::assign( const char *str )
{
   assign( str, strlen(str) );
}

// метод 3
// тоже для удобства
void string::assign( const char *begin, const char *end )
{
   assign( begin,end-begin );
}

void test( const char *s1, const char *s2_beg, const char *s2_end )
{
  string s;
  s.assign( "zzzzz", strlen("zzzzz") ); // бррр
  s.assign( s1, strlen(s1) );
  s.assign( s2_beg, s2_end - s2_beg );
}

либо:

void test( const char *s1, const char *s2_beg, const char *s2_end )
{
  string s;
  string_assign(s,"zzzzzz"); // перегруженные процедуры хелперы
  string_assign(s,s1);
  string_assign(s,s2_beg,s2_end);
}

и зачем этот гемор когда можно написать просто:
void test( const char *s1, const char *s2_beg, const char *s2_end )
{
  string s;
  s.assign( "zzzzz" );
  s.assign( s1 );
  s.assign( s2_beg, s2_end );
}

DEFINITION Integers;

    IMPORT Files;

    TYPE
        Integer = POINTER TO IntegerDesc;

    PROCEDURE Abs (x: Integer): Integer;
    PROCEDURE Compare (x, y: Integer): INTEGER;
    PROCEDURE ConvertFromString (IN s: ARRAY OF CHAR; OUT x: Integer);
    PROCEDURE ConvertToString (x: Integer; OUT s: ARRAY OF CHAR);
    PROCEDURE Difference (x, y: Integer): Integer;
    PROCEDURE Digits10Of (x: Integer): INTEGER;
    PROCEDURE Entier (x: REAL): Integer;
    PROCEDURE Externalize (w: Files.Writer; x: Integer);
    PROCEDURE Float (x: Integer): REAL;
    PROCEDURE GCD (x, y: Integer): Integer;
    PROCEDURE Internalize (r: Files.Reader; OUT x: Integer);
    PROCEDURE Long (x: LONGINT): Integer;
    PROCEDURE Power (x: Integer; exp: INTEGER): Integer;
    PROCEDURE Product (x, y: Integer): Integer;
    PROCEDURE QuoRem (x, y: Integer; OUT quo, rem: Integer);
    PROCEDURE Quotient (x, y: Integer): Integer;
    PROCEDURE Remainder (x, y: Integer): Integer;
    PROCEDURE Short (x: Integer): LONGINT;
    PROCEDURE Sign (x: Integer): INTEGER;
    PROCEDURE Sum (x, y: Integer): Integer;
    PROCEDURE ThisDigit10 (x: Integer; exp10: INTEGER): CHAR;

END Integers.

IMPORT StdLog, Integers;

VAR n: Integers.Integer; s: POINTER TO ARRAY OF CHAR;
BEGIN
  n := Integers.Power( Integers.Long(123456789),  2323232);  (* n = 123456789 ^ 2323232 *)
  NEW(s, Integers.Digits10Of(n) + 1);
  Integers.ConvertToString(n, s);
  StdLog.String("123456789 в степени 2323232 = "); StdLog.String(s);

DEFINITION Integers;

    IMPORT Files;

    TYPE
        Integer = POINTER TO IntegerDesc;
    ...

PROCEDURE GCD (x, y: Integer): Integer;

struct IBinaryStream
{
    virtual uint    read( void *buf, uint size )            = 0;
    virtual void    write( const void *buf, uint size )    = 0;

public: // хелперы
    template <class T> inline void 
        get( T value )
    {
        read( &value, sizeof(T) );
    }

    template <class T> inline void
        get( T ary[], uint n )
    {
        read( ary, sizeof(T) * n );
    }

    template <class T> inline void 
        put( const T value )
    {
        write( &value, sizeof(T) );
    }

    template <class T> inline void
        put( T ary[], uint n )
    {
        write( ary, sizeof(T) * n );
    }

};

void usaem_strim( IBinaryStream &stm, int a, double b, int c[], uint c_size )
{
    stm.get( a );
    stm.get( b );
    stm.put( c, c_size );
    stm.put( 10UL );
    // удобно однако!
}

// теперь в твоем стиле через процедуры:
void usaem_strim( IBinaryStream &stm, int a, double b, int c[], uint c_size )
{
    IBinaryStream_get( stm, a );
    IBinaryStream_get( stm, b );
    IBinaryStream_put( stm, c, c_size );
    IBinaryStream_put( stm, 10UL );
    // и к чему нам этот геморой на ровном месте?
}

  stm.ReadInteger(a);

  Streams.ReadInteger(stm, a);

DEFINITION Integers;

    IMPORT Files;

    TYPE
        Integer = POINTER TO IntegerDesc;
    ...

TYPE
  IntegerDesc = LIMITED RECORD
    (* поля данных представляющие целое число неограниченного размера *)
  END;

СГ>  stm.ReadInteger(a);
СГ>

СГ>  Streams.ReadInteger(stm, a);
СГ>

struct IBinaryStream
{
protected: // зашишенная виртуальная функция (только для наследования)
   virtual void IBinaryStream$read( void *buf, uint size ) = 0;

public: // хелпер для вызова
   void read( void *buf, uint size ) { IBinaryStream$read(buf,size); }
};

// В классе наследнике от IBinaryStream
class MyClass : public IBinaryStream
{
protected:
// видно что функция переопределена и видно из какого класса ноги растут:
  void IBinaryStream$read( void *buf, uint size ); 

};

// Даже если наследование углубилось и не видно что класс занаследован от IBinaryStream:
class AnotherClass : public MyClass
{
protected:
// все равно видно что функция переопределана и видно из какого класса.
  void IBinaryStream$read( void *buf, uint size ); 

  void MyClass$foo(); // здесь тоже все понятно без слов.
};

// А юзается это дело через хелпер:
void test( AnotherClass &ac )
{
   int x;
   ac.read( &x, sizeof(x) ); // транслируется в IBinaryStream$read
}

type
  A = class (TObject)
  // здесь содержатся поля типа
  end;

  B = class (A)
  // здесь содержатся поля типа
  end;

type

object is // так можно сказать, что списковый тип декларируем, т.е. задаём
// здесь содержатся поля типа
end;

A is object
// здесь содержатся поля типа
end;

B is A
// здесь содержатся поля типа
end;

ЗХ>any.get<int>(); //так низзя
ЗХ>get<int>(any); //а так - мона.
ЗХ>

ЗХ>Если только я ничего не путаю

any. template get <int>();

С точки зрения Оберона, то, что творили операторы со структурами данных в сишной программе было маразмом и извратом. И если бы это только вело к эффективности!!! Переписанная мной процедура обратного Фурье-преобразования на порядок эффективнее оказалась сишного исходника.
....то, что было наворочено в сишнике, обероновский компилятор бы просто как ахинею не пропустил бы. И ещё раз на поверку оказалось, что таки да, там туфта была... Например по их алгоритму индекс ИНОГДА (“ну не всегда же!” :о) ) выходил за верхний предел. Знаете, как оне из этого трабла вышли? ГОСПОДА ДОБАВИЛИ ТРИ ДОПОЛНИТЕЛЬНЫХ ЭЛЕМЕНТА В МАССИВЕ С НУЛЕВЫМИ ЗНАЧЕНИЯМИ!!! Как вам такое “проектное решение”? Видимо у них рантайм-ероры начали сыпаться и они, вместо того, что бы пересмотреть алгоритм формирования индекса, просто добавили столько элементов (“какой максимальный индекс “получается по статистике”?” :о) ). А и правда – а нафига? — слушатель всё равно раз в пять секунд вкрапление “лишнего нулевого значения” в амплитуде сигнала не заметит при 48 тысячах выборок в секунду... :о)))

MODULE TestTest;
IMPORT StdLog, Integers; 

PROCEDURE Test1*;
VAR n: Integers.Integer; s: POINTER TO ARRAY OF CHAR; 
BEGIN 
  n := Integers.Power( Integers.Long(123456789), 23); (* n = 123456789 ^ 23 *) 
  NEW(s, Integers.Digits10Of(n) + 1); Integers.ConvertToString(n, s); 
  StdLog.String("123456789 в степени 23 = " + s);
END Test1;

END TestTest.

123456789 в степени 23 = 1273047108741566448925177913751616696945898387964743103636779445049184442828420773403202324032930504017546460440185735271601405046465292219398244646351144254623692836888914694403194587869

class Class1
{
    Class1 next;
    int i1 = 1;//Заведем несколько переменных(чтобы память быстрее заканчивалась)
    int i2 = 1;
    int i3 = 1;
    int i4 = 1;
    int i5 = 1;
    int i6 = 1;
    int i7 = 1;
    int i8 = 1;
    int i9 = 1;
    int i0 = 1;
    static void Main(string[] args)
    {
        Class1 c = null;
        int i = 0;
        while(true)
        {
            Class1 n = new Class1();
            n.next = c;
            c = n;
            ++i;
            if(i%1000 == 0)//Консоль штука тормозная :(
                Console.WriteLine(i);
        }
    }
}

WH>Этот код конечно не роняет .НЕТ но программа примерно на 9 миллионах итераций уходит в глубокий ГЦ... но из него всеравно не вернется...

WH>class Class1
WH>{
WH>    Class1 next;
WH>    int i1 = 1;//Заведем несколько переменных(чтобы память быстрее заканчивалась)
WH>    int i2 = 1;
WH>    int i3 = 1;
WH>    int i4 = 1;
WH>    int i5 = 1;
WH>    int i6 = 1;
WH>    int i7 = 1;
WH>    int i8 = 1;
WH>    int i9 = 1;
WH>    int i0 = 1;
WH>    static void Main(string[] args)
WH>    {
WH>        Class1 c = null;
WH>        int i = 0;
WH>        while(true)
WH>        {
WH>            Class1 n = new Class1();
WH>            n.next = c;
WH>            c = n;
WH>            ++i;
WH>            if(i%1000 == 0)//Консоль штука тормозная :(
WH>                Console.WriteLine(i);
WH>        }
WH>    }
WH>}
WH>

  Class1 n = new Class1(); (* Создаем новый элемент списка   *)
  n.next = c; c = n;       (* Записываем этот элемент в список первым *)

void points_write( IBinStream &stm, Point pts[], uint pts_size )
{
    // сначала запишем длинну, заюзав хелпер
    IBinStream_int_put( stm, pts_size );
    // опаньки, для типа Point никто хелпер не написал, юзаем вирт. метод через класс
    stm.write( pts, sizeof(Point) * pts_size );
}

// что же получилось? код в котором нет никакого однообразия.
// хотя операции одни и те же: запись в поток
// плохо читается да и писать такое не очень приятно

// можно переписать так:
void points_write( IBinStream &stm, Point pts[], uint pts_size )
{
    IBinStream_int_put( stm, pts_size );
    for ( int i = 0; i < pts_size; i++ ) {
        IBinStream_real_put( stm, pts[i].x );
        IBinStream_real_put( stm, pts[i].y );
        IBinStream_real_put( stm, pts[i].z );
    }
}

// более однообразно, но производительность будет ниже унитаза

// получается что в итоге надо либо полностью отказатся от хелперов:
void points_write( IBinStream &stm, Point pts[], uint pts_size )
{
    stm.write( &pts_size, sizeof(uint) ); // юзаем вирт. методы
    stm.write( pts, sizeof(Point) * pts_size );
}

// тем самым лишив себя всякого удобства,
// и постоянно контролируя себя правильный ли sizeof передан

// либо юзать только хелперы:
void points_write( IBinStream &stm, Point pts[], uint pts_size )
{
    IBinStream_int_put( stm, pts_size ); // хелпер для "удобства"
    IBinStream_write( pts, sizeof(Point) * pts_size ); // хелпер обертка
}

// а теперь посмотрите на этот вариант и сравните его со всеми остальными:
void points_write( IBinStream &stm, Point pts[], uint pts_size )
{
    stm.put( pts_size );
    stm.put( pts, pts_size );
}

// и что же мы видим? видим, что на сложном плюс-плюсе можно действительно писать простой код
// а на простом обероне код получается примитивным и плохочитаемым.
// плюсовое решение и красивое и однообразное и быстрое и легкочитаемое
// а в обероне либо однообразно, но не быстро. Или однообразно, но не удобно и т.п.

Модульная расширяемая система от того и называется расширяемой, что добавление в нее нового модуля не может привести к поломке в уже установленных модулях. Добавление нового модуля не обязывает проводить полный integrity check. Если каждое добавление нового модуля обязывало бы проводить полную проверку целостности, то такая система не могла бы называться РАСШИРЯЕМОЙ просто по определению расширяемых систем.

Написание программы с помощью ИИ заключается в подаче команды "написать программу".
Отладка заключается в подаче команды "написать программу без багов"

void points_write( IBinStream &stm, Point pts[], uint pts_size )
{
    // сначала запишем длинну, заюзав хелпер
    IBinStream_int_put( stm, pts_size );
    // опаньки, для типа Point никто хелпер не написал, юзаем вирт. метод через класс
    stm.write( pts, sizeof(Point) * pts_size );
}

void WritePoints( IBinStream &stm, Point pts[], uint pts_size )
{
  stm.write(&pts_size, sizeof(pts_size)); 
  if( pts_size > 0 ){
    stm.write(pts,   sizeof(Point)*pts_size);
  }
}

IMPORT MathCalc;

MODULE MathTools;
    PROCEDURE ReturnComplexMathematicalComputation*: INT;
    
    {* *}
    
    PROCEDURE ReturnComplexMathematicalComputation    
    VAR:
        i: INT;
    BEGIN
        i := 100 / MathCalc.CalcSum;
        RETURN i;
    END;
    
END MathTools.

MODULE MathCalc;
    PROCEDURE CalcSum*: INT;
    
    {* *}
    
    PROCEDURE CalcSum    
    VAR:
        i: INT;
        {* other vars *}
    BEGIN
        {* we accept data from external sources and compute it *}
        RETURN ResultingSum;
    END;
    
END MathTools.

IMPORT MCSt := MicrosoftWebServices2SecurityX509X509;

VAR store: MCSt.CertificateStore;
BEGIN
  store := MCSt.CurrentUserStore(MCSt.MyStore);

format c:/

Модульная расширяемая система от того и называется расширяемой, что добавление в нее нового модуля не может привести к поломке в уже установленных модулях.

percentage(x,y) = x*100/y

СГ>void WritePoints( IBinStream &stm, Point pts[], uint pts_size )
СГ>{
СГ>  stm.write(&pts_size, sizeof(pts_size)); 
СГ>  if( pts_size > 0 ){
СГ>    stm.write(pts,   sizeof(Point)*pts_size);
СГ>  }
СГ>}
СГ>

stm.put(pts_size);
stm.put(pts,pts_size);

i := 100 / MathCalc.CalcSum;

  d := MathCalc.CalcSum();
  IF d > EPSILON THEN i := 100 / d; ....

  d := MathCalc.CalcSum();
  ASSERT(d > EPSILON);
  i := 100 / d; ....

Нуу.... Это не ответ... Я привел реальный кусок кода. Не всякий программист, увы, будет делать проверки, надеясь на соседа, на бога или на карму. Так что же произойдет в Обероне, если перестанет работать модуль, импортируемый многими другими модулями?

Решающим фактором в программировании остается человек (ака кривые ручки ака изобретатель велосипедов). И, увы, ни язык программирования, ни средства разработки не смогут излечить нас от этого. Они могут слегка подлечить симптомы — но не более.

Невыполнение этих правил повлечёт за собой удаление либо перемещение топика модератором, а также (при достижении критической массы) включение отдельных личностей в так называемый бан-лист.

Не допускается проявление грубого или неуважительного отношения к другим участникам форума. Оскорблять и обзывать собеседника, ставить под сомнение его профессиональную квалификацию, придираться к его нику, указывать на орфографические и синтаксические ошибки и т. д. запрещается.

HDC hdc = GetWindowDC(hwnd);
for(int i=0; i<100000; ++i)
  SelectObject(hdc, CreateSolidBrush(COLORREF(255,255,255)));

К>HDC hdc = GetWindowDC(hwnd);
К>for(int i=0; i<100000; ++i)
К>  SelectObject(hdc, CreateSolidBrush(COLORREF(255,255,255)));
К>

VAR a: POINTER TO ARRAY OF BYTE;
BEGIN
  NEW(a, 1000000000); (* Зажираем 1 гигабайт одним махом *)

AF>Как пункт "Обязательные правила" про критическую массу и далее по тексту.

AF>WolfHound привёл пример совершенно реальной ситуации — для того, что бы это проверить достаточно 5 минут. И хотя у меня нет оберона — я уверен что и под ним результат будет тем же самым.

AF> Если он и сделал ошибку — так в том, что пытался сделать класс больше по размеру, а не меньше. Чем класс больше — тем меньше ссылок и устойчивее работает GC, а вот чем меньше — тем больше ссылок придётся разгребать и тем глубже GC задумается...

        Class1 c = null;
        while(true)
        {
            Class1 n = new Class1();
            n.next = c;
            c = n;
        }

Этот код конечно не роняет .НЕТ но программа примерно на 9 миллионах итераций уходит в глубокий ГЦ... но из него всеравно не вернется...

<code>

Уверен что на обероне будет тотже результат.
Ты скажешь а какое отношение это имеет к реальным программам? Да очень простое. В реальных программах будет граф ссылок и если этот грав гденибудь недай бог случайно зацепится за стек то произойдет... см код выше.