C++ 向 Fortran 传递字符串的简易解决方案

EnSafe

向 Fortran 传递字符串的简易解决方案



摘要：C++ 字符串传递给 Fortran 时，需要将字符串内容和长度同时传送，Windows 下默认的方式是长度紧跟字符串。通过学习 CHEMKIN 部分 C++ 语言调用 Fortran 过程的源代码，可以看出其解决方案很简易。其实质是创建 CHARACTER 类，包含了字符串内容和长度成员。字符串传递前，将函数原型中的字符串声明为 CHARACTER 类型实现隐式转换。

源代码见附件： ForString_20140316.rar (13.26 KB, 下载次数: 50288)

2014-3-17 08:44 上传

点击文件名下载附件

1、CHARACTER 类

1.1 头文件 FortranString.h

#include <string.h>

/*
class CHARACTER
===============
A minimal class used when passing string arguments from C++
to FORTRAN 77 (received as FORTRAN 77 CHARACTER strings), and
subsequently returned back to C++ as properly zero terminated
strings.

Method used for zero-termination:
=================================
When the CHARACTER destructor is activated the zero-termination
of the c-string is automatically managed. Zero termination is
also done each time a string array is subscripted using
CHARACTER::operator()(size_t index)

FORTRAN Assumptions:
====================
(1) F77 truncates strings when CHARACTER variable is short
(2) F77 pads variable with blanks when assigned string is short
(3) F77 represents a string as a pointer followed by a length
(4) A string array is stored in contiguous memory

Author: Carsten A. Arnholm, 20-AUG-1995

Updates:
04-MAR-1996 Added features for handling arrays of strings
16-MAR-1996 Tested array features, explicit padding included
29-JUL-1996 Tested portability to SGI/Unix, moved decl. of destructor
04-APR-1997 Using strncpy instead of strcpy in operator=(char* str);
*/

// 定义导入函数属性
#define DLLExport __declspec(dllexport)

class DLLExport CHARACTER{
public:
    CHARACTER(char* cstring);
    CHARACTER(char* cstring, const size_t lstr);
    ~CHARACTER();
    CHARACTER operator()(size_t index);
    void  pad(size_t first, size_t howmany = 1);
    void  operator=(char* str);
    operator char*();
public:
    char*   rep;  // Actual string
    size_t  len;  // String length
};


1.2 #include "FortranString.cpp"

inline CHARACTER::CHARACTER(char* cstring)
: rep(cstring), len(strlen(cstring))
{};

inline CHARACTER::CHARACTER(char* cstring, const size_t lstr)
: rep(cstring), len(lstr)
{
    // find position from where to start padding
    size_t slen = strlen(rep);                // upper limit
    size_t actual = (slen < len) ? slen : len;   // actual <= len.
    for (size_t i = actual; i<len; i++) rep[i] = ' ';  // Do the padding.
}

inline CHARACTER::~CHARACTER() {
    if (rep[len] == '\0') return;     // catches string constants

    for (int i = len - 1; i >= 0; i--) {
        if (rep[i] == '\0') break;      // already zero terminated

        if (rep[i] != ' ') {            // non-blank discovered, so
            rep[i + 1] = '\0';            // zero-terminate and jump out
            break;
        }
    }
}

inline CHARACTER CHARACTER::operator()(size_t index)
{
    // Construct a temporary CHARACTER object for the array element
    // identified by "index" in order to zero-terminate that element
    size_t pos = index*len;          // start pos of array element
    CHARACTER element(rep + pos, len);  // construct new CHARACTER.
    return element;                  // destructor called here.
}

inline void  CHARACTER::pad(size_t first, size_t howmany)
{

    size_t pos = 0, i = 0, stop = first + howmany - 1;
    for (size_t index = first; index <= stop; index++) {
        pos = index*len;
        size_t slen = strlen(rep + pos);             // upper limit
        size_t actual = (slen < len) ? slen : len;
        for (i = pos + actual; i<pos + len; i++) rep[i] = ' ' ;  // Do the padding.
    }
}

inline void CHARACTER::operator=(char* str)
{
    strncpy(rep, str, len);    // this will copy a zero if str < rep
    rep[len - 1] = '\0';       // zero terminate in case strncpy did not
    size_t slen = strlen(rep);                // upper limit
    size_t actual = (slen < len) ? slen : len;   // actual <= len.
    for (size_t i = actual; i<len; i++) rep[i] = ' ';  // Do the padding.
}

inline CHARACTER::operator char*()
{
    return rep;
}

将该类编写为动态库，以便其它程序使用。

2. Fortran 程序

以下 Fortran 程序用于打开文件，关闭文件，类似 CHEMKIN C 语言接口函数 CCOPEN、CCCLOS。

注意，通过 -Gm 选项实现 StdCall 调用约定和参数引用传递。通过 Decorate 属性保证符号和 C++ 一致。

代码编译为静态库，因为只有在静态库中才可以共享文件单元。

    ! Copile the code with -Gm, 或 -iface:cvf, So the calling converntion will be StdCall, and parameters will be passed by reference.
    ! !DEC$ ATTRIBUTES Decorate is necessary for mixing programming with C++

    ! Open file, wrapped for C calling
    SUBROUTINE FOpen(FILNAM, FTYPE, FSTAT, LUNIT, IFLAG)
    !DEC$ ATTRIBUTES Decorate,  Alias:'FOpen' :: FOpen
    IMPLICIT NONE
    CHARACTER FILNAM*(*), FTYPE*(*), FSTAT*(*)
    INTEGER LUNIT, IFLAG
    PRINT *, 'Open file ', FILNAM
    OPEN(UNIT=LUNIT, FILE=FILNAM, FORM=FTYPE, STATUS=FSTAT, IOSTAT=IFLAG)
    WRITE(LUNIT, *) 'Test'
    END SUBROUTINE

    ! Close file, wrapped for C calling
    SUBROUTINE FClose(LUNIT)
    !DEC$ ATTRIBUTES Decorate, Alias:'FClose' :: FClose        
    IMPLICIT NONE
    INTEGER LUNIT
    CLOSE(UNIT=LUNIT)
    END SUBROUTINE   

3. C++ 程序

采用 __stdcall 调用约定，参数传递采用引用传递。

#include <stdio.h>
#include "FortranString.h"

#pragma comment(lib, "../Release/FortranString.lib")

// Fortran SUBROUTINE
#define SUBROUTINE extern "C" void __stdcall
// INTEGER  4 bytes
typedef int INTEGER;         

// 打开文件
SUBROUTINE FOpen(CHARACTER FILNAM, CHARACTER FTYPE, CHARACTER FSTAT, INTEGER& LUNIT, INTEGER& IFLAG);
// 关闭文件
SUBROUTINE FClose(INTEGER& LUNIT);

int main()
{
    CHARACTER fStr=CHARACTER("Hello");
    printf("String: %s, Length: %d", fStr.rep, fStr.len);
    int IFLAG;
    int iUnitOut = 8;
    FOpen("FortranFile.txt", "FORMATTED", "NEW", iUnitOut, IFLAG);
    FClose(iUnitOut);
    getchar();
    return 0;
}

EnSafe

C# 传递字符串到 Fortran

如果是 C# 向 Fortran 传递字符串，需要定义结构 struct。

(1) Fortran 函数

文件：CKPreprocess.for

  Integer Function CKPreprocess(strFileMechanism, strFileThermoData, strFileOut, strFileLink)
      !DEC$ Attributes DllExport, Decorate, Alias:'CKPreprocess'::CKPreprocess
      ! To do
  End Function

(2) C# 函数声明 Fortran 函数

文件： CKLib.cs

    public class CKLib
    {
        /// <summary>
        /// 模拟 Fortran 字符串
        /// </summary>
        public struct CHARACTER
        {
            string str;
            int len;
            
            public CHARACTER(string str)
            {
                this.str = str;
                this.len = str.Length;
            }

        }

        /// <summary>
        /// CHEMKIN 前处理，调用方法 1，指明 字符串长度
        /// </summary>
        [DllImport("CKPreprocess.dll", CallingConvention = CallingConvention.StdCall)]
        public static extern int CKPreprocess(String strFileMechanism, int lenStrFileMechanism,
            String strFileThermalData, int lenStrFileThermalData,
            String strFileOut, int lenStrFileOut,
            String strFileCKLink, int lenStrFileCKLink);

        /// <summary>
        /// CHEMKIN 前处理，调用方法 2，通过 CHARACTER 结构传递参数
        /// </summary>
        [DllImport("CKPreprocess.dll", CallingConvention = CallingConvention.StdCall)]
        public static extern int CKPreprocess(CHARACTER strFileMechanism, CHARACTER strFileThermalData,
            CHARACTER strFileOut, CHARACTER strFileCKLink);
    }

(3) C# 调用 Fortran 函数


     // 方法 1，指明 字符串长度
     CKLib.CKPreprocess(strMechanismFile, strMechanismFile.Length,  strThermalDataFile, strThermalDataFile.Length,
              strOutputFile, strOutputFile.Length, strCKLinkFile, strCKLinkFile.Length);

     // 方法 2，通过 CHARACTER 结构传递参数
     CKLib.CKPreprocess(new CKLib.CHARACTER(strMechanismFile), new CKLib.CHARACTER(strThermalDataFile),
              new CKLib.CHARACTER(strOutputFile), new CKLib.CHARACTER(strCKLinkFile));