用于调用 C 函数的 Fortran 接口，该函数返回指向数组的指针

Question

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

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

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

我已经用 cmets 突出显示了我为返回数组指针所做的更改，但我已经没有想法了。 （我可以说，“哦，在过去的糟糕日子里，我可以将一个整数等同于一个 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）等。

或者，如果您想要非常花哨并且语言界面具有灵活性，您可以在 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 函数，因为可互操作的函数不能有数组、指针或可分配的结果。

Answer 2

RE 子程序方法，我想我们可能需要在 C/C++ 端将c_p 声明为int**（而不是int*），以通过参数关联（而不是函数）获取bar 的地址返回值）。所以像......

main.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(:)
  integer(c_int) :: nsize

  interface
    subroutine foosub( c_p, nsize ) bind(c)
      import :: c_ptr, c_int
      implicit none  
      type(c_ptr)    :: c_p    !<-- sends the pointer to c_p
      integer(c_int) :: nsize  !<-- sends the pointer to nsize
    end subroutine
  end interface

  call foosub( c_p, nsize )
  call c_f_pointer( c_p, f_p, [nsize] )

  print *, "nsize  = ", nsize
  print *, "f_p(:) = ", f_p(:)

end program

sub.cpp:

extern "C" {
    int bar[3] = { 2, 3, 4 };
    
    void foosub( int** rtn, int* nsize ) {
        *rtn = bar;
        *nsize = sizeof(bar) / sizeof(int);
    }
 }

编译并运行：

$ g++-10 -c sub.cpp
$ gfortran-10 -c main.f90
$ g++-10 main.o sub.o -lgfortran
$ ./a.out
 nsize  =            3
 f_p(:) =            2           3           4