Please, this is not a wish, it is a bug.

I think as long as the workaround is not documented,
it is normal priority.
So either documentation or fix would be necessary.

I also appreciate a lot that there is now a workaround.
On the other hand, I would expect,
that for both types of declaration,
behind the scenes the same code runs
and so initialization works either with both notations or with none.
So I think , rework the code would be fine.

I think it is not worth fixing. MATLAB disbands from the `obj = class (obj, 'cname')` syntax in favor of classdef, that works like a charm for you example, that was flawed by the way:

Legacy class in "@xxx"-folder:

+verbose+
function obj = xxx(in)
  if nargin == 0
    fprintf('xxx: empty arguments\n');
    obj.str = 'no init';
  else
    fprintf('xxx: argument %d\n', in);
    obj.str = in;
  end
  obj = class(obj, 'xxx');
end % function
-verbose-

Using classdef:

+verbose+
classdef xxx2
 
  properties
    str
  end
 
  methods
    function obj = xxx2(in)
      if nargin == 0
        fprintf('xxx: empty arguments\n');
        obj.str = 'no init';
      else
        fprintf('xxx: argument %d\n', in);
        obj.str = in;
      end
    end
  end
 
end
-verbose-

Octave:

+verbose+

>> a(1,3) = xxx(3)

xxx: argument 3
a =

  <class xxx>

>> a.str

error: invalid index for class

>> b(1,3) = xxx2(3)

xxx: argument 3
xxx: empty arguments
b =

<object array xxx2>

>> b.str

ans = no init
ans = no init
ans =  3
-verbose-

MATLAB R2016b:

+verbose+

>> a(1,3) = xxx(3)

xxx: argument 3
xxx: empty arguments

a =

xxx object: 1-by-3

>> a.str

Access to an object's fields is only permitted within its methods.
 

>> b(1,3) = xxx2(3)

xxx: argument 3
xxx: empty arguments

b =

  1×3 xxx2 array with properties:

    str

>> b.str

ans =

no init


ans =

no init


ans =

     3
-verbose-

Therefore I declare this as "won't fix", as a future save workaround exists and close this item.

This is definitely not a wish but a real bug.
Matlab documentation clearly says,
that the constructor with no arguments is invoked
to initialize a(1),...a(6),
whereas to initialize a(7) the constructor given explicitly is invoked.

In contrast to this,
octave creates a kind of raw objects
without attributes
but with the correct class assigned.
This is not done via invocation of constructor,
but hardcoded.

The result for me, implementing an arithmetics
with class pn (polymorphic number) is,
that in Matlab I would create the 0 value with pn().
That way, a(1),...,a(6) are initialized implicitly with
the 0 value in pn.

This is to make it compatible with double,
where a(7)=4.3
makes a(1),...,a(6) be initialized with the double value 0.

Currently, octave initializes a(1),...a(6)
with some half finished objects
which carry no value at all, while being of the correct class.


As regards the question, whethe the constructor pn()
shall be invoked for a(1),...,a(n) separately,
or just once and then copied,
this is almost immaterial,
because if pn() has no side effects,
the result is the same.
Note that not the reference is copied, but the object.

It is just a matter of optimization,
that the constructor is invoked once only,
and the rest is just memory copy.

So, if I could vote, I would vote urgently,
to recover severity: it is a bug.

The result for me is,
that I very frequently have to check for the object
with all attributes uninitialized,
which is anoying. !!!!

Thank you for considering. !!!!

According to

https://de.mathworks.com/help/matlab/matlab_oop/initialize-object-arrays.html

if matlab is called with
a(7) = SimpleValue(7),
SimpleValue a class constructor,
then for initializing a(1), ...a(6),
the default constructor is invoked as SimpleValue().

I tried this with a very simple class
defined in folder @xxx
with the following constructor:

function obj = xxx(in)
  if nargin == 0
    printf("xxx: empty arguments");
    obj.str = "no init";
  else
    printf("xxx: argument %d ", in);
    obj.str = in;
  end
  class(obj, "xxx");
end % function

When assigning
a(3)=xxx(3),
then this constructor is invoked only once.
If I try a(3), then str is initialized,
whereas if I try a(2), it is not initialized.


This seems a bug.
In my case, I implement an arithmetics in java
which shall behave here as double,
i.e. the default constructor without arguments
shall return an object with 0 value,
but it returns an uninitialized object.