Fortran 中的重载赋值运算符和 ELEMENTAL 赋值运算符

Question

我正在尝试重载自定义类型的赋值运算符，我希望它能够使用自动分配。我阅读了线程，并写了以下内容：

module overload_op
  implicit none
  PUBLIC ASSIGNMENT(=)

  TYPE, PUBLIC :: my_type
    real :: real_member
  END TYPE my_type

  INTERFACE ASSIGNMENT (=)
    MODULE PROCEDURE assign_my_type_my_type_elem
    MODULE PROCEDURE assign_my_type_my_type
  END INTERFACE

  contains
    ELEMENTAL SUBROUTINE assign_my_type_my_type_elem (var1, var2)
      TYPE(my_type), INTENT(OUT) :: var1
      TYPE(my_type), INTENT(IN) :: var2
      var1%real_member = var2%real_member
    END SUBROUTINE assign_my_type_my_type_elem

    SUBROUTINE assign_my_type_my_type (var1, var2)
      TYPE(my_type), ALLOCATABLE, INTENT(OUT) :: var1(:)
      TYPE(my_type), ALLOCATABLE, INTENT(IN) :: var2(:)
      if (.not.allocated(var1)) allocate(var1(size(var2)))
      ! Call the elemental assignment subroutine for gfortran, fail for Intel
      var1(:) = var2(:)
    END SUBROUTINE assign_my_type_my_type   
end module overload_op

program main

  use overload_op
  implicit none
  TYPE(my_type) :: a(3), b(3)
  TYPE(my_type), allocatable :: c(:), d(:)
  b = a
  allocate(d(3))
  c = d

end program main

根据我的理解，代码应该为可分配数组调用 assign_my_type_my_type，为定义的形状数组（如带有 (:) 规范的数组）或简单的 my_type 变量调用元素。

这与我预期的 gfortran 版本 10.0.1（我有权访问的最新版本）一样有效。但是当我尝试用 ifort 编译时（最多 intel/2020.1）我首先得到以下错误：

error #6437: A subroutine or function is calling itself recursively. [ASSIGN_MY_TYPE_MY_TYPE] var1(:) = var2(:)

当我更改

的代码时

call assign_my_type_my_type_elem(var1(:), var2(:))

我在主程序的变量a、b 没有allocatable 属性时出错。

An allocatable dummy argument may only be argument associated with an allocatable actual argument.

所以我的问题是：我的实现是否完全错误，使用符号 (:) 我不是在调用元素赋值运算符吗？换句话说，gfortran 是否存在错误，英特尔是正确的还是相反？

Answer 1

您的实施不正确，但不容易修复。

只要 a 和 b 是 type(my_type) 的 rank-1 数组，子例程 assign_my_type_my_type 定义定义的赋值 a=b。 assign_my_type_my_type_elem 因此 never 为 rank-1 数组定义定义的赋值：如果没有其他子例程定义赋值，则基本子例程仅定义赋值。

确定子例程是否定义了特定赋值 (Fortran 2018 10.2.1.4)，不区分可分配参数或不可分配参数。（正如我所说 “没有要求声明定义的赋值要求所选择的子程序是可调用的！”）

在assign_my_type_my_type 赋值

var1(:) = var2(:)

仍然由 assign_my_type_my_type 本身定义，即使 var1(:) 不可分配。如果它可能发生，这将是递归的（它不会发生，因为实际参数不可分配）。

您尝试使用

call assign_my_type_my_type_elem(var1(:), var2(:))

而不是定义的赋值在正确指向基本（非递归）子例程的意义上确实有效。正如您所注意到的，它失败了，因为在主程序的定义分配中

b = a

您试图使用不可分配的参数调用子例程 assign_my_type_my_type。您调用此子例程是因为，这又是定义该类型 rank-1 数组分配的子例程。可否调用。

这导致了为什么这不容易修复：不可能创建一个泛型，其中两个具体的区别仅在于其中一个参数的可分配性质。并且不可能select“如果非元素不可调用则元素”。

您必须选择支持可分配左侧或不可分配左侧。或者使用“包装器”类型。

assign_my_type_my_type 有一个很容易解决的问题：var2 是可分配的意味着永远不能通过定义的赋值直接调用子例程。无论如何，该参数在您的使用中不需要可分配，因此请删除该属性。

最后，关于此“自动分配”实现的概念说明。对于第一个参数 allocatable, intent(out)，左侧 always 在赋值之前被释放。这与内在赋值时自动分配的情况不同。

在内部赋值中，仅当与右侧以某种方式（最常见的是大小）不匹配时，才会释放左侧。如果您想在定义的分配中保持一致的行为，您将需要 intent(inout) 并进行各种释放测试。

Fortran 中的重载赋值运算符和 ELEMENTAL 赋值运算符

Overload assignment operator and ELEMENTAL assignment operator in Fortran

fortran

allocation

operator-overloading

gfortran

intel-fortran