void utilize(int* x)
{
  cout << *x << endl;
  delete x;
}

int main()
{
  utilize(new int(7));
  int i = 3;
  utilize(&i);
}

template<class T>
class pointer
{
  T* ptr;
public:
  pointer() : ptr(NULL) {}
  pointer(T* p) : ptr(p) {} // не explicit

  T& operator*() const { return *ptr; }
  T* operator->() const { return ptr; }

  operator pointer<const T>() const { return pointer<const T>(ptr); }
};

template<class T>
class dyn_object : public pointer<T>
{
public:
  dyn_object() {}

private:
  explicit dyn_object(T* p) : pointer(p) {}

  T* get() const { return ptr; }
  friend struct dyn_object_helper;
};

struct dyn_object_helper
{
  template<class T>
  dyn_object<T> do_new() { return dyn_object<T>(new T()); }

  template<class T, class U>
  dyn_object<T> do_new(U u) { return dyn_object<T>(new T(u)); }

  template<class T>
  void do_delete(dyn_object<T> obj) { delete obj.get(); }
};

template<class T>
dyn_object<T> do_new() { return dyn_object_helper::do_new<T>(); }

template<class T, class U>
dyn_object<T> do_new(U u) { return dyn_object_helper::do_new<T>(u); }

template<class T>
void do_delete(dyn_object<T> obj) { dyn_object_helper::do_delete(obj); }


///////////////

void utilize_right(dyn_object<int> obj)
{
  cout << *obj << endl;
  do_delete(obj);
}
void utilize_wrong(pointer<int> ptr)
{
  cout << *ptr << endl;
  do_delete(ptr); // ошибка компиляции
}
void utilize_weak(pointer<int> ptr)
{
  cout << *ptr << endl;
}

int main()
{
  utilize_right(do_new<int>(7));
  utilize_right(new int(7)); // ошибка: нефиг пользоваться голыми указателями

  int i=3;
  utilize_right(&i); // ошибка: откуда я знаю, какой смысл у голого указателя
  utilize_right(pointer<int>(&i)); // ошибка: нехватка полномочий
  utilize_right(dyn_object<int>(&i)); // и опять ошибка: ну нельзя пользоваться голыми указателями!!!

  utilize_weak(new int(7)); // глупо конечно, утечка будет... но это уже нюансы.
  dyn_object<int> obj = do_new<int>(7);
  utilize_weak(obj);
  utilize_weak(&i); // приведение голого указателя к pointer - не криминал (хотя, можно запретить от греха подальше)
}

TYPE Data = POINTER TO RECORD x: Integer; END;

PROCETUDE touch(VAR p: Data);
BEGIN
  p := NEW Data;
END;

PROCEDURE utilize(VAR p: Data); (* здесь - заявлены неправильные полномочия *)
BEGIN
  Write(p);
  touch(p); (* а с виду и не поймёшь, что переменную изменили... *)
  p.x := 3;
END;

PROCEDURE main();
VAR i,j : POINTER TO Integer;
BEGIN
  i := NEW Data; i.x := 7;
  j := i; (* два указателя на один объект *)
  utilize(j);
  if(i.x <> j.x) Write('приплыли');
END;

К>TYPE Data = POINTER TO RECORD x: Integer; END;

К>PROCETUDE touch(VAR p: Data);
К>BEGIN
К>  p := NEW Data;
К>END;

К>PROCEDURE utilize(VAR p: Data); (* здесь - заявлены неправильные полномочия *)
К>BEGIN
К>  Write(p);
К>  touch(p); (* а с виду и не поймёшь, что переменную изменили... *)
К>  p.x := 3;
К>END;

К>PROCEDURE main();
К>VAR i,j : POINTER TO Integer;
К>BEGIN
К>  i := NEW Data; i.x := 7;
К>  j := i; (* два указателя на один объект *)
К>  utilize(j);
К>  if(i.x <> j.x) Write('приплыли');
К>END;
К>

2.4 WITH and guarded variables
It is possible to alter a guarded pointer variable within the scope of a guarding WITH
statement, example:
TYPE
T = RECORD END; P = POINTER TO T;
T1 = RECORD (T) END; P1 = POINTER TO T1;
T2 = RECORD (T) END; P2 = POINTER TO T2;
PROCEDURE X;
VAR p: P; p1: P1; p2: P2;
PROCEDURE Y;
BEGIN
The Oakwood Guidelines for Oberon-2 Compiler DevelopersOctober 20, 1995 10
p := p2
END Y;
BEGIN
NEW (p); NEW(p1); NEW(p2); p := p1;
WITH p: P1 DO
Y (*p is now of type P2 and not P1*)
END
END X;
A practical way to handle this is :
If the compiler can be sure it is safe then give no warning message. If there can be any
doubt then do give a warning message. A sophisticated compiler could automatically
insert the additional relevant type guard checks.

AVC>>А куда, собственно, приплыли?

typedef struct { int x; } *Data;
void main()
{
    Data *p, *q;
    p = malloc(sizeof *p);
    p->x = 7;
    q = p; /* два указателя на один объект */
    q = malloc(sizeof *q); /* уже нет */
    q->x = 3;
    if (p->x != q->x)
        printf("приехали"); /* здесь Вы кричите "пожар!" А в чем собственно дело? */
}

Data *p, *q;

Data p, q;

AVC>>>Я так и не понял, в чем именно ошибка.

AVC>Я и сейчас не вижу ошибки.

const double PI = exp(1.0);

AVC>Предлагаю сделать так. Вы пишете правильный вариант. (Можно на Си++. Я прощу. )

AVC>А я таким путем проникну в суть вещей.

AVC>>>Я вообще не вижу ошибки. (Код, конечно, странный. Но ведь неизвестно, для чего он.)

AVC>Я что-то не понимаю.

TYPE Foo = POINTER TO RECORD x:Integer; END;
     Bar = POINTER TO RECORD f:Foo;     END;

PROCEDURE deface(b:Bar); (* казалось бы, константа... *)
BEGIN
  b.f := NEW Foo; (* но объект поменять - как нефиг делать *)
  b.f.x := 456;
END;

PROCEDURE main();
VAR a,b:Foo;
    c:Bar;
BEGIN
  a := NEW Foo;
  a.x := 123;
  c := NEW Bar;
  c.f := a;
  deface(c);
  b := c.f;
  if(a.x <> b.x) Write("приплыли");
END;

template<class T>
class constable_pointer
{
  T* ptr;
public:
  /* тут всякие конструкторы, присваивания и т.п. */

  T       * operator->()       { return ptr; }
  T const * operator->() const { return ptr; }

  T       & operator*()       { return *ptr; }
  T const & operator*() const { return *ptr; }

  operator T       * () const { return ptr; }
  operator T const * () const { return ptr; }
};

struct Foo { int x; };

struct Bar1 { Foo* f; }; // добрый указатель
struct Bar2 { constable_pointer<Foo> f; }; // злой указатель

void deface(const Bar1& b1, const Bar2& b2)
{
  b1.f->x = 456;
  b2.f->x = 456; // ошибочка вышла!
}

      TProba = class
   I:Integer;
   Procedure ConstMethod(Const A:Tproba);
   Procedure NotConstMethod(Const A:Tproba); 
  end;
    
    procedure TForm1.Button1Click(Sender: TObject);
var A: Tproba;
begin
    A:=TProba.Create;
    A.ConstMethod(a);
end;

{ TProba }

procedure TProba.ConstMethod(const A: Tproba);
begin
 A:=TProba.Create; // не прокатывает
 A.I:=3; // прокатывает
 NotConstMethod(A); // прокатывает 
end;

procedure TProba.NotConstMethod(const A: Tproba);
begin
 A.I:=3;
end;

AVC>>Я что-то не понимаю.

К>TYPE Foo = POINTER TO RECORD x:Integer; END;
К>     Bar = POINTER TO RECORD f:Foo;     END;

К>PROCEDURE deface(b:Bar); (* казалось бы, константа... *)
К>BEGIN
К>  b.f := NEW Foo; (* но объект поменять - как нефиг делать *)
К>  b.f.x := 456;
К>END;

К>PROCEDURE main();
К>VAR a,b:Foo;
К>    c:Bar;
К>BEGIN
К>  a := NEW Foo;
К>  a.x := 123;
К>  c := NEW Bar;
К>  c.f := a;
К>  deface(c);
К>  b := c.f;
К>  if(a.x <> b.x) Write("приплыли");
К>END;
К>

<*+MAIN*>
<*+O2EXTENSIONS*> (* разрешаю использовать (в частности) readonly параметры *)
MODULE O2Ext;

IMPORT Out;

TYPE
    IPtr = POINTER TO RECORD x: INTEGER END;
    PPtr = POINTER TO PRec;
    PRec = RECORD p: IPtr END;
    
VAR
    p: IPtr;
    q: PPtr;

PROCEDURE test(q-: PRec);
VAR p: IPtr;
BEGIN
    NEW(p); p.x := 2;
    q.p := p; (* эту строку не пропускает компилятор *)
END test;
    
BEGIN
    NEW(p); p.x := 1;
    NEW(q); q.p := p;
    test(q^);
    IF q.p.x # p.x THEN Out.String("Oops!"); END;
END O2Ext.

<*+MAIN*>
MODULE O2Ext;

IMPORT Out;

TYPE
    IPtr = POINTER TO RECORD x: INTEGER END;
    PPtr = POINTER TO PRec;
    PRec = RECORD p: IPtr END;
    
VAR
    p: IPtr;
    q: PPtr;

PROCEDURE test(q: PRec);
VAR p: IPtr;
BEGIN
    NEW(p); p.x := 2;
    q.p := p;
END test;
    
BEGIN
    NEW(p); p.x := 1;
    NEW(q); q.p := p;
    test(q^);
    IF q.p.x # p.x THEN
        Out.String("Oops!");
    ELSE
        Out.String("Oberon forever!");
    END;
END O2Ext.