Why not just use the factory method?

class MyClass {
     const int a, b, c;
     MyClass(int a_, int b_, int c_)
      : a(a_), b(b_), c(c_)
     { }
public:
static MyClass factory( int someBaseValue )
      {
          auto someDerivedValue = SomeHeavyOperation(someBaseValue);
          return MyClass{
              someDerivedValue * 2,
              someDerivedValue / 3,
              someDerivedValue + 4,
          };
      }
};

Bonus:

I do not know much about them, but the added benefit might be that the factory can be a co-routine. A constructor can not be a co-routine.
Thus in that case SomeHeavyOperation() will not stop "everything".

On Wed, 1 Sept 2021 at 11:57, Edward Catmur via Std-Proposals <std-proposals@lists.isocpp.org> wrote:
On Wed, 1 Sept 2021 at 10:23, Artyom Lebedev via Std-Proposals <std-proposals@lists.isocpp.org> wrote:
You are right, I missed this feature. However, it is still a matter of
convenience. Besides passing list of parameters, you also need to ensure
the delegating constructor signature is not colliding with any other
constructor, requiring constructions like this:

class MyClass {
public:
     const int a, b, c;

     MyClass(int someBaseValue)
      : MyClass(SomeHeavyOperation(someBaseValue), ConstructorTag())
     {}

private:
     struct ConstructorTag {};

     MyClass(int someDerivedValue, ConstructorTag) :
         a(someDerivedValue * 2),
         b(someDerivedValue / 3),
         c(someDerivedValue + 4)
     {}
};

or introducing dedicated structure for passing construction parameters
in, which is quite verbose.

Introducing delegated constructors made much code less verbose.
Introducing variables in member initializer list could make the next
step to make it even neater.

It'd be enough if there were a way to re-enable aggregate initialization (maybe with private access) in the presence of constructors; then we could use an iife and named initialization:

class MyClass {
public:
     const int a, b, c;

     MyClass(int someBaseValue)
      : MyClass([&]
      {
          auto someDerivedValue = SomeHeavyOperation(someBaseValue);
          return MyClass{
              .a = someDerivedValue * 2,
              .b = someDerivedValue / 3,
              .c = someDerivedValue + 4,
          };
      }())
     {}
};

--
Std-Proposals mailing list
Std-Proposals@lists.isocpp.org
https://lists.isocpp.org/mailman/listinfo.cgi/std-proposals