🚀 go-pugleaf

Czy to będzie prawidłowo?
function TMyList<T>.Add(const Value: T): Integer;
var row : ^TCialo_Rozny;
begin
   row:=@value;
   row.Parent:=FParent;
   result:=inherited Add(value);
end;

W dniu 2018-08-22 o 11:42, konsul41@wp.pl pisze:
> Próbuję dziedziczyć po TList<T> i dodać coś po ADD
> 
> 
> ...
> TCialo_Rozny = class;
> 
> ...
> 
> TMyList<T> = class(TList<T>)
>    private;
>    public
>      function Add(const Value: T): Integer; overload;
>    end;
> 

Twoje intencje nie są dla mnie do końca jasne ani co dokładnie oznacza 
dla Ciebie niedziałanie. Jeśli chcesz wykonać jakieś dodatkowe operacje 
po dodaniu elementu do listy, to lepiej wykonaj przeciążenie metody 
wirtualnej Notify albo użyj zdarzenia OnNotify.


-- 
z pozdrowieniami
Adam Siwoń

W dniu 2018-08-23 o 14:18, Adam Siwoń pisze:
/ciach/

> Twoje intencje nie są dla mnie do końca jasne ani co dokładnie oznacza 
> dla Ciebie niedziałanie. Jeśli chcesz wykonać jakieś dodatkowe operacje 
> po dodaniu elementu do listy, to lepiej wykonaj przeciążenie metody 
> wirtualnej Notify albo użyj zdarzenia OnNotify.
Właśnie, a czkolwiek jeśli dziedzicznie, to raczej nie zdarzenie.


-- 
wloochacz

On Wed, 22 Aug 2018 11:42:49 +0200, konsul41@wp.pl wrote:

> Próbuję dziedziczyć po TList<T> i dodać coś po ADD
> 
> 
> ...
> TCialo_Rozny = class;
> 
> ...
> 
> TMyList<T> = class(TList<T>)
>    private;
>    public
>      function Add(const Value: T): Integer; overload;
>    end;
> 
> ...

Nie pomyliłeś przypadkiem overload i override?
 
> 
> function TMyList<T>.Add(const Value: T): Integer;
> var row : TCialo_Rozny;
> begin
>    result:=Self.Add(Value);
> 
> //jak prawidłowo dobrać się do listy po której dziedziczę
> 
>    row:=TCialo_Rozny(Items[Result]);
> //niedziała

A to sugeruje, że chyba nie do końca rozumiesz generyki i ich działanie.
Nie powinieneś w klasie generycznej hardkodować innych typów.

Na moje oko to chyba chcesz osiągnąć coś takiego:

TMyList = class(TList<TJakisTwojTyp>)
   public
     function Add(const Value: TJakisTwojTyp): Integer; override;
   end;

Gdzie TJakisTwojTyp to typ jaki chcesz gromadszić w liście.

-- 
pozdrawiam
Roman Tyczka

> Nie pomyliłeś przypadkiem overload i override?
Nie nie pomyliłem.
function Add(const Value: T): Integer; inline;
to z klasy bazowej więc nie ma mowy o override.

Na koniec stanęło na:

procedure TMyList<T>.Notify(const Item: T; Action: TCollectionNotification);
var row : ^TCialo_Rozny;
begin
   inherited;
   row:=@Item;
   row.Fdokwwal:=FParent.dokwwal;
end;
Wiem, wiem to nie jest dobre ogólnie(zależności).

> 
> A to sugeruje, że chyba nie do końca rozumiesz generyki i ich działanie.
> Nie powinieneś w klasie generycznej hardkodować innych typów.

Sprawa jest bardziej skomplikowana niż napisałem.

Klasa w sobie ma inną klasę (właśnie typu Cialo: TMyList<TCialo_Rozny>;)

całość ładowana i tworzona jest za pomocą "Aurelius"

więc najwygodniejsze dla mnie jest aby dokwwal dodawać w momencie add.
Jest pole w głównej klasie typu boolean Fdokwwal, które można byłoby 
wykorzystać do wpisania dokwwal(i tutaj uzupełnić informację w Cialo) , 
ale Aurelius ładuje wpierw klasę nadrzędną(dokwwal jest załadowane, a 
Cialo jest puste), a potem "Ciało" i klasa podrzędna nie dostaje 
informacji z tego pola boolean o tym jak ma się zachowywać.

On Mon, 3 Sep 2018 08:37:13 +0200, konsul41@wp.pl wrote:

>> Nie pomyliłeś przypadkiem overload i override?
> Nie nie pomyliłem.
> function Add(const Value: T): Integer; inline;
> to z klasy bazowej więc nie ma mowy o override.

Tak, racja.

> Na koniec stanęło na:
> 
> procedure TMyList<T>.Notify(const Item: T; Action: TCollectionNotification);
> var row : ^TCialo_Rozny;
> begin
>    inherited;
>    row:=@Item;
>    row.Fdokwwal:=FParent.dokwwal;
> end;
> Wiem, wiem to nie jest dobre ogólnie(zależności).
> 

Patrząc na tę metodę naprawdę nie wiem po co Ci generyk tutaj? Skoro i tak
każdy typ rzutujesz twardo na TCialo_Rozny. To bez sensu. Jakikolwiek inny
typ podstawiony zamiast T wywali na pysk całą klasę. Po co zatem generyczny
TMyList<T> a nie tak jak sugerowałem?

>> A to sugeruje, że chyba nie do końca rozumiesz generyki i ich działanie.
>> Nie powinieneś w klasie generycznej hardkodować innych typów.


-- 
pozdrawiam
Roman Tyczka

> Patrząc na tę metodę naprawdę nie wiem po co Ci generyk tutaj? Skoro i tak
> każdy typ rzutujesz twardo na TCialo_Rozny. To bez sensu. Jakikolwiek inny
> typ podstawiony zamiast T wywali na pysk całą klasę. Po co zatem generyczny
> TMyList<T> a nie tak jak sugerowałem?
> 
>>> A to sugeruje, że chyba nie do końca rozumiesz generyki i ich działanie.
>>> Nie powinieneś w klasie generycznej hardkodować innych typów.
> 
> 

Ponieważ, prawdopodobnie tą klasę będę wykorzystywał jako przodek 
dziedziczenia i każda następna klasa będzie miała także podklasę TList z 
obiektami Dziedziczącymi po TCialo_Rozny, a ten wytrych który stosuję, 
jest stosowany jednorazowo.

W dniu 2018-09-04 o 08:22, konsul41@wp.pl pisze:
> 
>> Patrząc na tę metodę naprawdę nie wiem po co Ci generyk tutaj? Skoro i 
>> tak
>> każdy typ rzutujesz twardo na TCialo_Rozny. To bez sensu. Jakikolwiek 
>> inny
>> typ podstawiony zamiast T wywali na pysk całą klasę. Po co zatem 
>> generyczny
>> TMyList<T> a nie tak jak sugerowałem?
>>
>>>> A to sugeruje, że chyba nie do końca rozumiesz generyki i ich 
>>>> działanie.
>>>> Nie powinieneś w klasie generycznej hardkodować innych typów.
>>
>>
> 
> Ponieważ, prawdopodobnie tą klasę będę wykorzystywał jako przodek 
> dziedziczenia i każda następna klasa będzie miała także podklasę TList z 
> obiektami Dziedziczącymi po TCialo_Rozny, a ten wytrych który stosuję, 
> jest stosowany jednorazowo.

To zadeklaruj klasę listy w ten sposób:

TMyList<T: TCialo_Rozny> = class(TList<T>)

wtedy kompilator pilnuje, żebyś nie próbował utworzyć listy dla 
niewłaściwej klasy.

-- 
z pozdrowieniami
Adam Siwoń

On Tue, 4 Sep 2018 09:24:34 +0200, Adam Siwoń wrote:

>> Ponieważ, prawdopodobnie tą klasę będę wykorzystywał jako przodek 
>> dziedziczenia i każda następna klasa będzie miała także podklasę TList z 
>> obiektami Dziedziczącymi po TCialo_Rozny, a ten wytrych który stosuję, 
>> jest stosowany jednorazowo.
> 
> To zadeklaruj klasę listy w ten sposób:
> 
> TMyList<T: TCialo_Rozny> = class(TList<T>)
> 
> wtedy kompilator pilnuje, żebyś nie próbował utworzyć listy dla 
> niewłaściwej klasy.

Oraz dodatkowo pozwoli używać metod i propertysów z TCialo_Rozny bez
rzutowania.

-- 
pozdrawiam
Roman Tyczka

> 
> TMyList<T: TCialo_Rozny> = class(TList<T>)
> 
> wtedy kompilator pilnuje, żebyś nie próbował utworzyć listy dla 
> niewłaściwej klasy.
> 


Tak ale czy przy dodawaniu potomków TCialo_Rozny nie będę musiał 
rzutować np: TNNCialo_Rozny na TCialo_Rozny aby dodać?

W dniu 2018-09-04 o 10:09, konsul41@wp.pl pisze:
> 
>>
>> TMyList<T: TCialo_Rozny> = class(TList<T>)
>>
>> wtedy kompilator pilnuje, żebyś nie próbował utworzyć listy dla 
>> niewłaściwej klasy.
>>
> 
> 
> Tak ale czy przy dodawaniu potomków TCialo_Rozny nie będę musiał 
> rzutować np: TNNCialo_Rozny na TCialo_Rozny aby dodać?

Nie będziesz musiał. Po to właśnie używasz generyka, żeby nie rzutować. 
Deklaracja: TMyList<T: TCialo_Rozny> ogranicza możliwość podawania klas 
elementów listy do klasy TCialo_Rozny i klas dziedziczących po niej.

-- 
z pozdrowieniami
Adam Siwoń