struct inheritance need?

[Janderson]

Weed wrote:
> Janderson пишет:
>> Weed wrote:
>>> I should explain why it's important for me:
>>>
>>> For example, I am making a matrix object(s)
>>>
>>> It should be:
>>> - any size
>>> - with ability of making matrix instance of a given size in compile 
>>> time.
>>> - ability of creating matrix instance in runtime.
>>>
>>> I have decided to make it struct because I need to create matrix
>>> object in compile time. in real program I'll need matricies of
>>> variable size and 3х1, 3х3, 6х6, 3х6 sizes (and may be other).
>>>
>>> I want to make matrix template and insert in it with mixin operator
>>> several structures of different sizes (and this structs are not store 
>>> his dimensions in each instance, of course: variables width and 
>>> height declared as invariant). By doing this I'll get several 
>>> different structures  (matrix_dynamic, matrix3x3, matrix6x6 etc)
>>>
>>> question is how those matricies can interoperate? They does not have
>>> common parent (structures does not have inheritance) , so I can't
>>> make common function for matricies of different sizes opAdd for
>>> example, and have to do functions for all types of matricies.
>>>
>>> How should I implement such a class In D properly?     It possible in 
>>> C++, but I like some of the language D
>>
>> The classical approach is to have "helper" template functions. 
>> Essentially:
>>
>> void doOpearation(mymatrix)(...)
>> {
>>
>> }
> 
> If I create struct MatrixStruct for compile-time matrix and class 
> MatrixClass for all other I will not be able to create a function of 
> interaction between these objects through the templates because some of 
> them will be announced before the other and it will not be able to get 
> another type of object in a template.
> 
> (I do not know, understand this long phrase on my strange English or 
> not? : ))
> 
> 
>>
>>
>> Note this is compiletime polymorphisms.
>>
>> Now if you want to add runtime polymorphism it is impossible to get 
>> away from a cost.  You can use a wrapper class like so:
>>
>> interface CommonMatrix
>> {
>>     operation()...
>> }
> 
>     
> Also, interfaces can not be used with the structs


I'm not sure what you mean:

I meant this:

You have your struct:

struct Foo
{

}

Then you have your template wrapper

class DoDynamicPolymorpicStuff(T) : TheInterface
{
	T foo;

	operation()
	{
		foo;
	}
}


Its a reasonably common pattern.

> 
> 
>>
>> class PolymorphicMatrix(mymatrix) : CommonMatrix
>> {
>>     operation()...
>> }
>>
>> You'll probably find though that PolymorphicMartix should be some 
>> higher level concept, like car, or entity.
>>
>> The great thing about these techniques is that they give a whole load 
>> more power then just using inheritance alone because you can 
>> essentially attach many different behaviors to that struct.
>>
>> I hope that was helpful.
>>
>> -Joel