hkaiser changed the topic of #ste||ar to: STE||AR: Systems Technology, Emergent Parallelism, and Algorithm Research | stellar-group.org | HPX: A cure for performance impaired parallel applications | github.com/STEllAR-GROUP/hpx | This channel is logged: irclog.cct.lsu.edu
Yorlik_ has joined #ste||ar
Yorlik has quit [Ping timeout: 240 seconds]
tufei has joined #ste||ar
hkaiser has quit [Quit: Bye!]
HHN93 has quit [Quit: Client closed]
hkaiser has joined #ste||ar
hkaiser has quit [Quit: Bye!]
hkaiser has joined #ste||ar
diehlpk_work has joined #ste||ar
<dkaratza[m]>
hkaiser: are you joining the meeting today?
<dkaratza[m]>
hkaiser: I see we haven't listed `ranges::transform` in the Public API, do you think we should add it?
<hkaiser>
dkaratza[m]: absolutely, do we have any range-based parallel algorithms documented?
<hkaiser>
if not, we should add them :-)
hkaiser has quit [Quit: Bye!]
<Aarya[m]>
Hi this is the bt of the current hpxmp example, where I have registered a shutdown function. Weirdly the function is not getting called -This is the bt after the hang - https://pasteboard.co/iKnED2tWJI7d.png
hkaiser has joined #ste||ar
<gonidelis[m]>
how can i access the members of a base class template in a derived from it class template without qualification?
<gonidelis[m]>
feel free to use structs and public inher.
<gonidelis[m]>
we could be discussing these in a coffeeshop in santa clara
<gonidelis[m]>
`😅
<gnikunj[m]>
Would love that. I'm in the office though and won't be free until 5:30 or so xD
<gonidelis[m]>
same :}
<gnikunj[m]>
I don't think you can remove the `base<T>` part. Although if you specialize of certain template types (say `int`), you can do `int b = a` directly. The reason why you can't do `base<T>` is because at the time of class compilation, the compiler has no means of knowing the type/value of a without knowing where the template instantiation type (T). That's why when you have template specialization, you could simply do `int b = a` and not get any
<gnikunj[m]>
Under template specialization, the compiler knows the exact type of `Base<T>` (`double` in the above example) and can construct the class directly from that knowledge.
<gonidelis[m]>
yup
<gonidelis[m]>
that's what i did
<gonidelis[m]>
i just wanted to do it without specializing
<gnikunj[m]>
then use `base<T>::a` method?
<gonidelis[m]>
problem is i only want it for two types, yet i don't fill like copy pasting the code twice
<gonidelis[m]>
well base has like 20 members that I need and I wanna avoid qualifying all of those
<gonidelis[m]>
plus base is a 5 camel case railroad word
<gonidelis[m]>
but i guess theres no other way
<K-ballo>
sfinae has absolutely nothing to do with it
<gnikunj[m]>
using my_base_alias = base<T>;
<gnikunj[m]>
int b = my_base_alias::a; // how can i remove base<T>:: ?
<gnikunj[m]>
aliases are your friend here ;)
<K-ballo>
you can bring base members into view with a using declaration
<gonidelis[m]>
true
<gonidelis[m]>
K-ballo: base is a template
<K-ballo>
you can bring base members of a template into view with a using declaration
<gonidelis[m]>
wait how
<K-ballo>
using base<T>::a; // now it's visible here too
<gonidelis[m]>
ah... 20 using's
<K-ballo>
no, 98
<gonidelis[m]>
20 members ==> 20 using declerations
<K-ballo>
or 1 multiple
<gonidelis[m]>
?
<K-ballo>
using base<T>::a, base<T>::b, ...;
<gonidelis[m]>
1 multiple?
<gonidelis[m]>
ah comma sep
<gonidelis[m]>
huh
<gonidelis[m]>
alrighty thankx a lot both, will stick with aliases
<gonidelis[m]>
way is bad anywyas
<K-ballo>
note you can use the derived class instead of the base class name
<gonidelis[m]>
yup
<K-ballo>
as well as this->, to keep it entirely independent of class names
<gonidelis[m]>
makes sense
<gonidelis[m]>
this too, yes
<K-ballo>
you can also use base's injected class name, to avoid repeating the template arguments
<gnikunj[m]>
I like this approach better honestly
<K-ballo>
using my_base_alias = derived::base;
<gonidelis[m]>
how do i avoid repeating template args this way?
<gonidelis[m]>
you mean instead of using my_base = base<T> ?
<K-ballo>
yes
<K-ballo>
note no template arguments after base
<gonidelis[m]>
what's the benefit?
<K-ballo>
the benefit of avoid repeating the template arguments?
<K-ballo>
the benefit of avoid repeating the template arguments is tha tyou don't have to repeat the template arguments
<gonidelis[m]>
yeah i didn't see it cause count of temp args was 1, but makes sense if they more
<K-ballo>
even if it's one, you don't want base to somehow end up using different arguments
<gonidelis[m]>
right
<gonidelis[m]>
since :: preceeds &, why is `&base<float>::a` a problem and need to be `(&base<float>::a)` instead?
<gonidelis[m]>
`&(base<float>::a)` **
diehlpk_work has quit [Remote host closed the connection]
<K-ballo>
`&base<float>::a` is a member pointer
<K-ballo>
presumably you want an ordinary pointer instead
tufei has quit [Remote host closed the connection]