i once was writing here my new observation
sometimes you need an array of things that
have some general type but differ on subtyopes

in c you would put that subtype as an enum signature
and put it all as record of arrays eventually
having union part

in c++ you use inheritance and virtual function

my thought was both are maybe bad as whot you
could do is to put it in two dimensional
array where this enum tag is a second rank
index

if you use such two dimensional you probably
also can sorta spare of unions as with 2-dimensional
array you get option to attach various size arrays
under that so same size is not strictly needed

its kinda interesting thought that both c popular
approach and c++ one are wrong

the question is hovever 1) how it can be exactly done
2) if language could support it more

piątek, 4 sierpnia 2023 o 12:07:48 UTC+2 fir napisał(a):
> i once was writing here my new observation
> sometimes you need an array of things that
> have some general type but differ on subtyopes
>
> in c you would put that subtype as an enum signature
> and put it all as record of arrays eventually
> having union part
>
> in c++ you use inheritance and virtual function
>
> my thought was both are maybe bad as whot you
> could do is to put it in two dimensional
> array where this enum tag is a second rank
> index
>
> if you use such two dimensional you probably
> also can sorta spare of unions as with 2-dimensional
> array you get option to attach various size arrays
> under that so same size is not strictly needed
>
> its kinda interesting thought that both c popular
> approach and c++ one are wrong
>
> the question is hovever 1) how it can be exactly done
> 2) if language could support it more

those low lewel/deep c ideas (like those rellocked containers, splitter
for chunks etc, but also how stack works etc, something that just need
strong logic ) i could call 'hard c'

if in co someone learns how to use some concepts in c c is easy liek
a pice of cace but there are regions of hard c where for some time you could
bump your head in a wall (if youre a noob) or just isolate and get think
(where youre more experienced)

piątek, 4 sierpnia 2023 o 13:21:11 UTC+2 fir napisał(a):
> piątek, 4 sierpnia 2023 o 12:07:48 UTC+2 fir napisał(a):
> > i once was writing here my new observation
> > sometimes you need an array of things that
> > have some general type but differ on subtyopes
> >
> > in c you would put that subtype as an enum signature
> > and put it all as record of arrays eventually
> > having union part
> >
> > in c++ you use inheritance and virtual function
> >
> > my thought was both are maybe bad as whot you
> > could do is to put it in two dimensional
> > array where this enum tag is a second rank
> > index
> >
> > if you use such two dimensional you probably
> > also can sorta spare of unions as with 2-dimensional
> > array you get option to attach various size arrays
> > under that so same size is not strictly needed
> >
> > its kinda interesting thought that both c popular
> > approach and c++ one are wrong
> >
> > the question is hovever 1) how it can be exactly done
> > 2) if language could support it more

i made soem exeprimentation .. this below is code for this container
(i named it vac from variants container)..teh advantage is you
can put any sized tagged ('signatured') structures into it
and they will be kept together by types, its 2x reallocable
- the main vector (name it temporarely a vector though should name
it array) keeps types and each have inner vector (i eventually should
change names as i mix 'types' names with 'variants'

disadvantage is maybe this loop iteration and acces via small inline helping functions though its probably to learn (maybe liek chunks, the chunks i liked and lerned was no problem with that)

here below i make brutal cast but is becouse i wanted to show some can
some may also use the iff acces by type, or use only one type of
physical record but use tags to sort it by content and 'logical' meaning
(phisical layout stay the same for optimistaion)

logicallly this conception is good imo as its better then puting things all to 1dimensional table, here acces by groups is granted so some codes liek colision
interactions not need to saw thru wasted empty loops

// vac = variants container

struct VacEntry { int type; int size; void* tab; int tab_size; };

VacEntry* vac = NULL; int types = 0;

int FindOrCreateVarArray(int type)
{ for(int i=0; i<types; i++)
if( vac[i].type == type ) return i;

types++;
vac = (VacEntry*) realloc(vac, sizeof(VacEntry)*types );
vac[types-1] = {type, 0, NULL, 0};

return types-1;
}

int AddVacVariant(int variant_type, void* variant, int variant_size)
{ int s = FindOrCreateVarArray(variant_type);
vac[s].tab_size++;
vac[s].size= variant_size;
vac[s].tab = realloc(vac[s].tab, vac[s].tab_size*vac[s].size);
int n = vac[s].tab_size-1;
void* var_adress = (char*)(vac[s].tab) + n*vac[s].size;
memcpy(var_adress, variant, variant_size);
}

inline void* vac_element(int s, int i){ return (vac[s].tab + i*vac[s].size);}
inline int vac_type(int s){ return vac[s].type;}
inline int vac_siz(int s){ return vac[s].tab_size;}

struct Human {char* name; float x,y,HP;};
struct Alien {char* name; float x,y,HP, a,b,c;};

void PrintAgentsCOmmonInfo()
{ for(int s=0; s<types;s++)
{
int type = vac_type(s);
int n = vac_siz(s);
for(int i=0; i<n; i++)
{
Human* h = (Human*) vac_element(s,i);
printf("\n name %s, HP %f ", (*h).name, (*h).HP);
}

}

}

void TestVac()
{

Human adam = {"adam", 0,0,100};
Human beata = {"beata", 100,100,200};
Human chloe = {"chloae", 20,20,79};
Alien zzxzz = {"zzxzz", 0,0,100,1,1,1};
Alien ssyss = {"ssyss", 100,100,200,2,2,2};
Alien bbnbb = {"bbnbb", 20,20,79,3,3,3};
AddVacVariant('hum', &adam, sizeof(Human));
AddVacVariant('ali', &zzxzz, sizeof(Human));
AddVacVariant('ali', &ssyss, sizeof(Human));
AddVacVariant('ali', &bbnbb, sizeof(Human));
AddVacVariant('hum', &beata, sizeof(Human));
AddVacVariant('hum', &chloe, sizeof(Human));

PrintAgentsCOmmonInfo();
}

> AddVacVariant('hum', &adam, sizeof(Human));
> AddVacVariant('ali', &zzxzz, sizeof(Human));
> AddVacVariant('ali', &ssyss, sizeof(Human));
> AddVacVariant('ali', &bbnbb, sizeof(Human));
> AddVacVariant('hum', &beata, sizeof(Human));
> AddVacVariant('hum', &chloe, sizeof(Human));
>

typos above should be

AddVacVariant('hum', &adam, sizeof(Human));
AddVacVariant('ali', &zzxzz, sizeof(Alien));
AddVacVariant('ali', &ssyss, sizeof(Alien));
AddVacVariant('ali', &bbnbb, sizeof(Alien));
AddVacVariant('hum', &beata, sizeof(Human));
AddVacVariant('hum', &chloe, sizeof(Human));

piątek, 4 sierpnia 2023 o 19:02:26 UTC+2 fir napisał(a):
> piątek, 4 sierpnia 2023 o 13:21:11 UTC+2 fir napisał(a):
> > piątek, 4 sierpnia 2023 o 12:07:48 UTC+2 fir napisał(a):
> > > i once was writing here my new observation
> > > sometimes you need an array of things that
> > > have some general type but differ on subtyopes
> > >
> > > in c you would put that subtype as an enum signature
> > > and put it all as record of arrays eventually
> > > having union part
> > >
> > > in c++ you use inheritance and virtual function
> > >
> > > my thought was both are maybe bad as whot you
> > > could do is to put it in two dimensional
> > > array where this enum tag is a second rank
> > > index
> > >
> > > if you use such two dimensional you probably
> > > also can sorta spare of unions as with 2-dimensional
> > > array you get option to attach various size arrays
> > > under that so same size is not strictly needed
> > >
> > > its kinda interesting thought that both c popular
> > > approach and c++ one are wrong
> > >
> > > the question is hovever 1) how it can be exactly done
> > > 2) if language could support it more
> i made soem exeprimentation .. this below is code for this container
> (i named it vac from variants container)..teh advantage is you
> can put any sized tagged ('signatured') structures into it
> and they will be kept together by types, its 2x reallocable
> - the main vector (name it temporarely a vector though should name
> it array) keeps types and each have inner vector (i eventually should
> change names as i mix 'types' names with 'variants'
>
> disadvantage is maybe this loop iteration and acces via small inline helping functions though its probably to learn (maybe liek chunks, the chunks i liked and lerned was no problem with that)
>
> here below i make brutal cast but is becouse i wanted to show some can
> some may also use the iff acces by type, or use only one type of
> physical record but use tags to sort it by content and 'logical' meaning
> (phisical layout stay the same for optimistaion)
>
> logicallly this conception is good imo as its better then puting things all to 1dimensional table, here acces by groups is granted so some codes liek colision
> interactions not need to saw thru wasted empty loops
>
>
> // vac = variants container
>

possibly in other alnguages this is called dictionary or something
here it is resizable array of signatured resizable arrays of various type..
on c ground such dictionarry is something other as it is kinda low lewel dictionary and some internals show - for example its seen that those signatures (keys) be better integer normal ordinal values (enums) to speed things up..there also
options to make it half static or fully static for execution speed (yawn)

i will rather stay with dynamic version unles maybe i wil be writing something time critical and then i would measure times (but recently i overally not write to much)