Swift: how to understand dynamic method dispatching in init method?

Question

I find that the dynamic method dispatching in init method of Swift is different from which in C++, can anyone explain why?

This is the demo code and its output:

In Swift:

class Object {
  init() {
    a()
  }

  func a() {
    print("Object")
  }
}

class SubObject: Object {
    override init() {
    }

    override func a() {
      print("SubObject")
    }
}

let a = SubObject()
// output: SubObject

In C++:

class Object {
public:
    Object() {
        a();
    }

    virtual void a() {
        std::cout << "Object" << std::endl;
    }
};

class SubObject: public Object {
public:
    SubObject() {
    }

    virtual void a() {
        std::cout << "SubObject" << std::endl;
    }
};

int main(int argc, const char * argv[]) {

    SubObject s;

    return 0;
}
// output: Object

As you can see, these code above write in Swift and C++ are nearly the same, but their output is quite different, while Swift seems that it finds the override method and called the derived one, the C++ still called the super's.

Here at LearnCpp, it says:

Do not call virtual functions from constructors or destructors Here’s another gotcha that often catches unsuspecting new programmers. You should not call virtual functions from constructors or destructors. Why?

Remember that when a Derived class is created, the Base portion is constructed first. If you were to call a virtual function from the Base constructor, and Derived portion of the class hadn’t even been created yet, it would be unable to call the Derived version of the function because there’s no Derived object for the Derived function to work on. In C++, it will call the Base version instead.

A similar issue exists for destructors. If you call a virtual function in a Base class destructor, it will always resolve to the Base class version of the function, because the Derived portion of the class will already have been destroyed.