c++ - que - matriz de caracteres en c

¿Cómo pasar arreglos de cadenas de C y Fortran a Fortran?

Question

Estoy tratando de pasar una serie de cadenas de C a una subrutina Fortran, así como de Fortran a esa misma subrutina Fortran. He logrado pasar cadenas simples (es decir, matrices de caracteres 1D) con éxito desde C y Fortran. Sin embargo, tengo problemas con los arreglos de cadenas. Estoy usando el enlace ISO C en el lado de Fortran, e idealmente me gustaría que esto sea lo más transparente posible en el lado de la llamada.

He leído algunas preguntas y respuestas relacionadas. Algunos, (es decir, esto y esto ) son simplemente "Use ISO C" sin más detalles, lo que no ayuda mucho. Esta respuesta fue muy útil (respuesta similar a una pregunta diferente ), pero solo funciona para cadenas simples, donde parece que el c_null_char se reconoce en la cadena Fortran única. No puedo imaginar qué hacer para el caso de matriz sin tener dos rutinas separadas.

Lo que tengo actualmente es una rutina C que quiero pasar la matriz de cadenas ( string ) de:

#include <iostream>

extern "C" void print_hi_array(char input_string[][255]);

using namespace std;

int main() {

  char string[3][255] = {"asdf","ghji","zxcv"};   
  print_hi_array(string);

  return 0;
}

Y, una rutina Fortran similar:

program main
  implicit none
  call print_hi_array( (/"asdf", "ghji", "zxcv"/) )
end program

Hasta ahora, esto es lo que tengo para el receptor:

subroutine print_hi_array(input_string) bind(C)
  use iso_c_binding, only: C_CHAR, c_null_char

  implicit none

  character (kind=c_char, len=1), dimension (3,255), intent (in) :: input_string
  character (len=255), dimension (3) :: regular_string
  character (len=255) :: dummy_string
  integer :: i,j,k

  write (*,*) input_string

  do j = 1 , 3
    dummy_string(:) = c_null_char
    k = 1
    do i = 1 + (j-1)*255, j*255,1
      if (input_string(i) .ne.  c_null_char) then
        write (*,*) "i ",i,j, input_string(i)
        dummy_string(k:k) = input_string(i)
      endif
    k = k +1
    enddo
    regular_string(j) = dummy_string
  enddo

  write (*,*) regular_string

end subroutine print_hi_array

Esto funciona para la función C; Obtengo esta salida:

 asdfghjizxcv
 j=           1
 i            1           1 a
 i            2           1 s
 i            3           1 d
 i            4           1 f
 j=           2
 i          256           2 g
 i          257           2 h
 i          258           2 j
 i          259           2 i
 j=           3
 i          511           3 z
 i          512           3 x
 i          513           3 c
 i          514           3 v
 asdf   ghji   zxcv   

Sin embargo, cuando se hace a través de Fortran me sale sin sentido:

asdfghjizxcv@O,B�@(P,B�]B]6(P,B�@ .......

Parece que no hay c_null_char en este enfoque.

Entonces, ¿cómo puedo escribir una subrutina Fortran para tomar arreglos de cadenas tanto de C como de Fortran?

Answer 1

Fortran usa espacios para llenar el resto de la cadena si se declara más larga que su texto almacenado. No está delimitado por cero, la longitud declarada se almacena en una variable oculta. No contiene c null char y, por lo tanto, está leyendo basura (desbordamiento de búfer). Lo que Fortran debería imprimir cuando tlit imprime una cadena con / 000 no está definido por la norma y depende de la implementación.

En particular, también está transfiriendo una matriz de caracteres (4) con la dimensión 3 a una subrutina que espera mucha más información (255 caracteres, aunque no estoy seguro del orden de los índices). Solo se pasan los punteros, así que creo que no se puede verificar.

Es posible definir la longitud de las cadenas en el constructor de la matriz de esta manera:

[character(255) :: "a","ab","abc"]

Answer 2

Un enfoque que se me ocurrió es modificar la rutina llamada Fortran para usar también el enlace ISO C:

program main

  use iso_c_binding, only: C_CHAR
  implicit none
  character (kind=c_char, len=255), dimension (3) :: input_string

  input_string = (/ "asdf", "ghji", "zxcv" /)

  call print_hi_array(input_string)

end program

Answer 3

Veo en realidad dos maneras de hacer eso. O bien, escribes un ciclo en C y pasas las cuerdas una por una a Fortran, como ya lo hiciste antes. Alternativamente, si quiere pasar la matriz completa y quiere manejar las matrices Fortran y C con la misma rutina, tendrá que hacer una copia apropiada de su matriz C-string. Debajo de un ejemplo que funciona, pero no demasiado probado:

extern "C" void print_array_c(int nstring, char input_string[][255]);

using namespace std;

int main() {

  char string[3][255] = {"asdf","ghji","zxcv"};    
  print_array_c(3, string);

  return 0;
}

Tenga en cuenta que también paso el número de cadenas, para que el ejemplo pueda manejar matrices con varios tamaños. (Sin embargo, se supone que la longitud de las cadenas es de 255 caracteres). En el tamaño de Fortran, uno necesitaría una rutina para convertirlo en cadenas Fortran. Una posible visualización podría ser:

module arrayprint_module
  use, intrinsic :: iso_c_binding
  implicit none

  integer, parameter :: STRLEN = 255

contains

  !> The printing routine, works with Fortran character arrays only.
  subroutine print_array(strings)
    character(len=STRLEN), intent(in) :: strings(:)

    integer :: ii

    do ii = 1, size(strings)
      write(*,*) ii, strings(ii)
    end do

  end subroutine print_array


  !> Converts C string array to Fortran string array and invokes print_array.
  subroutine print_array_c(nstring, cptr) bind(C)
    integer(c_int), value :: nstring
    type(c_ptr), intent(in), value :: cptr

    character(kind=c_char), pointer :: fptr(:,:)
    character(STRLEN), allocatable :: fstrings(:)
    integer :: ii, lenstr

    call c_f_pointer(cptr, fptr, [ STRLEN, nstring ])
    allocate(fstrings(nstring))
    do ii = 1, nstring
      lenstr = cstrlen(fptr(:,ii))
      fstrings(ii) = transfer(fptr(1:lenstr,ii), fstrings(ii))
    end do
    call print_array(fstrings)

  end subroutine print_array_c


  !> Calculates the length of a C string.
  function cstrlen(carray) result(res)
    character(kind=c_char), intent(in) :: carray(:)
    integer :: res

    integer :: ii

    do ii = 1, size(carray)
      if (carray(ii) == c_null_char) then
        res = ii - 1
        return
      end if
    end do
    res = ii

  end function cstrlen


end module arrayprint_module

Tenga en cuenta que la matriz que pasa desde C debe ser contigua para que esto funcione y supongo que el carácter (kind = c_char) es compatible con el tipo de carácter fortran, que normalmente debería ser.