Take the 2-minute tour ×

I think title says what I need. I know we can use "asd" function to do this, but for some reasons I need to do the allocation in Fortran (i.e. in subroutine "asd_"). Here is the C code:

#include <stdio.h>

void asd(float **c) {
  *c = (float *) malloc (2*sizeof(float));
  **c =123;

void asd_(float **c);

main () {
  float *c;
// asd(&c); would do the job perfectly
  printf("%f %f \n",c[0],c[1]);
  return 0;

And here is the Fortran code:

  subroutine asd(c)

  implicit none

  real, pointer, allocatable ::c(:)

  print *, associated(c)
  if(.not. associated(c))  allocate(c(2))

  end subroutine 

This randomly gives segmentation fault. Any help would be appreciated.

share|improve this question
What operating system are you using? –  xxbbcc Mar 13 '12 at 3:27
I agree with andrew. I know there is a ISO_C_BINDING module in XL compilers that support interoperability/compatibility between intrinsic C and Fortran types. I believe there is a similar module for gcc. Check this -> gcc.gnu.org/onlinedocs/gfortran/ISO_005fC_005fBINDING.html –  Gargi Srinivas Mar 13 '12 at 5:47
It is linux. I am using ifort and icc compilers. Anyway, MSB solution works. Thanks. –  mem Mar 13 '12 at 19:30
add comment

2 Answers

The Fortran 2003 ISO C Binding provides a portable way to do this. It is implemented in many compilers. Here is example code.

#include <stdio.h>

void test_mem_alloc ( float ** array );

int main ( void ) {

   float * array;
   test_mem_alloc (&array);

   printf ( "Values are: %f %f\n", array [0], array [1] );

   return 0;


subroutine test_mem_alloc ( c_array_ptr ) bind (C, name="test_mem_alloc")

   use, intrinsic :: iso_c_binding
   implicit none

   type (c_ptr), intent (out) :: c_array_ptr
   real (c_float), allocatable, dimension (:), target, save :: FortArray

   allocate (FortArray (1:2) )
   FortArray = [ 2.5_c_float, 4.4_c_float ]

   c_array_ptr = c_loc (FortArray)

end subroutine test_mem_alloc
share|improve this answer
+1: An answer by someone who knows modern Fortran. –  High Performance Mark Mar 13 '12 at 9:26
You are awesome. Thank you very much. –  mem Mar 13 '12 at 19:28
add comment
up vote 0 down vote accepted

Here is also another solution, if you want to use Fortran intrinsic types. This was my case, since I needed to call routines from an external library, using the pre-specified data types. This is basically done with a wrapper Fortran subroutine. Here is the C code:

void mywrap_(void **);
void myprint_(void *);

main () {
  void *d;
  return 0;

And here is the wrapper:

  subroutine mywrap(b)
  implicit none
  include "h.h"     
  type(st), target, save :: a
  integer, pointer :: b
     subroutine alloc(a)
        include "h.h"
        type(st) a
     end subroutine alloc
  end interface

  call alloc(a)
  b => a%i

And the Fortran codes:

  subroutine alloc(a)
  implicit none 
  include "h.h"
  type(st) a

  a%i = 2
  a%r = 1.5
  if (allocated(a%s)) deallocate(a%s)
  a%s(1) = 1.23
  a%s(2) = 1234
  subroutine myprint(a)
  implicit none
  include "h.h"     
  type(st) a

  print *,"INT: ", a%i
  print *,"REAL: ", a%r
  print *,"ALLOC: ", a%s

And the header file "h.h":

  type st
     integer i
     real r
     real, allocatable :: s(:)
  end type

Note, this way all the objects are opaque in the C.

share|improve this answer
add comment

Your Answer


