Trying to understand why we can’t subclass something like a uint8 and add a property. Say I want to enumerate data types and conveniently bundle the size of instances of the type in bytes.
In this first case, we specify which uint8 we want each enumeration member to correspond to in parens next to the name, and this works fine:
classdef DataTypeEnumeration < uint8
enumeration
UINT8 (0)
UINT16 (1)
UINT32 (2)
UINT64 (3)
end
end
In totally user-defined classes we use these parens to set properties, like
classdef DataTypeEnumeration
properties
underlying_value
end
enumeration
UINT8 (0)
UINT16 (1)
UINT32 (2)
UINT64 (3)
end
methods
function obj = DataTypeEnumeration(v)
obj.underlying_value = v
end
end
end
but it does not seem there is any way to use this syntax for the built-in type, even if I am not actually trying to define a new property:
classdef DataTypeEnumeration < uint8
properties
some_special_underlying_value_property
end
enumeration
UINT8 (0)
UINT16 (1)
UINT32 (2)
UINT64 (3)
end
methods
function obj = DataTypeEnumeration(v)
obj.some_special_underlying_value_property = uint8(v)
end
end
end
or even just
classdef DataTypeEnumeration < uint8
enumeration
UINT8 (0)
UINT16 (1)
UINT32 (2)
UINT64 (3)
end
methods
function obj = DataTypeEnumeration(v)
obj = uint8(v)
end
end
end
seems like it should work. It kind of feels like the only reason we can’t tack on a property to an enumeration of some built-in type is because the interface doesn’t support it, which would be sad. What would be the harm in being able to let the parent object be constructed with the first argument and set properties with following arguments, like
classdef DataTypeEnumeration < uint8
properties
bytes
end
enumeration
UINT8 (0, 1)
UINT16 (1, 2)
UINT32 (2, 4)
UINT64 (3, 8)
end
methods
function obj = DataTypeEnumeration(b)
obj.bytes = b
end
end
endTrying to understand why we can’t subclass something like a uint8 and add a property. Say I want to enumerate data types and conveniently bundle the size of instances of the type in bytes.
In this first case, we specify which uint8 we want each enumeration member to correspond to in parens next to the name, and this works fine:
classdef DataTypeEnumeration < uint8
enumeration
UINT8 (0)
UINT16 (1)
UINT32 (2)
UINT64 (3)
end
end
In totally user-defined classes we use these parens to set properties, like
classdef DataTypeEnumeration
properties
underlying_value
end
enumeration
UINT8 (0)
UINT16 (1)
UINT32 (2)
UINT64 (3)
end
methods
function obj = DataTypeEnumeration(v)
obj.underlying_value = v
end
end
end
but it does not seem there is any way to use this syntax for the built-in type, even if I am not actually trying to define a new property:
classdef DataTypeEnumeration < uint8
properties
some_special_underlying_value_property
end
enumeration
UINT8 (0)
UINT16 (1)
UINT32 (2)
UINT64 (3)
end
methods
function obj = DataTypeEnumeration(v)
obj.some_special_underlying_value_property = uint8(v)
end
end
end
or even just
classdef DataTypeEnumeration < uint8
enumeration
UINT8 (0)
UINT16 (1)
UINT32 (2)
UINT64 (3)
end
methods
function obj = DataTypeEnumeration(v)
obj = uint8(v)
end
end
end
seems like it should work. It kind of feels like the only reason we can’t tack on a property to an enumeration of some built-in type is because the interface doesn’t support it, which would be sad. What would be the harm in being able to let the parent object be constructed with the first argument and set properties with following arguments, like
classdef DataTypeEnumeration < uint8
properties
bytes
end
enumeration
UINT8 (0, 1)
UINT16 (1, 2)
UINT32 (2, 4)
UINT64 (3, 8)
end
methods
function obj = DataTypeEnumeration(b)
obj.bytes = b
end
end
end Trying to understand why we can’t subclass something like a uint8 and add a property. Say I want to enumerate data types and conveniently bundle the size of instances of the type in bytes.
In this first case, we specify which uint8 we want each enumeration member to correspond to in parens next to the name, and this works fine:
classdef DataTypeEnumeration < uint8
enumeration
UINT8 (0)
UINT16 (1)
UINT32 (2)
UINT64 (3)
end
end
In totally user-defined classes we use these parens to set properties, like
classdef DataTypeEnumeration
properties
underlying_value
end
enumeration
UINT8 (0)
UINT16 (1)
UINT32 (2)
UINT64 (3)
end
methods
function obj = DataTypeEnumeration(v)
obj.underlying_value = v
end
end
end
but it does not seem there is any way to use this syntax for the built-in type, even if I am not actually trying to define a new property:
classdef DataTypeEnumeration < uint8
properties
some_special_underlying_value_property
end
enumeration
UINT8 (0)
UINT16 (1)
UINT32 (2)
UINT64 (3)
end
methods
function obj = DataTypeEnumeration(v)
obj.some_special_underlying_value_property = uint8(v)
end
end
end
or even just
classdef DataTypeEnumeration < uint8
enumeration
UINT8 (0)
UINT16 (1)
UINT32 (2)
UINT64 (3)
end
methods
function obj = DataTypeEnumeration(v)
obj = uint8(v)
end
end
end
seems like it should work. It kind of feels like the only reason we can’t tack on a property to an enumeration of some built-in type is because the interface doesn’t support it, which would be sad. What would be the harm in being able to let the parent object be constructed with the first argument and set properties with following arguments, like
classdef DataTypeEnumeration < uint8
properties
bytes
end
enumeration
UINT8 (0, 1)
UINT16 (1, 2)
UINT32 (2, 4)
UINT64 (3, 8)
end
methods
function obj = DataTypeEnumeration(b)
obj.bytes = b
end
end
end enumeration, subclass, built-in, properties MATLAB Answers — New Questions

​