arrays - 用于调用 C 函数的 Fortran 接口(interface)，该函数返回指向数组的指针

Question

经过大量搜索，我发现我认为最接近我的问题的答案是 Stack Overflow (SO)，地址为 Fortran interface to call a C function that return a pointer。 ,(近 10 年前发布!)

我引用这个是因为使用该示例使代码保持简单并且仍然说明了我的问题。

我想返回一个在 C++ 中创建/分配的内存的数组，并能够在 Fortran 中分析答案，因为这是该应用程序的大部分代码所在的位置。我的应用程序进入 C++ 以生成整数数组答案并通过 C 接口(interface)将其返回给 Fortran 程序。原始 SO 示例使用单个 double 变量作为返回值。我已将其更改为整数，因为这是我将在我的应用程序中处理的内容。示例代码(已更改)有效。

我已经在注释中突出显示了我为返回数组指针所做的更改，但我已经没有想法了。 (我可以说，“哦，在过去的糟糕日子里，我可以将一个整数等同于一个 iarray(1) 并超出数组的大小”，但我不会。有编码保护很好，但有时这让人沮丧。)

我正在使用 Visual Studio 2017 和 Intel Fortran parallel_studio_xe_2019_update5_composer。

我对原始SO代码的修改示例:

! ps_test_pointers.f90

program foo
  use, intrinsic :: iso_c_binding, only : c_ptr,        &
                                          c_f_pointer,  &
                                          c_int
  implicit none
  type(c_ptr) :: c_p!(:) ! <-------
  integer(c_int), pointer :: f_p!(:) ! <-------

  interface
    function foofunc() bind(c)
      import :: c_ptr
      implicit none  
      type(c_ptr) :: foofunc!(:) ! <-------
    end function foofunc
  end interface

  c_p = foofunc()
  call c_f_pointer(c_p, f_p)
  print *, f_p

end program foo

// ps_test_pointersC.cpp : 'Subroutine' only.

extern "C" {

    int bar[3] = { 2, 3, 4 };
    
    int *foofunc() {
        return bar;
    }

}

正如我上面所说，代码有效，因为它打印出数组的第一个元素 ('2')。

如果我在 f_p 的定义中添加 '(:)'，代码编译不会出错，但是当我运行它时，程序会失败并出现运行时错误:“forrtl: Serious (408): fort: (7):在“call c_f_pointer(c_p, f_p)”行中，当指针F_P没有与目标关联时，尝试使用它。

我尝试将 c_p 声明为一个数组(“c_p(:)”)，但我在同一个地方得到了同样的错误。

我也尝试过调用 c_p 作为子程序的参数——仍然只使用整数:

    ! ps_test_pointers.f90
    
    program foo
      use, intrinsic :: iso_c_binding, only : c_ptr,        &
                                              c_f_pointer,  &
                                              c_int
      implicit none
      type(c_ptr) :: c_p!(:) ! <-------
      integer(c_int), pointer :: f_p!(:) ! <-------
    
      interface
        subroutine foofunc(c_p) bind(c)
          import :: c_ptr
          implicit none  
          type(c_ptr) :: c_p!(:) ! <-------
        end subroutine foofunc
      end interface
    
      call foofunc(c_p)
      call c_f_pointer(c_p, f_p)
      print *, f_p
    
    end program foo
    

    // ps_test_pointersC.cpp : 'Subroutine' only.
    
    extern "C" {
    
        int bar[3] = { 2, 3, 4 };
        
        void foofunc(int *rtn) {
            rtn = bar;
        }
    
    }

但是在 C 函数中创建的指针永远不会在返回时被分配给 c_p(因此 f_p 永远不会被定义)。

阅读这个问题，我希望我不是处于编译器实现的最前沿，并且已经暴露了限制收紧但无法应对所有用例之间的问题!

有解决办法吗？

Answer 1

你的 C 函数返回一个指针标量；您想将此目标与 Fortran 数组相关联。这意味着你有声明

type(c_ptr) :: c_p                  ! <- scalar address
integer(c_int), pointer :: f_p(:)   ! <- array to associate

在调用 c_f_pointer 时，您可以使用另一个参数指定 Fortran 指针数组的形状。但是，在这种情况下，Fortran 端无法知道 C 函数返回的数组有多大。

考虑:

use, intrinsic :: iso_c_binding
implicit none

type(c_ptr) :: c_p
integer(c_int), pointer :: f_p(:)

interface
    function foofunc() bind(c)
      import :: c_ptr
      implicit none  
      type(c_ptr) :: foofunc
    end function foofunc
end interface

c_p = foofunc()
call c_f_pointer(c_p, f_p, [3])
print *, f_p

end

如果您不喜欢神奇的数字 3，您需要找到其他方法来获取该数字(就像在 C 世界中调用此函数一样)。您可以将长度作为额外的参数，如 roygvib's subroutine例如，作为链接关联的额外变量，通过单独的查询调用(例如字符数组如何使用strnlen)等

或者，如果您想要非常花哨并且在语言界面上具有灵 active ，您可以在 C 子例程中使用“改进的互操作性”功能来进行 Fortran 内存管理:

program foo
  use, intrinsic :: iso_c_binding, only : c_int

  implicit none
  integer(c_int), pointer :: f_p(:)

  interface
     subroutine foosub(f_p) bind(c)
       import c_int
       implicit none  
       integer(c_int), pointer, intent(out) :: f_p(:)
     end subroutine foosub
  end interface
    
  call foosub(f_p)
  print *, f_p
    
end program foo

#include "ISO_Fortran_binding.h"

int bar[3] = { 2, 3, 4 };
        
void foosub(CFI_cdesc_t* f_p) {
  CFI_index_t nbar[1] = {3};
  CFI_CDESC_T(1) c_p;

  CFI_establish((CFI_cdesc_t* )&c_p, bar, CFI_attribute_pointer, CFI_type_int,
                nbar[0]*sizeof(int), 1, nbar);
  CFI_setpointer(f_p, (CFI_cdesc_t *)&c_p, NULL);
}

如果您愿意，也可以使用可分配变量而不是指针变量。

这种方法不适用于 Fortran 函数，因为可互操作的函数不能有数组、指针或可分配的结果。