Ich habe einen abgeleiteten Typ (wrapper) mit einem anderen abgeleiteten Typ (over). Für letztere wurde der Zuweisungsoperator überladen. Da die Zuweisung abgeleiteter Typen standardmäßig komponentenweise erfolgt, würde ich davon ausgehen, dass zwei Instanzen von zugewiesen werdenwrapper würde die überladene Zuordnung für aufrufenover irgendwann. Mit dem folgenden Programm scheint dies jedoch nicht der Fall zu sein. Die überladene Zuordnung wird nur aufgerufen, wenn ich auch die Zuordnung für überladewrapper mit einemausdrücklich Zuordnung zwischen Instanzen vonover (indem Sie die kommentierten Codezeilen auskommentieren). Warum? Ich finde es etwas kontraintuitiv. Gibt es eine Möglichkeit, die Überlastung der Verpackungsart zu vermeiden?

module test_module
  implicit none

  type :: over
    integer :: ii = 0
  end type over

  type :: wrapper
    type(over) :: myover
  end type wrapper

  interface assignment(=)
    module procedure over_assign
    !module procedure wrapper_assign
  end interface assignment(=)

contains

  subroutine over_assign(other, self)
    type(over), intent(out) :: other
    type(over), intent(in) :: self

    print *, "Assignment of over called"
    other%ii = -1

  end subroutine over_assign

  !subroutine wrapper_assign(other, self)
  !  type(wrapper), intent(out) :: other
  !  type(wrapper), intent(in) :: self
  !
  !  other%myover = self%myover
  !
  !end subroutine wrapper_assign

end module test_module

program test
  use test_module
  implicit none

  type(wrapper) :: w1, w2

  print *, "Assigning wrapper instances:"
  w2 = w1

end program test