Ack that. Trying again with 'datetime' in the Matlab online tool

>> x = datetime(zeros(100, 3));
>> size(x)
ans = 1×2

    100     1

>> s = whos('x'); s.bytes
ans = 801

So yeah, it does look like the 'bytes' size of classdef objects defined in m files reflects the sum of the sizes of its properties.

Since 'sizeof' is not a defined Matlab function or object method, it's intentionally not used as an override when getting the size of objects in 'whos'.

I tested with 'containers.Map' in the Matlab online feature, and the size of the map object is 8 bytes, regardless of how many entries are added to the map.

I found this: https://www.mathworks.com/matlabcentral/answers/14837-how-to-get-size-of-an-object

Where a Mathworks employee wrote

> Unfortunately, there is no way to check the amount of memory that is being
> occupied by class objects, since MATLAB is storing references to C++
> objects. As you say, whos is representing the size of the pointer to the
> created object, which will be 60 bytes (in 32-bit) or 112 bytes (in 64-bit).
>
> However, you can create a function in your class and calculate the real
> memory of the object by manually querying for the memory of each of the
> properties in the class, like you do with whos for a matrix.

So I think we can choose to return whatever we want to for 'whos' and 'sizeof' on class objects, since there is no compatibility problem here.

Sorry, I'm leery of running any tests on Matlab, for fear of violating the Matlab license's non-compete clause.

Oh. Also, for complex objects, counting the total number of raw bytes in their object/memory graph could be a complex, expensive operation because you have to traverse a lot of objects. So maybe the default behavior of sizeof() and the Bytes column in whos() should be to return/show NaN and '?', respectively, to avoid causing them to hang in casual usage.

It looks like the default implementation of sizeof() returns 0 for user-defined classdef objects. (I think this also causes the Bytes for classdef objects in the `whos` output to be displayed as 0.)

IMHO, it would make more sense for the default implementation of sizeof() to  do a `builtin('struct', x)` on user-defined objects and return that. That would give you a decent approximation of the Octave-managed raw data being used by those objects.

To reproduce:

Define MyDumbClass.m:

classdef MyDumbClass

  properties
    data
  endproperties

  methods
    function this = MyDumbClass (data)
      this.data = data;
    endfunction
  endmethods

endclassdef

Create one and check its size:

>> x = MyDumbClass(zeros(1000, 1000))
x =
<object MyDumbClass>

>> sizeof(x)
ans = 0
>> sizeof(x.data)
ans =  8000000

I think that sizeof(x) should be returning 8000000 instead of 0.