有限差分网格：分段错误与插值函数返回值异常求助

需要在域[0,2π]上数值求解u(x,t)=7.5-sin(x)，满足周期性边界条件u(0)=u(2π)=7.5。实现方案是创建包含N个网格单元的1D网格，每个单元包含X、U向量及邻接指针，通过周期边界连接首尾单元，将单元存入vector<Grid>中。目前遇到两个问题：

• interp_u和interp_x始终返回0，疑似使用初始全0向量
• 程序出现分段错误（SEGMENTATION FAULT）

原问题代码 #

class Grid {
  public:
    // Pointers to neighbour cells
  Grid * LeftNeighbour;
  Grid * RightNeighbour;

  std::vector < double > X;
  std::vector < double > U;

  Grid() {
    // Initialises vectors
    std::vector < double > X(2);
    std::vector < double > U(2);
  }

  double interp_x(double t) {
    return X[0] * (1 / 2) * (1 - t) + X[1] * (1 / 2) * (1 + t);
  }

  double interp_u(double t) {
    return U[0] * (1 / 2) * (1 - t) + U[1] * (1 / 2) * (1 + t);
  }
};

int main() {
  const long double pi = 3.1415926535897932384626433832795;
  std::cout.precision(10);
  int N = 5; //number of cells
  std::vector < Grid > cells(N); //initialises vector of cells

  Grid * RightNeighbour, * LeftNeighbour;

  for (int i = 0; i < N; i++) {
    cells[i].X[0] = 0 + ((2 * pi) / N) * i;
    cells[i].X[1] = cells[i].X[0] + ((2 * pi) / N); //SEGMENTATION FAULT

    cells[i].U[0] = 7.5 - sin(cells[i].X[0]);
    cells[i].U[1] = 7.5 - sin(cells[i].X[1]);

    std::cout << "u(t=0) = " << cells[i].interp_u(0) << std::endl; //linear interpolation

    if (i == 0) { //first cell
      LeftNeighbour = & cells[N - 1];
      RightNeighbour = & cells[i + 1];
    }

    if ((i % (N - 1)) != 0) {
      LeftNeighbour = & cells[i - 1];
      RightNeighbour = & cells[i + 1];
    }

    if (i == N - 1) { //last cell
      LeftNeighbour = & cells[i - 1];
      RightNeighbour = & cells[0];
    }
  }
  return 0;
}

错误原因分析 #

1. 构造函数变量遮蔽：原构造函数中创建了局部的X和U向量，遮蔽了类成员变量，导致类成员的X、U始终是空向量，后续访问下标越界，插值计算调用空向量元素（未定义行为，表现为返回0）。
2. 内存越界触发分段错误：空向量直接访问下标0、1属于非法内存访问，直接触发分段错误。
3. 邻接指针未关联到类成员：原代码仅给局部指针赋值，并未将邻接关系写入cells[i]的成员指针，网格邻接关系未正确建立。
4. 条件判断逻辑冗余：多个独立if可能导致逻辑覆盖，例如中间单元的判断会干扰首尾单元的逻辑。
5. 整数除法隐藏bug：1/2是整数除法，结果为0，这也是插值返回0的核心原因之一。

修复后的完整代码 #

#include <iostream>
#include <vector>
#include <cmath>

class Grid {
public:
    // 邻接单元指针
    Grid* LeftNeighbour;
    Grid* RightNeighbour;

    std::vector<double> X;
    std::vector<double> U;

    // 初始化列表直接初始化类成员，避免变量遮蔽
    Grid() : X(2, 0.0), U(2, 0.0), LeftNeighbour(nullptr), RightNeighbour(nullptr) {}

    double interp_x(double t) {
        // 用0.5替代1/2，避免整数除法
        return X[0] * 0.5 * (1 - t) + X[1] * 0.5 * (1 + t);
    }

    double interp_u(double t) {
        return U[0] * 0.5 * (1 - t) + U[1] * 0.5 * (1 + t);
    }
};

int main() {
    const long double pi = 3.1415926535897932384626433832795;
    std::cout.precision(10);
    int N = 5; // 网格单元数量
    std::vector<Grid> cells(N); // 初始化N个网格单元

    for (int i = 0; i < N; i++) {
        // 计算当前单元的左右端点x坐标
        cells[i].X[0] = (2 * pi / N) * i;
        cells[i].X[1] = cells[i].X[0] + (2 * pi / N);

        // 计算对应x坐标的u值
        cells[i].U[0] = 7.5 - sin(cells[i].X[0]);
        cells[i].U[1] = 7.5 - sin(cells[i].X[1]);

        // 输出插值结果（t=0时取左端点值）
        std::cout << "u(t=0) at cell " << i << ": " << cells[i].interp_u(0) << std::endl;

        // 用else if确保逻辑互斥，正确设置邻接指针
        if (i == 0) {
            // 第一个单元，左邻接是最后一个单元
            cells[i].LeftNeighbour = &cells[N - 1];
            cells[i].RightNeighbour = &cells[i + 1];
        } else if (i == N - 1) {
            // 最后一个单元，右邻接是第一个单元
            cells[i].LeftNeighbour = &cells[i - 1];
            cells[i].RightNeighbour = &cells[0];
        } else {
            // 中间单元，邻接左右单元
            cells[i].LeftNeighbour = &cells[i - 1];
            cells[i].RightNeighbour = &cells[i + 1];
        }
    }

    // 可选：验证邻接关系（打印最后一个单元的右邻接x坐标）
    std::cout << "\nLast cell's right neighbour x[0]: " << cells[N-1].RightNeighbour->X[0] << std::endl;

    return 0;
}

关键修复点说明 #

• 构造函数修正：使用初始化列表直接初始化类成员X、U为大小2的向量，同时初始化邻接指针为nullptr，避免局部变量遮蔽类成员。
• 修复整数除法：将1/2改为0.5，确保插值计算的系数正确。
• 邻接指针关联：直接将邻接地址赋值给cells[i]的成员指针，正确建立网格单元的邻接关系。
• 条件逻辑优化：改用else if结构，确保每个单元只执行一个分支，逻辑清晰无覆盖。
• 补充头文件：添加<iostream>、<cmath>头文件，解决编译依赖问题。

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