type TPerversiveObject = class
private
  FA, FB: integer;
public
  property A: integer write FA read FB;
    property B: integer write FB read FA;
end;

type TPoint = class
private
  FX, FY: extended;
public
  property X: extended read FX write FX;
    property Y: extended read FY write FY;
    property R: extended read GetR write SetR; // имеется в виду R = sqrt(x*x+y*y)
    property Alpha: extended read GetAlpha write SetAlpha // полярный угол

Если быть более точным, то Delphi предоставляет возможность динамически определять базис при помощи ключевого слова stored. Кроме того, поверх базовых возможностей языка реализован механизм "псевдосвойств", но они определяются исключительно процедурным способом, в отличие от декларативных published/stored.

template <class T>
class CTemplateClass
{
  T member;
}
class CSon1 : public CTemplateClass<class1>
{
}
class CSon2 : public CTemplateClass<class2>

J>А зачем нам MS

M>var Excel : Variant;

M>begin
M>  Excel := CreateOleObject('Excel.Application');
M>  Excel.OpenFile('sdfsdfsdfsd.xls');
M>  Excel.Range("A1").Value=294;
M>end.
M>

ExcelWrapper excel(CREATE_BY_NAME); // Предположим, что CREATE_BY_NAME - константа,
                                    //определяющая способ создания объекта Excel.Application,
                                    // альтеннативой может быть передача конструктору GUID-а объекта.
excel.OpenFile("tra-la-la.xls");
excel.Range("A1") = 294; // Вот здесь избавимся от '.Value' за счёт перекрытия оператора присвоения значения

unit FLDUnit;
  {$R-,T-,X+,H+,B-}
interface
 Uses SysUtils;
 Type
   TFld = Class(TObject)
   Len,Offset:Cardinal;
   protected
   Procedure SetCompValue(Const p:Pointer); virtual; abstract;
   Function GetAsString(Const p:Pointer):string; virtual; abstract;
   Procedure SetAsString(Const p:Pointer; Const Value:String); virtual; abstract;

   Public
   Procedure Swap(Const p1,p2:Pointer); virtual; abstract; // для любителей оптимизации на Asm
   Function CompareFlds(Const p1,p2:Pointer):Integer; virtual; abstract;
   Function CompareFldWithCompValue(Const p:Pointer):Integer; virtual; abstract;

   Procedure SetValue(Const p,buffer:Pointer); virtual; abstract;
   Procedure GetValue(Const p,buffer:Pointer); virtual; abstract;

   Property  CompValue:Pointer write SetCompValue;
   Property AsString[Const P:Pointer]:String Read GetAsString write SetAsString;

    Constructor Create; Virtual;
   end;

   TFldClass = class of TFld;

   TFldArray =  Array of TFld;

   TMultiFlds = Class(TFld)
      PointerOfCompValue:Pointer;
      Fields  : TFldArray;
      CompFlds: TFldArray;
      HiCompIndex:Cardinal;
     Public
   Function CompareFlds(Const p1,p2:Pointer):Integer; Override;
   Function CompareFldWithCompValue(Const p:Pointer):Integer; override;
   Procedure SetCompValue(Const p:Pointer);Override;
   Procedure SetFldValue(Const i:Cardinal; Const p,buffer:Pointer);
   Procedure GetFldValue(Const i:Cardinal; Const p,buffer:Pointer);
   Procedure SetCompareFields(CmpFld:array of TFLD);
   Constructor Create; override;
   Constructor CreateFromFldClass(Flds: array of TFldClass); Virtual;
   Constructor CreateFromFlds(Flds: array of TFld);Virtual;
   destructor Destroy; override;
   end;

   implementation

{ TMultiFlds }

function TMultiFlds.CompareFlds(const p1, p2: Pointer): Integer;
 Var I:Integer;
 Fld:Tfld;
begin
    For i:=0 To HiCompIndex Do
      Begin
       Fld:=CompFlds[i];
       result:=Fld.CompareFlds(Pointer(Cardinal(p1)+Fld.Offset),Pointer(Cardinal(p2)+Fld.Offset));
        If Result<>0 Then
         Break
       end;

end;

function TMultiFlds.CompareFldWithCompValue(const p: Pointer): Integer;
 Var I:Integer;
     Fld:Tfld;
begin

    For i:=0 To HiCompIndex Do
      Begin
       Fld:=CompFlds[i];
       result:=Fld.CompareFldWithCompValue(Pointer(Cardinal(p)+Fld.Offset));
        If Result<>0 Then
         Break
        end;

end;


constructor TMultiFlds.Create;
begin

 Inherited Create;
end;

constructor TMultiFlds.CreateFromFldClass(Flds: array of TFldClass);
 Var i:Integer;
begin
    inherited Create;
    SetLength(self.Fields,Length(Flds));

        len:=0;
      For i:=0 to  Length(Flds)-1 do
        Begin
        Fields[i]:=Flds[i].Create;
        Fields[i].Offset:=len;
        Inc(len,Fields[i].Len);
        end;



end;

constructor TMultiFlds.CreateFromFlds(Flds: array of TFld);
 Var i:Integer;
begin
    inherited Create;
    SetLength(self.Fields,Length(Flds));
        len:=0;
      For i:=0 to  Length(Flds)-1 do
        Begin
        Fields[i]:=Flds[i];
        Fields[i].Offset:=len;
        Inc(len,Flds[i].Len);
        end;

end;

destructor TMultiFlds.Destroy;
 Var i:Integer;
begin
    For i:=0 To Length(Fields)-1 Do
        Fields[i].Free;
  inherited;
end;



procedure TMultiFlds.GetFldValue(const i: Cardinal; const p,
  buffer: Pointer);
begin
   Fields[i].GetValue(p,buffer);
end;




procedure TMultiFlds.SetCompareFields(CmpFld: array of TFLD);
 Var i:integer;
begin
  HiCompIndex:=Length(CmpFld);
  SetLength(CompFlds,HiCompIndex);
  Dec(HiCompIndex);
 For i:=0 to HiCompIndex Do
    CompFlds[i]:=CmpFld[i];


end;

procedure TMultiFlds.SetCompValue(const p: Pointer);
 Var i:Integer;
     Fld:Tfld;
begin
   For i:=0 To Self.HiCompIndex Do
    Begin
       Fld:=CompFlds[i];
       Fld.CompValue:=Pointer(Cardinal(p)+Fld.Offset);
    end;
end;

procedure TMultiFlds.SetFldValue(const i: Cardinal; const p,
  buffer: Pointer);
begin
 Fields[i].SetValue(p,buffer);
end;
end;

    Procedure SortArrayFld(Var a;Fld:TFld);
     Var
         BeginArray,len:Cardinal;
 procedure QuickSort(L, R: Integer);
var
  I, J: Integer;
begin


    I :=L;
    J :=R;
     Fld.CompValue:=Pointer( L+(( ((r-l) div len) shr 1)*len));

    repeat
      while Fld.CompareFldWithCompValue(Pointer(I)) < 0 do
        Inc(I,Len);
      while Fld.CompareFldWithCompValue(Pointer(J)) > 0 do
        Dec(J,len);
      if I <= J then
      begin

      //Fld.Swap(Pointer(I),Pointer(J));
      Q_SwapMem(Pointer(i),Pointer(j), Len);

        Inc(I,Len);
        Dec(J,Len);
      end;
    until I > J;

    if L < J then
      QuickSort(L,J);
     if R>I then
     QuickSort(I,R);

end;

     Begin
      Len:=fld.Len;
      BeginArray:=PCardinal(@a)^;
            QuickSort(BeginArray,BeginArray+(PCardinal(BeginArray-4)^-1)*len);
     End;

    dynamic_cmp_t<test> cmp;
    cmp.reset()
        (&test::f1)
        (&test::i2)
        (&test::i1)
    ;
    std::sort(test_arr, test_arr+100, cmp.less());
    cmp.reset()
        (&test::i1)
        (&test::i2)
        (&test::f1)
    ;
    std::sort(test_arr, test_arr+100, cmp.greater());
    cmp.reset();
    if(some1)cmp(&test::i1);
    if(some2)cmp(&test::i2);
    if(some3)cmp(&test::f1);
    std::sort(test_arr, test_arr+100, cmp.less());

A>Не нравится, значит, как я код изложил. Так моей целью была не оптимизация, а демонстрация. Давай так.

A>var
A>    C: TCollection;
A>    Item: TMyItem;
A>begin
A>    C := TCollection.Create(TMyItem);

procedure some
var
  ptr:SomeAbstractClass
begin
  ptr:=SomeAbstractClass.Create;
end

#define max(a,b)    (((a) > (b)) ? (a) : (b))

int a=5, b=5;
max(a++, b)

DOO>Дак это плюсы макросов что ли? По-моему Вы не ту точку зрения стали отстаивать

template <class T>
class CTemplateClass
{
 T member;
}
template <class T>
class CSon : public CTemplateClass<T>
{
}

J>>А зачем нам MS

procedure abc;
var s: IMyInterface;
begin
  s:=TMyObject.Create;
    s.DoSome;
    ...
    // и никаких забот — само освободится
end;

library MyDll;

procedure MyExportFunction; stdcall;
begin
end;

exports MyExportFunction;

end.

WH>Ну предоставь Кое о чем я уже говорил.

int main()
{
    enum{N=100};
    int int_arr[N];
    float float_arr[N];
    double double_arr[N];
    std::string string_arr[N];
    //....
    std::sort(int_arr, int_arr+N);
    std::sort(float_arr, float_arr+N);
    std::sort(double_arr, double_arr+N);
    std::sort(string_arr, string_arr+N);
    return 0;
}

WH>Каким не определенным поведением? Нука обьясни.

  class char_stack {
      int size;
      char* top;
      char* s;
  public:
      char_stack(int sz) { top=s=new char[size=sz]; }
      ~char_stack()      { delete s; }     // деструктор
      void push(char c)  { *top++ = c; }
      char pop()         { return *--top; }
  };

  void h()
  {
      char_stack s1(100);
      char_stack s2 = s1;  // неприятность
      char_stack s3(99);
      s3 = s2;             // неприятность
  }

struct some{};
struct base
{
    base(some*){}
};
struct derived
    :base
{
    derived(some* ptr)
        :base(test_some(ptr))
    {}
    static some* test_some(some*)
    {
        if(!is_good)
            throw bad_some_ptr();
    }
};

template<class T, int X, int Y>
struct matrix
{
    template<class,int,int>
    friend struct matrix;

    matrix<T, Y, X> transposition()
    {
        matrix<T, Y, X> tmp;
        for(int i=0;i<X;++i)
            for(int j=0;j<Y;++j)
                tmp[j][i]=(*this)[i][j];
        return tmp;
    }
    matrix& operator+=(const matrix& that)
    {
        for(int i=0;i<X;++i)
            for(int j=0;j<Y;++j)
                (*this)[i][j]+=that[i][j];
        return *this;
    }
    matrix operator+(const matrix& that)const
    {
        matrix tmp(*this);
        return tmp+=that;
    }
//...
};
int main()
{
    matrix<int, 3, 6> m_i_3_6_a;
    matrix<int, 3, 6> m_i_3_6_b;
    matrix<int, 6, 3> m_i_6_3;
    m_i_6_3=(m_i_3_6_a+m_i_3_6_b).transposition();
    return 0;
}

unit SortAnyArray;

interface

 Type
  TCompareProc= Function(Var Item1,Item2):Integer;
  TSwapProc= Procedure(Var Item1,Item2);
Procedure SortArray3(Var a; Len:Integer; CompareProc:TCompareProc;SwapProc:TSwapProc);// Для несовсем ленивых
  Procedure SortArray( Var a; Len:Integer; CompareProc:TCompareProc); // для ленивых
implementation
      Procedure SortArray(Var a; Len:Integer; CompareProc:TCompareProc);
     Var TempBuffer:Pointer;
         BeginArray:Cardinal;
         MidlVar:Pointer;

  procedure QuickSort(L, R: Integer);
var
  I, J: Integer;
begin


    I :=L;
    J :=R;
   Move(Pointer(BeginArray +((((L+R-BeginArray-BeginArray) div len)  shr 1)* len ))^,MidlVar^,Len);

    repeat
      while CompareProc(Pointer(I)^, MidlVar^) < 0 do
        Inc(I,Len);
      while CompareProc(Pointer(J)^, MidlVar^) > 0 do
        Dec(J,len);
      if I <= J then
      begin
        Move(Pointer(I)^,TempBuffer^,Len);
        Move(Pointer(J)^,Pointer(I)^,Len);
        Move(TempBuffer^,Pointer(J)^,Len);

        Inc(I,Len);
        Dec(J,Len);
      end;
    until I > J;


    if L < J then
      QuickSort(L,J);
     if R>I then
     QuickSort(I,R);

end;



     Begin
      GetMem(TempBuffer,2*Len);
      MidlVar:=Pointer(Cardinal(TempBuffer)+len);
      BeginArray:=PCardinal(@a)^;
      QuickSort(BeginArray,BeginArray+(PCardinal(BeginArray-4)^-1)*len);
      Dispose(TempBuffer);
     End;

       Procedure SortArray3(Var a; Len:Integer; CompareProc:TCompareProc;SwapProc:TSwapProc);
     Var TempBuffer:Pointer;
         BeginArray:Cardinal;
         MidlVar:Pointer;

  procedure QuickSort(L, R: Integer);
var
  I, J: Integer;
begin


    I :=L;
    J :=R;
   Move(Pointer(BeginArray +((((L+R-BeginArray-BeginArray) div len)  shr 1)* len ))^,MidlVar^,Len);

    repeat
      while CompareProc(Pointer(I)^, MidlVar^) < 0 do
        Inc(I,Len);
      while CompareProc(Pointer(J)^, MidlVar^) > 0 do
        Dec(J,len);
      if I <= J then
      begin
//        Move(Pointer(I)^,TempBuffer^,Len);
//        Move(Pointer(J)^,Pointer(I)^,Len);
//        Move(TempBuffer^,Pointer(J)^,Len);
       SwapProc(Pointer(I)^,Pointer(J)^);
        Inc(I,Len);
        Dec(J,Len);
      end;
    until I > J;


    if L < J then
      QuickSort(L,J);
     if R>I then
     QuickSort(I,R);

end;



     Begin
      GetMem(TempBuffer,2*Len);
      MidlVar:=Pointer(Cardinal(TempBuffer)+len);
      BeginArray:=PCardinal(@a)^;
      QuickSort(BeginArray,BeginArray+(PCardinal(BeginArray-4)^-1)*len);
      Dispose(TempBuffer);
     End;
end.


//=================================================
Type
 TType = packed record
      d:Double;
      b:Byte;
      end;
function CmpDoubleByte(var item1, item2): Integer;
var
  i1: TType absolute item1;
  i2: Ttype absolute item2;
  r: Double;
begin
  r := i1.d-i2.d;
  if (Abs(r) < 1.0E-100) then
    Result := 0
  else if (r < 0) then
    Result := -1
  else
    Result := 1;
 If Result:=0 Then
    Begin
       Result:=i1.B;
       Dec(result,i2.B
    end;
end;

Procedure SwapDoubleByte(Var Item1,Item2);
   var I1:TType absolute Item1;
        I2:TType absolute Item2;
        Temp:TType;
    Begin
    Temp:=i1;
    i1:=i2;
    i2:=temp;
    end;

///====================================================
Var a:Array of TType;
begin
//.................
 SortArray3(a,SizeOf(TType),CmpDoubleByte,SwapDoubleByte); 
// или
SortArray3(a,SizeOf(TType),CmpDoubleByte); // но в 2 раза медленнее

end;

  std::generate( data.begin(), data.end(),  boost::bind(random, 1000) );