dla mnie tez dziedziczenie/polimorfizm [co ja sam wolalbym nazwaz programowaniem na
ogolnikach - tj takie programowanie gdzie zastepujesz konkretny typ pewna klasa
typów] jest innym paradygmatem niz czyste oo - zobacz np ten przyklad podany przez
uzytkownika toslaw, wlasnie wycialem stamtad elementy dziedziczenia po to zeby
uproscic sprawe a nadal jest to przyklad na oop

sam bardzo rozbudowalem i niejako zunifikowałem system modułowy (napisałem o tym pare
postów),
dodalem m.in. mozliwosc instancjonowania modułow
i jesli wybrac sposród tego niektóre charakterystyczne elementy to mozna powiedziec
ze niektore (te lepsze) elementy oop 'wtopiły sie' w to [w tym ze bylbym badzo
obrazony gdyby mowic ze
cos tu zostalo przejete od oop, bo dla mnie oop
(taki jaki znam z javy albo c++) to niesamowita chała której szczerze niecierpie,
raczej po prostu
pewne czesci mojego systemu (który jest 'generalny')
pozwalaja wyrazić lepiej to co w oop jest umieszczone w kontekscie pewnego koszmaru)

specjalny opopodobny przykład z mojego systemu modułowego*

main()
{
Int x;
Int y;
Int z;

x.add(y);
y.add(z);
z.add(x);

Monitor m1, m2, m3;

x.add(m1);
x.add(m2);
x.add(m3);

x.run();

}

Int jest tutaj modułem który jest instancjonowany
3 razy do encji x y z

przez te linijki z add zakladam pewien taki łancuch
kółeczko encji x->y->z->(x->) (w opopodobny sposób
tj przez fizyczny wskaznik) tak by np dzialalo to jak trzy fabryki x produkuje cos i
uruchamia y ktore
produkuje cos i uruchamia z ktore wtedy produkuje cos i uruchamia z
na przyklad

x produkuje "1111" (**mozna w x napisac parolinijkowa funkcje ktora to bedzie
robic:)

y produkuje z tego "2222"
z produkuje z tego "3333"
x produkuje z tego "4444"

do x y i z podpiałem trzy encja monitora tak ze na
monitor jeden bedzie szedł napis "1111" "4444" "7777" na drugi "2222" "5555" itd


[* specjalnie zostawilem to oznaczenie z kropka zeby wykazac podobieństwo
gdy normalnie w moim systemi emodulowym bardziej
naturalne sa wywolania "x add(y)" dla zwykłych funkcji (ew "x add y" dla operatorów)]

[**

Int.c:

module Int uses Monitor&

unsigned data[4];

Int& consumer;
Monitor& monitor;

void produce()
{
data[0]++;
data[1]++;
data[2]++;
data[3]++;
}

external void add(Int consumer){
consumer& = &consumer;
}

external void add(Monitor m){
monitor& = &monitor;
}

external void run()
{
produce();
monitor& show();
consumer& run();
}

Monitor.c (skip)

specjalnie wypichcony obiektowopodobny kawałek
tj komunikacja za pomoca fizycznych referencji
(w nieco przypadkowej składni), sa tu ze
cztery czy piec ciekawych tematow m.in
ciekawe dla mnie jest to ze jak sie raz "sklei"
Inta z monitorem

Int add(monitor)

to pozniej nie trzeba przekazywac metodom
miedzy monitorem a intem argumentów bo
sa one widzialne wewnetrzeni wzajemnie
przez ten wskaznik (jest to interesujace)

innym ubocznym tematem przy okazji pisanie tego
byloby dla mnie zastanawianie sie czy trzeba pisac
asserty dla nieustawionych referencji (lepiej nie
pisac by obsluzyl je system ale czy system w runtime bedzie w stanie bezstratnie
podac informacje ktora
referencja jest pusta.. pewnie da sie zrobic

jeszcze innym tematem jest zastanowienie sie co jest podobnie jak w kaszaniastym
pozatym oop a co jest jednak inaczej.. itd