class Object
{
virtual ~Object()
{
}
};

var
  a: A;
  p: Pointer;

SS>var
SS>  a: A;
SS>  p: Pointer;
SS>

type
  AAAA=class
  end;
...
var
  a: AAAA;
  p: Pointer;
begin
  a := p;
  p := a;
....
end;

var
  m: TButton;
begin
  FreeAndNil(m); // error: types of actual and formal var parameters must be identical
end

SS>var
SS>  m: TButton;
SS>begin
SS>  FreeAndNil(m); // error: types of actual and formal var parameters must be identical
SS>end
SS>

m.free?

class A
{
...
};

void* p;
A* a;
...

{
  p = reinterpret_cast<void*>(a);
  a = reinterpret_cast<A*>(p); //Чувсвуете силу - такое писать не сильно хочется, а надо.
}

type
  AAAA=class
  end;
  ...
  var
    a: AAAA;
    p: Pointer;
  begin
    a := p;
    p := a;
  end;

C++                 Delphi
(T)v                   T(v)
static_cast<T>(v)      T(v)
reinterpret_cast<T>(v) T(v)
const_cast<T>(v)       T(v)
dynamic_cast<T>(v)     v as T

SS>>var
SS>>  m: TButton;
SS>>begin
SS>>  FreeAndNil(m); // error: types of actual and formal var parameters must be identical
SS>>end
SS>>

V>m.free?
V>

var
  m: TFileStream;
begin
  m = TFileStream.Create(fname, fmCreate); // create and lock file
  try
    WriteFile(m);
    FreeAndNil(m); // release file here
    UseFile(fname);
  finally
    m.Free();
  end;
end;

m.Free(); 
m = nil;

var
  m: TFileStream;
  ..
begin
  m = TFileStream.Create(fname, fmCreate); // create and lock file
  try
    WriteFile(m);
  finally
    m.free;
  end;
  m = TFileStream.Create(fname, fmCreate); // create and lock file
  try
    UseFile(m);
  finally
    m.free;
  end;
end;

var
  p: Pointer;
  m: TButton;
begin
  m := p;
end;

char t[10];
printf("%d",t);

{$WARNINGS OFF}//обяснения, почему здесь. обычно это TODO.
//Палённая строка
{$WARNINGS ON}

V>В делфе можно перегужать операторы? Или это фича только для комплексных? Если последнее — мне это не представляет никакой ценности, ибо комплексные числа не нужны (мне, пока что

type
  TComplex = packed record
  strict private
    procedure Defuzz;
  private
    class procedure Init; static;
  public
    var
      Real, Imaginary: Double;
    class var
      Symbol: string;                 // defaults to 'i'
      SymbolBeforeImaginary: Boolean; // defaults to false
      DefuzzAtZero: Boolean;          // defaults to true
    class operator Round(const AValue: TComplex): Int64;
    class operator Trunc(const AValue: TComplex): Int64;
    class operator Equal(const Left, Right: TComplex): Boolean;
    class operator NotEqual(const Left, Right: TComplex): Boolean;
    class operator LessThan(const Left, Right: TComplex): Boolean;
    class operator LessThanOrEqual(const Left, Right: TComplex): Boolean;
    class operator GreaterThan(const Left, Right: TComplex): Boolean;
    class operator GreaterThanOrEqual(const Left, Right: TComplex): Boolean;
    class operator Add(const Left, Right: TComplex): TComplex;
    class operator Subtract(const Left, Right: TComplex): TComplex;
    class operator Multiply(const Left, Right: TComplex): TComplex;
    class operator Divide(const Left, Right: TComplex): TComplex;
    class operator Negative(const AValue: TComplex): TComplex;

    // Note: currently Implicit operators work like Explicit operators in Win32,
    // i.e. they need an explicit type-cast
    class operator Implicit(const AValue: Double): TComplex;
    class operator Implicit(const AValue: Integer): TComplex;
    class operator Implicit(const AValue: Int64): TComplex;
    class operator Implicit(const AValue: Variant): TComplex;
    class operator Explicit(const AValue: TComplex): Double;
    class operator Explicit(const AValue: TComplex): Integer;
    class operator Explicit(const AValue: TComplex): Int64;
  end;

class function TComplex.From(const AReal, AImaginary: Double): TComplex;
begin
  Result.Real := AReal;
  Result.Imaginary := AImaginary;
  if DefuzzAtZero then
    Result.Defuzz;
end;

class operator TComplex.Add(const Left, Right: TComplex): TComplex;
begin
  Result := From(Left.Real + Right.Real, Left.Imaginary + Right.Imaginary);
end;

class operator TComplex.Subtract(const Left, Right: TComplex): TComplex;
begin
  Result := From(Left.Real - Right.Real, Left.Imaginary - Right.Imaginary);
end;

class operator TComplex.Multiply(const Left, Right: TComplex): TComplex;
begin
  Result := From((Left.Real * Right.Real) - (Left.Imaginary * Right.Imaginary),
                 (Left.Real * Right.Imaginary) + (Left.Imaginary * Right.Real));
end;

begin
  myFavoriteObject := TMyFavoriteObject.Create(args);
  try
    .....
  finally
    myFavoriteObject.free;  
  end;

OV>>>ЗЫ. Отвечать самому себе — прикольно!

V>>Это да, редактировать я не научился .

 
  type
    TMyClass=class
    private: 
      //private members
    public
      class operator add(left, right: TMyClass) : TMyClass;
    end
..
class operator TMyClass.add(left, right: TMyClass) : TMyClass;
begin 
  Result := TMyClass.Create; //ВАЖНО
end;

//и теперь где то в коде имеем

var
  a, b, c, d: TMyClass;
...
begin
  ...
  a := b + c + d; //Имеем лик, ах да, вы можете посоветовать вкрутить костыль с подсчетом ссылк  :)))  :))) Ню ню, а травка действительно хороша
  ...
end;

V>>Дадут возможность для рекорда обьявлять член-функции? Дадут модификаторы прав private/public/protected — вообще старнный и не понятный для меня? И тогда будет Селфи++ ?

V>>Я в восторге. Или они предложат рядом с рекордами делать свободные функции, которые на вход будут принимать первым параметром указатель на рекорд? . Мдя. Смешно.

 
V>  type
V>    TMyClass=class
V>    private: 
V>      //private members
V>    public
V>      class operator add(left, right: TMyClass) : TMyClass;
V>    end
V>..
V>class operator TMyClass.add(left, right: TMyClass) : TMyClass;
V>begin 
V>  Result := TMyClass.Create; //ВАЖНО
V>end;

V>//и теперь где то в коде имеем

V>var
V>  a, b, c, d: TMyClass;
V>...
V>begin
V>  ...
V>  a := b + c + d; //Имеем лик, ах да, вы можете посоветовать вкрутить костыль с подсчетом ссылк  :)))  :))) Ню ню, а травка действительно хороша
V>  ...
V>end;

V>

class operator TMyClass.add(right: TMyClass) : TMyClass;
begin 
  Result := TMyClass.Create; //ВАЖНО? Уже не надо
end;

V>>>Дадут возможность для рекорда обьявлять член-функции? Дадут модификаторы прав private/public/protected — вообще старнный и не понятный для меня? И тогда будет Селфи++ ?

V>>>>Дадут возможность для рекорда обьявлять член-функции? Дадут модификаторы прав private/public/protected — вообще старнный и не понятный для меня? И тогда будет Селфи++ ?

struct T
{
    int A, B;
private:
    int C;
};

procedure FreeAndNil(var Obj);
var
  Temp: TObject;
begin
  Temp := TObject(Obj);
  Pointer(Obj) := nil;
  Temp.Free;
end;

procedure FreeAndNil(var Obj: TObject);
var
  Temp: TObject;
begin
  Temp := Obj;
  Obj := nil;
  Temp.Free;
end;

type
  MyInt = type integer;

А>type
А>  MyInt = type integer;
А>

type
  MyInt = type integer;

procedure some(i: MyInt);
begin
end;

procedure some2;
var
  index: Integer;
  ii: MyInt;
begin
  ii := 0;
  index := 0;
  index := ii;
  some(index);
end;