Przeciazanie jak w delphi
webmaj...@poczta.onet.pl
operatorów dla rekordów .
{$Mode Delphi}
type
R = record
F: Integer;
class operator Implicit(const v: integer): R;
class Operator Explicit(const v: R ): integer;
end;
--
Wysłano z serwisu OnetNiusy: http://niusy.onet.pl
Wiktor S.
> operatorów dla rekordów .
>
> {$Mode Delphi}
>
> type
> R = record
> F: Integer;
> class operator Implicit(const v: integer): R;
> class Operator Explicit(const v: R ): integer;
> end;
szkoda że twórcy Delphi kompletnie ignorują Free Pascala, za każdym razem
wymyślając własną składnię, nawet jesli w FPC coś było wcześniej.
--
Azarien
webmaj...@poczta.onet.pl
> szkoda że twórcy Delphi kompletnie ignorują Free Pascala, za każdym razem
> wymyślając własną składnię, nawet jesli w FPC coś było wcześniej.
a czy delphi nie maiło wcześniej przeciążanie operatorów ??
zresztą i tak przeciążanie w stylu delphi bardziej mi się podoba -- lepiej
pasuej do stylu "object pascal " ( wszystkie przeciążenia z przedrostkiem
danego rekordu/klasy ) .
Wiktor S.
>> razem
>
>> wymyślając własną składnię, nawet jesli w FPC coś było wcześniej.
>
>
> a czy delphi nie maiło wcześniej przeciążanie operatorów ??
nie - miało dużo później.
generyki też FPC miało _trochę_ wcześniej, i też na trochę innych zasadach
(acz <klamerki> są te same). Delphi ma wygodniejsze w użyciu, FPC bardziej
restrykcyjne (w duchu Pascala).
--
Azarien
Wiktor S.
>> razem
>
>> wymyślając własną składnię, nawet jesli w FPC coś było wcześniej.
>
>
> a czy delphi nie maiło wcześniej przeciążanie operatorów ??
nie - miało dużo później.
generyki też FPC miało trochę wcześniej, i też na trochę innych zasadach
(acz <klamerki> są te same). Delphi ma wygodniejsze w użyciu, FPC bardziej
restrykcyjne (w duchu Pascala).
Choć mnie by się bardziej podobała składnia
var lista:=TList of string;
(na wzór array) niż kopiowanie C# o zupełnie innej "tradycji" składniowej.
--
Azarien
Wiktor S.
>> razem
>
>> wymyślając własną składnię, nawet jesli w FPC coś było wcześniej.
>
>
> a czy delphi nie maiło wcześniej przeciążanie operatorów ??
nie - miało dużo później.
generyki też FPC miało trochę wcześniej, i też na trochę innych zasadach
(acz <klamerki> są te same). Delphi ma wygodniejsze w użyciu, FPC bardziej
restrykcyjne (w duchu Pascala).
Choć mnie by się bardziej podobała składnia
var lista:TList of string;
webmaj...@poczta.onet.pl
klass/obiektów ??
wloochacz
O ile taka składania dla TList przejdzie, bo typ generyczny jest
zadeklarowany tak:
TList<T>
ale już np. deklaracja słownika jest taka:
TDictionary<T, T>;
i jak to zadeklarujesz na wzór array:
var slownik : TDictionary of string, TObject;
a może:
var slownik : TDictionary of [string, TObject];
??
A co z zagnieżdżonym typem generycznym - wersja absolutnie banalna:
TMojTyp<T, T<T>>
Jak go zadeklarować na wzór array?
Nie - "kopiowanie C#" w tynm przypadku jest po prostu zdrowe.
--
wloochacz
Wiktor S.
> klass/obiektów ??
Problemem jest w zasadzie to, że potrzebny jest do tego garbage collector,
lub przynajmniej zliczanie referencji.
var a,b,c,d:TMojaKlasa;
begin
a:=TMojaKlasa.Create;
b:=TMojaKlasa.Create;
c:=TMOjaKlasa.Create;
d:= a + b + c;
zakładając, że operator + tworzy nowy obiekt na stercie (czyli odpala
TMojaKlasa.Create), co i kiedy zniszczy ci obiekt tymczasowy o wartości a+b?
--
Azarien
Wiktor S.
> TMojTyp<T, T<T>>
>
> Jak go zadeklarować na wzór array?
jeżeli przyjmiemy wariant
> var slownik : TDictionary of string, TObject;
to zagnieżdzenie wyglądałoby
var zmienna = TMojTyp of T, T of T;
--
Azarien
webmaj...@poczta.onet.pl
> Problemem jest w zasadzie to, że potrzebny jest do tego garbage collector,
> lub przynajmniej zliczanie referencji.
w delhi.net jakoś się udało .
>
> var a,b,c,d:TMojaKlasa;
>
> begin
> a:=TMojaKlasa.Create;
> b:=TMojaKlasa.Create;
> c:=TMOjaKlasa.Create;
>
> d:= a + b + c;
kompilator przetłumaczył by to na cos takiego
if d=nil Then d:=TMojaClasa.Create;
d.Add(a);
d.Add(b);
d.Add(c);// procedura add była by odpowiednikem d+=b;
>
> zakładając, że operator + tworzy nowy obiekt na stercie (czyli odpala
> TMojaKlasa.Create), co i kiedy zniszczy ci obiekt tymczasowy o wartości a+b?
>
jak bawiłem się przeciążeniami dla klas to robiłem tak
operator +(a,b:TMojaKlasa):R:TMojaKlasa;
begin
a.Aad(b);
R:=b;
end;
Tylko musiałem pamietać żeby wywoływać w jeden sposób
ZZ+=YY; lub ZZ:=ZZ+YY;
Gdyby ten fragment kodu odpowiadający za oabsługe operatora ( operator ) był na
jakiś specialnych i w momęcie wywołania w zmiennej R (Result ) był już adres
obiektu który ma otrzymać dane to w zasadzie byłoby to rozwiązanie i nie
trzeba by dodatkowo dodawać skomplikowanych mechanizmów zarzadzania pamięcią .
wtedy by operaator wyglądał tak
operator +(a,b:TMojaKlasa):R:TMojaKlasa;
begin
if R<>a then begin R:=0;// wyczyść np liczbe
R.Add(A);
R.Add(b)
end else R.Add(b);
end;
Łukasz 'Maly' Ostrowski
> to zagnieżdzenie wyglądałoby
>
> var zmienna = TMojTyp of T, T of T;
Pod względem czytelności, straszne.
Pod względem funkcjonalnym, też, bo wprowadza ambiguity.
var zmienna = TType of T, U of V, X, Y, Z
1. Type<T, U<V>, X, Y, Z>?
2. Type<T, U<V, X>, Y, Z>?
3. Type<T, U<V, X, Y>, Z>?
4. Type<T, U<V, X, Y, Z>>?
X-D.
--
Pozdrawiam,
Łukasz 'Maly' Ostrowski. http://l3v.eu/
Łukasz 'Maly' Ostrowski
>> Problemem jest w zasadzie to, że potrzebny jest do tego garbage collector,
>
>> lub przynajmniej zliczanie referencji.
>
>
> w delhi.net jakoś się udało .
Bo Delphi .NET lata na CLR .NET - więc ma też garbage
collector... i nie ma wiele wspólnego z Delphi
już defacto ;-).
Wiktor S.
TInterfacedObject.
Trzeba jednak pamiętać, by operować na zmiennych "interfejsowych" a nie
"klasowych".
=======
{$mode objfpc}
type IKlasa = interface
function getvalue:integer;
procedure setvalue(v:integer);
property value:integer read getvalue write setvalue;
end;
type TKlasa = class(TInterfacedObject,IKlasa)
fvalue:integer;
constructor Create(x:integer);
destructor Destroy; override;
function getvalue:integer;
procedure setvalue(v:integer);
property value:integer read getvalue write setvalue;
end;
constructor TKlasa.Create(x:integer);
begin
writeln('konstruktor ',x);
value:=x;
end;
destructor TKlasa.Destroy;
begin
writeln('destruktor ',value);
end;
procedure TKlasa.setvalue(v:integer);
begin
fvalue:=v;
end;
function TKlasa.getvalue:integer;
begin
getvalue:=fvalue;
end;
operator +(a,b:IKlasa):IKlasa;
begin
result:=TKlasa.Create(a.value + b.value);
end;
var a,b,c,d:IKlasa;
begin
a:=TKlasa.Create(2);
b:=TKlasa.Create(3);
c:=TKlasa.Create(4);
d:=a+b+c;
writeln('wynik: ',d.value);
end.
=======
konstruktor 2
konstruktor 3
konstruktor 4
konstruktor 5
konstruktor 9
wynik: 9
destruktor 5
destruktor 2
destruktor 3
destruktor 4
destruktor 9
--
Azarien