On Wednesday, 16 October 2013 at 06:09:48 UTC, Benjamin Thaut
wrote:
Am 16.10.2013 03:17, schrieb DoctorCaptain:
I've gotten extremely close. The DPaste link that follows
demonstrates
three different templates:
...
So is there any reason why you still pass the variadic
arguments to the generator function and not do it the way I
proposed in my last dpaste snippet? Even if you need the
variadic arguments inside the generator for some logic you
could still reference them by using the variadic arguments to
the actual template.
I suppose I was trying to give the class individual data members,
such that passing a tuple of (WorstChild, MiddleChild, BestChild)
would result in a class definition of:
class MagicClass {
WorstClass t1;
MiddleClass t2;
BestClass t3;
}
However, if that is impossible (and frankly it'd be more
difficult to work with than your way even if it was achieved),
then I'll use your approach (actually, I'm just going to use your
approach anyway. It's significantly cleaner than my horrid mess
of a goal). That said, what is actually happening in your example?
I reworked it a bit to demonstrate that the class has accessible
members within T, that can be instantiated and accessed and
whatnot.
http://dpaste.dzfl.pl/07b20d75
Note the use of typeof() to get the type of the elements at each
index of members, to generate a type on which a constructor can
be called to instantiate the elements at each index of members.
Magic.
What is T within the generated class definition? Is this just how
tuples work? T is an "array" of three arbitrary pointers,
initially null, that can be instantiated with new to create valid
pointers to objects of each type at T's indexes? Like, T in the
DPaste example is an array of pointers, such that:
[WorstChild*, MiddleChild*, BestChild*]? Is it literally just
magic like that?
Actually, let me formally present a couple of ending
thoughts/questions:
First, allow me to apologize for trying to force a different,
messy horrid mess of a goal on you, when your initial solution
was majestic to begin with.
Second, as I was trying to figure out just a moment ago, what
-exactly- is T in the generated class definition, and why does it
allow me to use it as an arbitrary container for objects of the
arbitrary types I want it to contain (Read: why is it able to do
exactly what I want it to be able to do? What's going on behind
the scenes?)?
Third, given that I am going to go with your solution (it works,
it works well, and I can't seem to force my original goal to
work, whether that was even a good idea to begin with at all (it
wasn't)), can you think of a way to actually produce my original
goal? That is, instead of a container T which I can use to access
my arbitrary data members once the generated class is
instantiated, is it actually even possible to generate individual
data members, a la:
class MagicClass {
T[0] t0;
T[1] t1;
// ... etc
} // ?
You've been wildly helpful, and admirably concise. I am
-extremely- interested in the answer to the second thought, and
while I'm sure the answer is simple, it also seems -too- magic to
actually work, and yet it does.
Again, thank you to everyone who responded, and thank you
Benjamin for your continued help.
