Re: Use class template as a type
On Tuesday, 29 November 2016 at 15:56:23 UTC, Jerry wrote:
To avoid having to use the Object class directly you can make
an base class of the class template.
Like:
```
abstract class MyClass {}
abstract class MyClassImpl(T)
{
public:
@property const(T) value(){return _value;}
@property void value(T val){_value = val;}
...
private:
T _value;
...
}
MyClassInt and float inherits from MyClassImpl
```
And use it like:
```
void main() {
MyClass[] objs;
objs ~= new MyClassFloat();
objs ~= new MyClassInt();
}
```
Yes, but anyway you need to downcast if(MyClassBlahBlah subclass
= cast(MyClassBlahBlah)obj)...
So it's not much sense to have base class or interface MyClass.
Re: Use class template as a type
On Wednesday, 30 November 2016 at 14:53:21 UTC, ag0aep6g wrote: On 11/30/2016 10:42 AM, Bauss wrote: Usually casts to base classes can be determined if they're valid at compile-time. Yeah, that's what I said. A cast to a base class is an "upcast". Upcasts don't need run-time checks. The other direction (cast to more derived class) is a downcast. Downcasts need run-time checks. Actually I've always called an "upcast" a "downcast" ! This incredible misconception explains why you had to correct me after my yesterday's answer.
Re: Use class template as a type
On 11/30/2016 10:42 AM, Bauss wrote: Usually casts to base classes can be determined if they're valid at compile-time. Yeah, that's what I said. A cast to a base class is an "upcast". Upcasts don't need run-time checks. The other direction (cast to more derived class) is a downcast. Downcasts need run-time checks.
Re: Use class template as a type
On Tuesday, 29 November 2016 at 15:56:23 UTC, Jerry wrote:
On Monday, 28 November 2016 at 11:26:41 UTC, dm wrote:
```
abstract class MyClass(T)
{
public:
@property const(T) value(){return _value;}
@property void value(T val){_value = val;}
...
private:
T _value;
...
}
To avoid having to use the Object class directly you can make
an base class of the class template.
Like:
```
abstract class MyClass {}
abstract class MyClassImpl(T)
{
public:
@property const(T) value(){return _value;}
@property void value(T val){_value = val;}
...
private:
T _value;
...
}
MyClassInt and float inherits from MyClassImpl
```
And use it like:
```
void main() {
MyClass[] objs;
objs ~= new MyClassFloat();
objs ~= new MyClassInt();
}
```
I would rather go with an interface than a base class.
Re: Use class template as a type
On Tuesday, 29 November 2016 at 09:58:16 UTC, ag0aep6g wrote:
On 11/29/2016 02:21 AM, Basile B. wrote:
The cast from a class type to a sub class in itself does
absolutely
nothing.
That can't be right. A bad downcast gives you null, so it has
to check the dynamic type information. Compare with upcasts
which are statically known to be correct, so they don't need to
check anything at runtime.
Usually casts to base classes can be determined if they're valid
at compile-time.
Take this for an example:
class Foo {
}
class Bar : Foo {
}
void main() {
auto bar = new Bar;
auto foo = cast(Foo)bar; // The compiler should know that bar
is of type Bar, which is a subclass of Foo and thus the cast
theoretically is redundant.
}
Even in a situation like this, the compiler should be able to see
if the cast could ever be invalid during compile-time determined
by calls to fun.
void fun(Cast)(Bar bar) {
return cast(Cast)bar; // If Cast is Foo then the compiler
should know the cast is redundant.
]
I don't know if the D compiler actually takes such situation into
account, but I'd assume it does some kind of optimization in
regards of that.
Re: Use class template as a type
On Tuesday, 29 November 2016 at 15:56:23 UTC, Jerry wrote:
abstract class MyClass {}
abstract class MyClassImpl(T)
Oops, forgot MyClassImpl should extend from MyClass.
abstract class MyClassImpl(T) : MyClass {
...
}
Re: Use class template as a type
On Monday, 28 November 2016 at 11:26:41 UTC, dm wrote:
```
abstract class MyClass(T)
{
public:
@property const(T) value(){return _value;}
@property void value(T val){_value = val;}
...
private:
T _value;
...
}
To avoid having to use the Object class directly you can make an
base class of the class template.
Like:
```
abstract class MyClass {}
abstract class MyClassImpl(T)
{
public:
@property const(T) value(){return _value;}
@property void value(T val){_value = val;}
...
private:
T _value;
...
}
MyClassInt and float inherits from MyClassImpl
```
And use it like:
```
void main() {
MyClass[] objs;
objs ~= new MyClassFloat();
objs ~= new MyClassInt();
}
```
Re: Use class template as a type
On 11/29/2016 02:21 AM, Basile B. wrote: The cast from a class type to a sub class in itself does absolutely nothing. That can't be right. A bad downcast gives you null, so it has to check the dynamic type information. Compare with upcasts which are statically known to be correct, so they don't need to check anything at runtime.
Re: Use class template as a type
On Monday, 28 November 2016 at 14:35:36 UTC, Namespace wrote:
We have a handy dandy syntax for this:
if (MyClassInt subclass = cast(MyClassInt)value) {
writeln(subclass.value);
}
If it doesn't cast to said type (it will be null) that branch
won't execute.
Just out of interest: it looks like a dynamic_cast in C++ which
is considered as slow operation. Is that D cast also a dynamic
cast and also slow? I've never used it, so I'm a bit curious.
The cast from a class type to a sub class in itself does
absolutely nothing. It has only an effect when you call a virtual
method. This is slow because of the indirection that happens when
the right offset has to be found in the VTBL.
Re: Use class template as a type
On 29/11/2016 3:35 AM, Namespace wrote:
We have a handy dandy syntax for this:
if (MyClassInt subclass = cast(MyClassInt)value) {
writeln(subclass.value);
}
If it doesn't cast to said type (it will be null) that branch won't
execute.
Just out of interest: it looks like a dynamic_cast in C++ which is
considered as slow operation. Is that D cast also a dynamic cast and
also slow? I've never used it, so I'm a bit curious.
I wouldn't worry about it. You're already using classes and they are dog
slow in general.
Re: Use class template as a type
We have a handy dandy syntax for this:
if (MyClassInt subclass = cast(MyClassInt)value) {
writeln(subclass.value);
}
If it doesn't cast to said type (it will be null) that branch
won't execute.
Just out of interest: it looks like a dynamic_cast in C++ which
is considered as slow operation. Is that D cast also a dynamic
cast and also slow? I've never used it, so I'm a bit curious.
Re: Use class template as a type
We have a handy dandy syntax for this:
if (MyClassInt subclass = cast(MyClassInt)value) {
writeln(subclass.value);
}
If it doesn't cast to said type (it will be null) that branch
won't execute.
Hell yeah! It's works!
Thank you!
Re: Use class template as a type
Thats because MyClass is a template class. Templates are note types, instansiations of templates can be types. e.g. Myclass!float[] arr; // note this is not MyClass!(float[]); will work. As Rikki suggested using Object[] instead will allow use to store classes of different types. Maybe I must use some stub class or interface and override all methods... But I so like D templates, as a result it's a small and easy to understand code. Or actually it's maybe a XY problem. I'm trying to implement OpenGL material manager and for OpenGL uniforms I tried to write: ``` abstract class Uniform(T) @property ... @property ... T _val;... void method()... ... class FloatUniform: Uniform!float ... override void method()... And in material class class Material ... Texture[] textures; Uniform[] uniforms; ... ``` Maybe i'm totally wrong and better just use glUniformXXX... in my main app instead of ``` auto uniform = new SomeTypeUniform... ... uniform.value = someValue; ``` ?
Re: Use class template as a type
On 29/11/2016 2:56 AM, dm wrote:
On Monday, 28 November 2016 at 11:30:23 UTC, rikki cattermole wrote:
In your case I'd just swap out ``MyClass[] someArray;`` to ``Object[]
someArray;``.
But only because there are no members added without the extra typing
in MyClass.
Remember types in meta-programming in D are not erased, they exist in
the assembly and are unique. Unlike Java who did the implementation
rather wrong.
I'm tried to use Object[], but got error
Error: no property 'value' for type 'object.Object'
I guess I must cast() to MyClassInt or MyClassFloat, but how can I do it?
We have a handy dandy syntax for this:
if (MyClassInt subclass = cast(MyClassInt)value) {
writeln(subclass.value);
}
If it doesn't cast to said type (it will be null) that branch won't execute.
Re: Use class template as a type
On Monday, 28 November 2016 at 11:30:23 UTC, rikki cattermole wrote: In your case I'd just swap out ``MyClass[] someArray;`` to ``Object[] someArray;``. But only because there are no members added without the extra typing in MyClass. Remember types in meta-programming in D are not erased, they exist in the assembly and are unique. Unlike Java who did the implementation rather wrong. I'm tried to use Object[], but got error Error: no property 'value' for type 'object.Object' I guess I must cast() to MyClassInt or MyClassFloat, but how can I do it?
Re: Use class template as a type
On Monday, 28 November 2016 at 11:26:41 UTC, dm wrote:
Hi.
Is it possible to write in D something like this?
```
abstract class MyClass(T)
{
public:
@property const(T) value(){return _value;}
@property void value(T val){_value = val;}
...
private:
T _value;
...
}
...
class MyClassFloat: MyClass!float
...
class MyClassInt: MyClass!int
...
void main()
{
MyClass[] someArray;
---^
someArray ~= new MyClassFloat();
...
someArray ~= new MyClassInt();
...
foreach(myClass; someArray)
if(typeid(myClass) == typeid(MyClassInt))
myClass.value = 999;
else
myClass.value = 123.45f;
...
}
```
When I trying to compile code like above I got
Error: class MyClass(T) is used as a type.
Thats because MyClass is a template class. Templates are note
types, instansiations of templates can be types.
e.g.
Myclass!float[] arr; // note this is not MyClass!(float[]);
will work. As Rikki suggested using Object[] instead will allow
use to store classes of different types.
Re: Use class template as a type
In your case I'd just swap out ``MyClass[] someArray;`` to ``Object[] someArray;``. But only because there are no members added without the extra typing in MyClass. Remember types in meta-programming in D are not erased, they exist in the assembly and are unique. Unlike Java who did the implementation rather wrong.
Use class template as a type
Hi.
Is it possible to write in D something like this?
```
abstract class MyClass(T)
{
public:
@property const(T) value(){return _value;}
@property void value(T val){_value = val;}
...
private:
T _value;
...
}
...
class MyClassFloat: MyClass!float
...
class MyClassInt: MyClass!int
...
void main()
{
MyClass[] someArray;
someArray ~= new MyClassFloat();
...
someArray ~= new MyClassInt();
...
foreach(myClass; someArray)
if(typeid(myClass) == typeid(MyClassInt))
myClass.value = 999;
else
myClass.value = 123.45f;
...
}
```
When I trying to compile code like above I got
Error: class MyClass(T) is used as a type.
