void test();
int main ()
{
test();
}
```
Notice that we don’t need the trailing underscore anymore, since `BIND(C)` takes care of that.
To compile, you also need to link `libgfortran`:
```nohighlight
$ gfortran -c -g test.f90 -o test.o
$ gcc -c -g main.c -o main.o
$ gcc main.o test.o -o test.exe -lgfortran
$ ./test.exe
Size of real(c_float) is 4 and size of real(c_double) is 8
```
---
### Author:  [@wyphan](https://fortran-lang.discourse.group/u/wyphan)
#### Post date: [May 13, 2022, 3:47pm UTC](https://fortran-lang.discourse.group/t/fortran-sending-real-pointer-to-c-program-real-8/3450/6 "2022-05-13T15:47:18Z")
What about `ISO_FORTRAN_ENV`? Is that too new as well?
---
### Author:  [@ivanpribec](https://fortran-lang.discourse.group/u/ivanpribec)
#### Post date: [May 13, 2022, 3:47pm UTC](https://fortran-lang.discourse.group/t/fortran-sending-real-pointer-to-c-program-real-8/3450/7 "2022-05-13T15:47:37Z")
So inside the Fortran routine `test`, you will call a C routine (which is not shown), that will access the array `sizetest`? At the moment your sample program just has declarations, there is zero notion of which direction you’re trying to pass data.
---
### Author:  [@ivanpribec](https://fortran-lang.discourse.group/u/ivanpribec)
#### Post date: [May 13, 2022, 3:56pm UTC](https://fortran-lang.discourse.group/t/fortran-sending-real-pointer-to-c-program-real-8/3450/8 "2022-05-13T15:56:46Z")
In this case, the “lifetime” of the array is limited to the subroutine call. If you want to manipulate the array in C, there must be another C function involved:
main (enter) → test (enter) → ??? (do stuff with array in C) → test (return) → main (return)
---
### Author:  [@wyphan](https://fortran-lang.discourse.group/u/wyphan)
#### Post date: [May 13, 2022, 4:06pm UTC](https://fortran-lang.discourse.group/t/fortran-sending-real-pointer-to-c-program-real-8/3450/10 "2022-05-13T16:06:39Z")
> Should I define it as `real`, `real *8`, `real* 16` etc?
Yes, but as I warned before, the code wouldn’t be portable.
PS: pro tip, use backticks ` to write code so asterisks wouldn’t be interpreted as bold/italic syntax.
---
### Author:  [@ivanpribec](https://fortran-lang.discourse.group/u/ivanpribec)
#### Post date: [May 13, 2022, 4:07pm UTC](https://fortran-lang.discourse.group/t/fortran-sending-real-pointer-to-c-program-real-8/3450/11 "2022-05-13T16:07:47Z")
> [@giraffe](#):
>
> I need to know how to define an array of reals to send. Should I define it as real, real\*8, etc. etc.?
That depends if you want `float` or `double`. You haven’t specified what precision you want.
---
### Author:  [@ivanpribec](https://fortran-lang.discourse.group/u/ivanpribec)
#### Post date: [May 13, 2022, 4:12pm UTC](https://fortran-lang.discourse.group/t/fortran-sending-real-pointer-to-c-program-real-8/3450/12 "2022-05-13T16:12:53Z")
> [@giraffe](#):
>
> The C routine would be something such as:
>
> ```auto
> void gimme (int *dummy)
> {
>
> }
>
> ```
>
> That’s how it is defined in my program. I have multiple calls to gimme with calls sending reals not integers!
>
> An example call would be:
>
> > CALL gimme (sizetest)
Btw, don’t forget about name mangling, in C you’ll need
```cpp
void gimme_(float *dummy);
```
to call it the way you’ve shown.
---
### Author:  [@ivanpribec](https://fortran-lang.discourse.group/u/ivanpribec)
#### Post date: [May 13, 2022, 4:32pm UTC](https://fortran-lang.discourse.group/t/fortran-sending-real-pointer-to-c-program-real-8/3450/14 "2022-05-13T16:32:07Z")
> [@giraffe](#):
>
> The C code doesn’t use float or double. The C code defines the formal argument to be “int \*dummy”. The Fortran code defines the actual argument to be REAL.
I probably need not mention that type-casting through argument passing is a quite dangerous programming practice for many reasons…
In that case you’re already set-up. Just pass the first element:
```fortran
subroutine test()
real :: sizetest(50)
call gimme(sizetest(1))
end subroutine
```
Make sure you calculate the storage sizes correctly, and how many elements your array new aliased array has. Unless you also want to cross the boundary on purpose ⚠ (that’s a joke).
---
### Author:  [@ivanpribec](https://fortran-lang.discourse.group/u/ivanpribec)
#### Post date: [May 13, 2022, 4:47pm UTC](https://fortran-lang.discourse.group/t/fortran-sending-real-pointer-to-c-program-real-8/3450/16 "2022-05-13T16:47:54Z")
There are too many implicit assumptions in your question to give any definitive answer.
Which compilers are you using (it influences the kind parameter)? What is the word size (in bits) of your processor and platform? Size of a C pointer is larger than 4 _what_? Bytes?
If you’re planning to write importable programs, at least share the platform details.
---
### Author:  [@ivanpribec](https://fortran-lang.discourse.group/u/ivanpribec)
#### Post date: [May 13, 2022, 5:20pm UTC](https://fortran-lang.discourse.group/t/fortran-sending-real-pointer-to-c-program-real-8/3450/21 "2022-05-13T17:20:48Z")
An acknowledgement in the product, or perhaps a [donation](https://fortran-lang.discourse.group/t/options-for-funding-fortran-lang-projects/3418/11) from you or your employer would be nice, if this is for commercial purposes.
> [@giraffe](#):
>
> Is it okay to do that if the kind of a Fortran real is 4 and the size of a C pointer is larger than 4?
Have you tried it already, and did it work the way you expected? If you’re not willing to do the reading, you can still get far with experimentation:
> **Take a look**
>
> ```cpp
> /* main.c */
> extern void alias_();
>
> int main(int argc, char const *argv[])
> {
> alias_();
> return 0;
> }
>
> ```
>
> ```fortran
> ! alias.f90
> subroutine alias()
> real :: a(3)
> a(1) = transfer(2,a(1))
> a(2) = transfer(4,a(1))
> a(3) = transfer(6,a(1))
> call print_ints_in_c(a(1))
> end subroutine
>
> ```
>
> ```cpp
> /* print_ints_in_c_.c */
> #include
> void print_ints_in_c_(int *a) {
> for (int i = 0; i < 3; i++) {
> printf("a[%d] = %d\n",i, a[i]);
> }
> }
>
> ```
```txt
$ gfortran -c alias.f90
$ gcc -c print_ints_in_c_.c
$ gcc main.c alias.o print_ints_in_c_.o -o main
$ ./main
a[0] = 2
a[1] = 4
a[2] = 6
```
---
### Author:  [@everythingfunctional](https://fortran-lang.discourse.group/u/everythingfunctional)
#### Post date: [May 13, 2022, 6:24pm UTC](https://fortran-lang.discourse.group/t/fortran-sending-real-pointer-to-c-program-real-8/3450/23 "2022-05-13T18:24:14Z")
> [@giraffe](#):
>
> That’s currently the way I’ve been told to proceed.
At this point I think it’s clear. I suggest to stop what you’re doing and to read this book:
> **[Amazon.com: The Clean Coder: A Code of Conduct for Professional Programmers...](https://www.amazon.com/Clean-Coder-Conduct-Professional-Programmers/dp/B08X7MNTCX)**
>
> Amazon.com: The Clean Coder: A Code of Conduct for Professional Programmers (Audible Audio Edition): Robert C. Martin, Theodore O'Brien, Upfront Books: Books
> This book is about software professionalism. …
>
> … It is a willingness to accept the dire responsibility of being a craftsman and an engineer. …
>
> But that responsibility includes one other thing – one frightening thing. As an engineer, you have a depth of knowledge about your systems and projects that no managers can possibly have. With that knowledge comes the responsibility to _act_.
In continuing to work in a direction you know to be contrary to the best interests of the project, and thus ultimately contrary to the best interests of your employer, you are acting unprofessionally and unethically. As the developer of the project, it is your responsibility to work to the best of your abilities towards what is best for the project, not simply do what you’re told. As hard as it may be some times, that’s what it means to be a professional.
Now, you may think that my statement above is harsh and unhelpful for your situation, but I contend that like a road block with a sign saying “Bridge out ahead” impedes your travel, it encourages you to not to go down a dangerous path.