使用 Fortran 中的内存数据调用 C 代码

Question

我有一个复杂的 C++ 对象，我想在我的 Fortran 代码中使用它。 一般来说，从 Fortran 调用 C++ 代码是没有问题的（例如只需要提供一个合适的接口与 C 链接）。

但是我的问题是我希望我对 C++ 的 Fortran 调用对我称之为持久对象的对象进行操作：由第一个 init 函数创建并由其他 C++ 函数操作的 C++ 对象。

更具体地说，假设我有以下 C++ 代码

struct A {
    public:
      void do() { // do something on complicated stuff
    private:
      ... // complicated stuff
};

extern "C" {
    void* init_A() {
         A* a = new A();
         return reinterpret_cast<void*>(a);
    }

    void doSth(void* ptr_to_A) {
         A* a = reinterpret_cast<A*>(ptr_to_A);
         a.do();
    }

    void teardown_A(void* ptr_to_A) {
         A* a = reinterpret_cast<A*>(ptr_to_A);
         delete a;
    }
}

以及下面的fortran代码（假设是main()）：

USE, INTRINSIC :: ISO_C_BINDING, ONLY: C_PTR
INTERFACE
    TYPE(C_PTR) FUNCTION init_A() BIND(C, NAME='init_A')
        USE, INTRINSIC :: ISO_C_BINDING, ONLY: C_PTR
        IMPLICIT NONE
    END FUNCTION init_A

    SUBROUTINE doSth(ptr_to_A) BIND(C, NAME='doSth')
        USE, INTRINSIC :: ISO_C_BINDING, ONLY: C_PTR
        IMPLICIT NONE
        TYPE(C_PTR), INTENT(IN), VALUE :: ptr_to_A
    END SUBROUTINE doSth

    SUBROUTINE teardown_A(ptr_to_A) BIND(C, NAME='teardown_A')
        USE, INTRINSIC :: ISO_C_BINDING, ONLY: C_PTR
        IMPLICIT NONE
        TYPE(C_PTR), INTENT(IN), VALUE  :: ptr_to_A
    END SUBROUTINE teardown_A
END INTERFACE

现在在我的真实代码中，它可以编译、链接，有时可以工作，但有时不能： 似乎 init_A() 中分配的内存不保证 Fortran 代码保持不变）

我无法在互联网上找到任何相关信息：

• 您知道是否有任何标准机制来确保由 init_A_() 分配的内存保持不变并且仍然由 fortran 代码分配？
• 您知道其他适合我的问题的机制吗？

另外，有人能解释一下为什么内存管理不正确吗？ 直到现在，我还以为

• Fortran 会向操作系统请求内存，C++ 也是如此，

• 操作系统为 Fortan 和 C++ 提供的内存段不相关，并且保证不重叠，

• 如果请求新内存，操作系统不会让 Fortran 使用 C++ 内存，直到 C++ 释放它

• 通过调用 teardown_A() 或程序（即 Fortran main）终止时释放 C++ 内存

编辑：我用 IanH 的答案更新了我的代码，但这仍然不起作用（段错误，在从 Fortran 调用 doSth() 时释放了部分内存

我贴的原代码如下（供cmets参考）

struct A {
    public:
      void do() { // do something on complicated stuff
    private:
      ... // complicated stuff
};

extern "C" {
    void init_A_(long* ptr_to_A) { // ptr_to_A is an output parameter
         A* a = new A();
         *ptr_to_A = reinterpret_cast<long>(a);
    }

    void doSth_(long* ptr_to_A) {
         A* a = reinterpret_cast<A*>(*ptr_to_A);
         a.do();
    }

    void teardown_A_(long* ptr_to_A) {
         A* a = reinterpret_cast<A*>(*ptr_to_A);
         delete a;
    }
}

以及 Fortran 代码：

integer :: ptr_to_A

call init_A(ptr_to_A)

do i=1,10000
    call doSth(ptr_to_A)
enddo

call teardown_A(ptr_to_A)

Answer 1

Fortran 2003 将 C 互操作性引入了 Fortran 语言。这种语言特性使得编写可以以可移植和健壮的方式一起工作的 Fortran 和 C（以及因此 C++）源代码变得更加容易。除非您因为其他原因而无法使用该级别的语言，否则您应该非常使用此功能。

指针间接存在问题 - 指向 C++ 对象的指针是存储在 long 还是指向 long 的指针（doSth_ 和 teardown_A_ 中的强制转换的操作数应该在它们之前有一个 *）。这取决于您使用的 C++ 和 Fortran 编译器，但 C long、C 指针和 Fortran 默认类型整数之间的大小可能不匹配。

下面的修改示例显示了使用 Fortran 2003 的 C 互操作性功能的方法。

// C++
struct A {
    public:
      void do_something()
      {
         // ...
      }
    private:
      // ...
};

// Note no need for trailing underscore.
extern "C" {
    // Note pointer to pointer to void.
    void init_A(void** ptr_ptr_to_A) {
         A* a = new A;
         *ptr_ptr_to_A = reinterpret_cast<void*>(a);
    }

    void doSth(void* ptr_to_A) {
         A* a = reinterpret_cast<A*>(ptr_to_A);
         a->do_something();
    }

    void teardown_A(void* ptr_to_A) {
         A* a = reinterpret_cast<A*>(ptr_to_A);
         delete a;
    }
}


! Fortran 2003
  USE, INTRINSIC :: ISO_C_BINDING, ONLY: C_PTR
  IMPLICIT NONE
  INTERFACE
    SUBROUTINE init_A(ptr_to_A) BIND(C, NAME='init_A')
      USE, INTRINSIC :: ISO_C_BINDING, ONLY: C_PTR
      IMPLICIT NONE
      ! This argument is a pointer passed by reference.
      TYPE(C_PTR), INTENT(OUT) :: ptr_to_A
    END SUBROUTINE init_A
    SUBROUTINE doSth(ptr_to_A) BIND(C, NAME='doSth')
      USE, INTRINSIC :: ISO_C_BINDING, ONLY: C_PTR
      IMPLICIT NONE
      ! This argument is a pointer passed by value.
      TYPE(C_PTR), INTENT(IN), VALUE :: ptr_to_A
    END SUBROUTINE doSth
    SUBROUTINE teardown_A(ptr_to_A) BIND(C, NAME='teardown_A')
      USE, INTRINSIC :: ISO_C_BINDING, ONLY: C_PTR
      IMPLICIT NONE
      ! This argument is a pointer passed by value.
      TYPE(C_PTR), INTENT(IN), VALUE :: ptr_to_A
    END SUBROUTINE teardown_A
  END INTERFACE
  TYPE(C_PTR) :: ptr_to_A
  INTEGER :: i
  !****
  CALL init_A(ptr_to_A)
  DO i = 1, 100
    CALL doSth(ptr_to_A)
  END DO
  CALL teardown_A(ptr_to_A)
END