Template Base Classes, Refering to typeof(this)

[Travis Boucher]

Robert Jacques wrote:
> On Wed, 04 Nov 2009 13:35:45 -0500, Travis Boucher 
> <boucher.travis at gmail.com> wrote:
> 
>> I am writing a generic vector base class.  The class implements all of 
>> the operator overloads so I don't have to implement them over and over 
>> and over for each type of vector class.
>>
>> class VectorBase(size_t S, T) {
>>     T[S] data;
>>
>>     ...
>> }
>>
>> class Vector3f : VectorBase!(3, float) { ... }
>>
>> The problem I am having is implementing operations that can take a 
>> matching vector.  I can't figure out the proper way of declaring the 
>> type of input.
>>
>> eg.
>>
>> void opAssign(VectorBase!(S, T) r);
>>  > function VectorBase!(3LU,float).VectorBase.opAssign identity 
>> assignment operator overload is illegal
>>
>>
>> void opAssign(this r);
>>  > basic type expected, not this
>>
>>
>> The only way I can think of handling it is to add another parameter to 
>> the template declaration, eg:
>>
>> class VectorBase(size_t S, T, N) { ... }
>> class Vector3f : VectorBase!(3, float, Vector3f) { ... }
>>
>> But I would like to avoid that if possible.
>>
>> Any hints on how to implement this so I can keep my original 
>> declaration? class VectorBase(size_t S, T)
> 
> Well first, you can't overload assignment of a class to it's own type.

Ok, that makes sense, since an object is just a reference, so an 
assignment is really just a pointer copy, not a data copy, correct?

> (It's part of the language spec, at the bottom of the operator overload 
> page IIRC) Second, I've already solved this in D2, (using structs) so 
> let me know if you want code. 

Yeah, I'd be interested.  I am currently running gdc with D1, but I did 
see some notes on getting gdc working with D2.

> Third, fixed sized arrays as value-type 
> are coming in the next release (I think), so you could wait for that. 
> Lastly, you're (probably) going to run into issues with your other 
> operator overloads because of some bugs in instantiating templates 
> inside of templates using template literals as opposed to types.

Do you have any hints on what to look out for?  I did implement a Vector 
class template, passing in a template parameter to refer to the 
instantiated type.  It used mixins.

eg.
class VectorBase(size_t S, T, N) { ... }
class Vector3f {mixin VectorBase!(3, float, Vector3f); }

It compiled and worked for the basic tests, including all operator 
overloading.

auto a = new Vector3f();
auto b = new Vector3f(1, 2, 3);
auto c = b * 2; // c = Vector3f(2, 4, 6)
auto d = b + c; // d = Vector3f(3, 6, 9)

I didn't run into any bugs, and even more complex methods (explict 
methods) returned valid results (eg. T dotProduct(N vec) { ... }).