如何合并功能相近但略有差异的Fortran子程序？基于超模块与子模块的冗余代码优化进阶方案咨询

Great question! The preprocessor approach you're using works for trivial cases, but it doesn't scale well when you have more modules or complex shared logic. Here are two robust, scalable solutions tailored to Fortran's module/submodule system that eliminate redundancy without messy parameter passing:

方案1：模板方法模式（适合复杂差异化逻辑） #

This approach centralizes all shared *do something* code in the parent module, while letting submodules handle only the unique parts. We use an abstract interface to define a "hook" for差异化 operations, then submodules implement that hook.

超模块（Parent Module） #

module letter
    implicit none

    ! 定义抽象接口，规范差异化操作的签名
    abstract interface
        subroutine diff_init_hook()
        end subroutine diff_init_hook
    end interface

contains

    ! 公共初始化入口：包含所有重复的*do something*代码
    subroutine letter_init(diff_hook)
        procedure(diff_init_hook) :: diff_hook

        ! --- 这里放所有模块共享的初始化逻辑 ---
        print *, "[Common] Executing shared initialization steps..."
        call allocate_shared_resources()
        call validate_common_config()
        ! --- 结束公共逻辑 ---

        ! 调用子模块的差异化操作
        call diff_hook()
    end subroutine letter_init

    ! 共享的辅助函数，所有子模块都可以调用
    subroutine allocate_shared_resources()
        print *, "[Common] Allocating shared memory/handles"
    end subroutine allocate_shared_resources

    subroutine validate_common_config()
        print *, "[Common] Validating global configuration"
    end subroutine validate_common_config

end module letter

子模块A #

submodule(letter) letter_A
    implicit none
contains

    ! 实现A模块独有的差异化操作
    subroutine a_init_hook()
        call my_function(1)
        print *, "[A] letter A init complete"
    end subroutine a_init_hook

    ! 对外暴露的A模块初始化入口
    subroutine a_init()
        call letter_init(a_init_hook)
    end subroutine a_init

end submodule letter_A

子模块B #

submodule(letter) letter_B
    implicit none
contains

    ! 实现B模块独有的差异化操作
    subroutine b_init_hook()
        call my_function(2)
        print *, "[B] letter B init complete"
    end subroutine b_init_hook

    ! 对外暴露的B模块初始化入口
    subroutine b_init()
        call letter_init(b_init_hook)
    end subroutine b_init

end submodule letter_B

优势：

• All shared logic lives in one place—no more copying *do something* blocks across modules
• Adding a new letter_C module only requires writing its unique hook, no changes to the parent module
• No messy parameter passing—submodules handle their own unique values/operations

方案2：参数化模块（适合仅常量差异的场景） #

If your only differences are constant values (like the my_function argument or print message), a parameterized module is even cleaner. This lets you reuse the entire init routine while overriding constants per usage.

参数化超模块 #

module letter
    implicit none
    integer, intent(in), parameter :: LETTER_ID  ! 子模块/使用者指定的ID
    character(len=*), intent(in), parameter :: INIT_MSG  ! 子模块/使用者指定的消息

contains

    subroutine letter_init()
        ! --- 共享的*do something*逻辑 ---
        print *, "[Common] Running shared initialization..."
        call common_setup()
        ! --- 差异化部分使用参数常量 ---
        call my_function(LETTER_ID)
        print *, INIT_MSG
    end subroutine letter_init

    subroutine common_setup()
        print *, "[Common] Performing shared setup tasks"
    end subroutine common_setup

end module letter

使用示例（在主程序或其他模块中） #

program test_letters
    ! 引用参数化模块并传入A的常量
    use letter, LETTER_ID=>1, INIT_MSG=>"letter A init"
    call letter_init()

    ! 重新引用模块传入B的常量（注意：部分编译器需要用block隔离）
    block
        use letter, LETTER_ID=>2, INIT_MSG=>"letter B init"
        call letter_init()
    end block
end program test_letters

优势：

• Extremely concise for constant-only differences
• No submodule boilerplate—just override parameters when using the module

对比原方案 #

Your original preprocessor approach has two key limitations:

1. It requires preprocessor macros, which make the code less portable and harder to debug
2. Scaling to 5+ modules would mean messy nested #if/#elif branches and cumbersome parameter lists

Both solutions above avoid these issues while keeping your code modular and maintainable.

内容的提问来源于stack exchange，提问作者Yes