Arrays 在这段代码中，如何设置一个数组使其具有一个我不知道的维度？

我有一个打印素数的程序。在第二个子例程中，我必须将数组的大小设置为代码中计算的k，但我不知道如何设置，因为在一开始，当我声明numeri时，我已经设置了他的维数。我怎么做

program primi

implicit none

    integer, parameter :: a=10
    integer:: i,k
    logical, dimension(a):: logi
    integer, dimension(10) :: numeri


    call sieve(logi,a)
    print *, logi

    k=0
    do i=1,size(logi)
        if (logi(i)) then
            k=k+1
        end if
    end do

    print *, k

    call logical_to_integer(numeri,logi,10,a)
    print *, numeri

end program primi

subroutine sieve(is_prime, n_max)

    integer, intent(in)   :: n_max
    logical, intent(out)  :: is_prime(n_max)
    integer :: i
    is_prime = .true.
    is_prime(1) = .false.
    do i = 2, int(sqrt(real(n_max)))
        if (is_prime (i)) is_prime (i * i : n_max : i) = .false.
    end do
    return
end subroutine

subroutine logical_to_integer(prime_numbers, is_prime, num_primes, n)
! =====================================================
! Translates the logical array from sieve to an array
! of size num_primes of prime numbers.
! =====================================================
    integer                 :: i, j=0
    integer, intent(in)     :: n
    logical, intent(in)     :: is_prime(n)
    integer, intent(in)     :: num_primes
    integer, intent(out)    :: prime_numbers(num_primes)
    do i = 1, size(is_prime)
        if (is_prime(i)) then
            j = j + 1
            prime_numbers(j) = i
        end if
    end do

    return
end subroutine

---

我知道您需要数组

numeri

才能在运行时分配。 有一种特定的方法可以在Fortran90中声明数组可分配，

integer，dimension（：，：），allocatable:：x

（这里

x

只是一个矩阵示例）。 如上所述声明一个矩阵

x

，通过使用命令

allocate（x（first\u dim，second\u dim））

可以在运行时分配它

我还检测到在子例程中应该声明为

inout

的两个参数，它不会导致错误，但仍然是一种良好的做法

正如Ian Bush所建议的，您可以使用函数

Count

定义

k

这是您的程序的工作版本，从范围（1100）中选取素数：

输出：

F T T F T F T F F F T F T F F F T F T F F F T F F F F F T F T F F F F F T F F F T F T F F F T F F F F F T F F F F F T F T F F F F F 
T F F F T F T F F F F F T F F F T F F F F F T F F F F F F F T F F F                                                                  
          25                                                                                                                         
           2           3           5           7          11          13          17          19          23          29          31 
         37          41          43          47          53          59          61          67          71          73          79  
        83          89          97

---

我为nw想出了一个解决方案，我想知道是否还有其他方法可以做到这一点，所以我会保持它的开放性我发现它有点不清楚你的确切意思，但我要注意的是

prime_numbers=pack（[（I，I=1，size（logi））]，logi）

是一种合理的方法，而不是子例程。@francescalus太棒了！您可以将计数结构简化为简单的k=Count（logi）@IanBush这是真的。我可以补充一点，在退出时也需要

deallocate

数组，但是这里的分配发生在主程序内部，所以不需要担心deallocation，因为程序将退出并完全释放内存。赋值语句不会被忽略，但保存时，变量保留它之间的值调用子例程。因此，当程序执行值为0时，它将启动，然后下次输入子例程时，它将达到上次的值（可能不是0）.True，除非该变量是

out

参数或保存为上面的

static

as

j

。但是指针不会自动解除分配，并且可能会导致内存泄漏，就像在C语言中发生的那样：，因此在使用Fortran中的指针时要小心。

F T T F T F T F F F T F T F F F T F T F F F T F F F F F T F T F F F F F T F F F T F T F F F T F F F F F T F F F F F T F T F F F F F 
T F F F T F T F F F F F T F F F T F F F F F T F F F F F F F T F F F                                                                  
          25                                                                                                                         
           2           3           5           7          11          13          17          19          23          29          31 
         37          41          43          47          53          59          61          67          71          73          79  
        83          89          97