C 分段错误：11

我在一些程序上遇到了问题，我搜索了一些分段错误，因为我不太了解它们，我只知道我可能正在尝试访问一些不应该访问的内存。问题是我看到了我的代码，不明白我做错了什么

#include<stdio.h>
#include<math.h>
#include<stdlib.h>

#define   lambda   2.0
#define   g        1.0
#define   Lx       100
#define   F0       1.0
#define   Tf       10
#define   h       0.1
#define   e       0.00001

FILE   *file;

double F[1000][1000000];

void Inicio(double D[1000][1000000]) {
int i;
for (i=399; i<600; i++) {
    D[i][0]=F0;
}
}

void Iteration (double A[1000][1000000]) {
long int i,k;
for (i=1; i<1000000; i++) {
    A[0][i]= A[0][i-1] + e/(h*h*h*h)*g*g*(A[2][i-1] - 4.0*A[1][i-1] + 6.0*A[0][i-1]-4.0*A[998][i-1] + A[997][i-1]) + 2.0*g*e/(h*h)*(A[1][i-1] - 2*A[0][i-1] + A[998][i-1]) + e*A[0][i-1]*(lambda-A[0][i-1]*A[0][i-1]);
    A[1][i]= A[1][i-1] + e/(h*h*h*h)*g*g*(A[3][i-1] - 4.0*A[2][i-1] + 6.0*A[1][i-1]-4.0*A[0][i-1] + A[998][i-1]) + 2.0*g*e/(h*h)*(A[2][i-1] - 2*A[1][i-1] + A[0][i-1]) + e*A[1][i-1]*(lambda-A[1][i-1]*A[1][i-1]);
    for (k=2; k<997; k++) {
        A[k][i]= A[k][i-1] + e/(h*h*h*h)*g*g*(A[k+2][i-1] - 4.0*A[k+1][i-1] + 6.0*A[k][i-1]-4.0*A[k-1][i-1] + A[k-2][i-1]) + 2.0*g*e/(h*h)*(A[k+1][i-1] - 2*A[k][i-1] + A[k-1][i-1]) + e*A[k][i-1]*(lambda-A[k][i-1]*A[k][i-1]);
    }
    A[997][i] = A[997][i-1] + e/(h*h*h*h)*g*g*(A[0][i-1] - 4*A[998][i-1] + 6*A[997][i-1] - 4*A[996][i-1] + A[995][i-1]) + 2.0*g*e/(h*h)*(A[998][i-1] - 2*A[997][i-1] + A[996][i-1]) + e*A[997][i-1]*(lambda-A[997][i-1]*A[997][i-1]);
    A[998][i] = A[998][i-1] + e/(h*h*h*h)*g*g*(A[1][i-1] - 4*A[0][i-1] + 6*A[998][i-1] - 4*A[997][i-1] + A[996][i-1]) + 2.0*g*e/(h*h)*(A[0][i-1] - 2*A[998][i-1] + A[997][i-1]) + e*A[998][i-1]*(lambda-A[998][i-1]*A[998][i-1]);
    A[999][i]=A[0][i];
}
}

main() {
long int i,j;
Inicio(F);
Iteration(F);
file = fopen("P1.txt","wt");
for (i=0; i<1000000; i++) {
    for (j=0; j<1000; j++) {
        fprintf(file,"%lf \t %.4f \t %lf\n", 1.0*j/10.0, 1.0*i, F[j][i]);
    }
}
fclose(file);
}

#包括
#包括
#包括
#定义lambda2.0
#定义G1.0
#定义Lx 100
#定义F0 1.0
#定义TF10
#定义h0.1
#定义e 0.00001
文件*文件；
双F[1000][1000000]；
无效Inicio（双D[1000][1000000]）{
int i；
对于（i=399；i您运行的是什么系统？您是否可以访问某种调试器（gdb、visual studio的调试器等）

这将给我们提供有价值的信息，比如程序崩溃的代码行……而且，内存量可能会过高

此外，我是否可以建议您使用命名定义替换数字限制

因此：

#define DIM1_SZ 1000
#define DIM2_SZ 1000000

只要您希望引用数组维度限制，就可以使用这些限制。这将有助于避免键入错误。
此声明：

double F[1000][1000000];

在典型的x86系统上会占用8*1000*1000000字节。这大约是7.45 GB。可能是系统在尝试执行代码时内存不足，这会导致分段错误。
使用链接到的运行程序。这将告诉您指针被取消引用的位置，如果您可以修复他们告诉您的所有错误。
您的阵列占用了大约8 GB的内存（1000 x 1000000 x sizeof（双）字节）。这可能是您的问题的一个因素。它是一个全局变量，而不是堆栈变量，因此您可能没有问题，但您在这里突破了限制

将这么多数据写入文件需要一段时间

您没有检查文件是否已成功打开，这也可能是问题的根源（如果确实失败，很可能是分段错误）

您确实应该为1000和1000000引入一些命名常量；它们代表什么

您还应该编写一个函数来进行计算；您可以在C99或更高版本（或C++）中使用
inline
函数。代码中的重复令人痛苦

对于
main（）
，您还应该使用C99表示法，并使用显式返回类型（当您不使用
argc
或
argv
时，参数列表最好使用
void
）：


出于好奇，我复制了您的代码，将所有出现的1000行更改为行，所有出现的1000000行更改为COLS，然后创建了
enum{ROWS=1000，COLS=10000}；
（从而将问题大小减少了100倍）.我做了一些小的修改，这样它就可以在我喜欢的编译选项集下干净地编译了（没什么大不了的：
static
在函数前面，主数组；
文件成为
main
的本地文件；错误检查
fopen（）
，等等）

然后我创建了第二个副本，并创建了一个内联函数来进行重复计算（第二个用于进行下标计算）。这意味着这个可怕的表达式只写了一次——这是非常可取的，因为它确保了一致性

#include <stdio.h>

#define   lambda   2.0
#define   g        1.0
#define   F0       1.0
#define   h        0.1
#define   e        0.00001

enum { ROWS = 1000, COLS = 10000 };

static double F[ROWS][COLS];

static void Inicio(double D[ROWS][COLS])
{
    for (int i = 399; i < 600; i++) // Magic numbers!!
        D[i][0] = F0;
}

enum { R = ROWS - 1 };

static inline int ko(int k, int n)
{
    int rv = k + n;
    if (rv >= R)
        rv -= R;
    else if (rv < 0)
        rv += R;
    return(rv);
}

static inline void calculate_value(int i, int k, double A[ROWS][COLS])
{
    int ks2 = ko(k, -2);
    int ks1 = ko(k, -1);
    int kp1 = ko(k, +1);
    int kp2 = ko(k, +2);

    A[k][i] = A[k][i-1]
            + e/(h*h*h*h) * g*g * (A[kp2][i-1] - 4.0*A[kp1][i-1] + 6.0*A[k][i-1] - 4.0*A[ks1][i-1] + A[ks2][i-1])
            + 2.0*g*e/(h*h) * (A[kp1][i-1] - 2*A[k][i-1] + A[ks1][i-1])
            + e * A[k][i-1] * (lambda - A[k][i-1] * A[k][i-1]);
}

static void Iteration(double A[ROWS][COLS])
{
    for (int i = 1; i < COLS; i++)
    {
        for (int k = 0; k < R; k++)
            calculate_value(i, k, A);
        A[999][i] = A[0][i];
    }
}

int main(void)
{
    FILE *file = fopen("P2.txt","wt");
    if (file == 0)
        return(1);
    Inicio(F);
    Iteration(F);
    for (int i = 0; i < COLS; i++)
    {
        for (int j = 0; j < ROWS; j++)
        {
            fprintf(file,"%lf \t %.4f \t %lf\n", 1.0*j/10.0, 1.0*i, F[j][i]);
        }
    }
    fclose(file);
    return(0);
}

但是，几乎所有的时间都花在磁盘I/O上。我将磁盘I/O减少到最后一行数据，因此外部I/O
for
循环变成：

for (int i = COLS - 1; i < COLS; i++)

在我看来，通过一次写出可怕的表达式来简化代码是非常有益的。我当然更愿意维护该程序，而不是原始程序。
什么时候发生了SEGFULT？^尝试使用Valgrind获得发生SEGFULT的行号。一般来说，一次就相当明显了你已经把它缩小到了一行，如果没有的话，公布哪一行，我们可以提供帮助。看到你的代码，首先你的编译器肯定出现了分段错误…它编译，当我运行它时，它会说分段错误，/程序如果不能创建P1.txt，你的程序将分段错误。你应该始终使用系统fopen（和其他可能失败的例程）失败。7年后仍然有效。太棒了。
Original   Modified
6.334s      6.367s
6.241s      6.231s
6.315s     10.778s
6.378s      6.320s
6.388s      6.293s
6.285s      6.268s
6.387s     10.954s
6.377s      6.227s
8.888s      6.347s
6.304s      6.286s
6.258s     10.302s
6.975s      6.260s
6.663s      6.847s
6.359s      6.313s
6.344s      6.335s
7.762s      6.533s
6.310s      9.418s
8.972s      6.370s
6.383s      6.357s

for (int i = COLS - 1; i < COLS; i++)

Original    Modified
0.168s      0.165s
0.145s      0.165s
0.165s      0.166s
0.164s      0.163s
0.151s      0.151s
0.148s      0.153s
0.152s      0.171s
0.165s      0.165s
0.173s      0.176s
0.171s      0.165s
0.151s      0.169s