C++ 矢量引起的分割错误

我有一个程序，应该用四阶龙格-库塔法和欧拉-克罗默法计算摆的轨迹，不幸的是。。。我有一个缺点

我不知道如何解决这个问题，正如您所看到的，我有一些std:：cout要尝试调试，但它们甚至没有输出。这让我相信函数永远无法执行main（）

我目前的直觉是，它在函数声明期间出错，但如果我错了，我想知道。如果可能的话，您能描述一下用于调试的技术吗

#include <iostream>
#include <cmath>
#include <string>
#include <vector>
#include <stdlib.h>
#include <fstream>

#define N 1

// Pendulum Variables
double d_pendLength = 1.0, d_pendMass = 1.0; // Pendulum Properties
double d_viscParam = 1.0, d_gravity = 1.0; //9.80665; // Enviromental Factors
double d_dAmp = 0.0, d_dFreq = 0.0; // Driving Force

double d_initTheta = 0.0, d_initAVel = 0.0; //Initial Conditions

void v_rungekutta(double d_time, std::vector<double> d_pendulum, double d_step);
void v_eulercromer(double d_time, std::vector<double> d_pendulum, double d_step);
double d_derivative(double d_time, std::vector<double> d_pendulum, int i_de);

int main(void)
{
    // Numerical Variables
    double d_step = 0.01, d_mTime = -1, d_mPeriod  = 300;

    // Global Variables
    double d_time = 0.0, d_period = 0.0, d_limit;

    // Function Vectors
    std::vector<double> d_pendulum (2);

    // Settings
    std::string plot = "theta", algo = "rk4";


    std::cout << "START!";
    std::ofstream file_output;
    std::cout << "HAIDATA!";
    file_output.open("pendulum.data");

    std::cout << "HAI!";
    d_pendulum.at(0)= d_initTheta;  //Initial Theta
    d_pendulum.at(1)= d_initAVel;   //Initial Omega
    std::cout <<"BAI!";

    if (d_mPeriod > 0)
    {
        d_limit = d_mPeriod;
    }
    else if (d_mTime > 0)
    {
        d_limit = d_mTime;
    }
    else
    {
        std::cout << "No Limit Specified";
        exit(1);
    }

    for (int i_currentStep=1; i_currentStep*d_step<=d_limit;i_currentStep++)       
    {
        d_time = i_currentStep*d_step;

        if (algo == "rk4")
        {
            v_rungekutta(d_time, d_pendulum, d_step);
        }
        else if (algo == "ec")
        {
            v_eulercromer(d_time, d_pendulum, d_step);
        }
        file_output << d_time << d_pendulum.at(0) << d_pendulum.at(1) << std::endl;
    }


    file_output.close();
    d_pendulum.clear();

    return 0;
}


void v_rungekutta(double d_time, std::vector<double> d_pendulum, double d_step)
{
    double h=d_step/2.0;  
    std::vector<double> t1, t2, t3, k1, k2, k3, k4;
    int i;

    for (i=N;i>0;i--) t1[i]=d_pendulum.at(i)+0.5*(k1[i]=d_step*d_derivative(d_time, d_pendulum, i));
    for (i=N;i>0;i--) t2[i]=d_pendulum.at(i)+0.5*(k2[i]=d_step*d_derivative(d_time+h, t1, i));
    for (i=N;i>0;i--) t3[i]=d_pendulum.at(i)+ (k3[i]=d_step*d_derivative(d_time+h, t2, i));
    for (i=N;i>0;i--) k4[i]=d_step*d_derivative(d_time+d_step, t3, i);

    for (i=N;i>0;i--) d_pendulum.at(i) += (k1[i]+2*k2[i]+2*k3[i]+k4[i])/6.0;
}

void v_eulercromer(double d_time, std::vector<double> d_pendulum, double d_step)
{
    int i;
    for (i=N;i>0;i--) d_pendulum.at(i) += d_derivative(d_time, d_pendulum, i)*d_step;
}

double d_derivative(double d_time, std::vector<double> d_pendulum, int i_de)
 {
    double dtheta = d_pendulum.at(1);
  if (i_de==0) return dtheta;
  double domega = d_pendulum.at(1)+((-d_gravity/d_pendLength)*sin(d_pendulum.at(0)))+(-d_viscParam*(d_pendulum.at(1)))+(d_dAmp*sin(d_dFreq*d_time));
  if (i_de==1) return domega; 
  if (i_de < 0) return 0; // 0 is a possible value, exit with exit func.
}

#包括
#包括
#包括
#包括
#包括
#包括
#定义n1
//摆变量
双d_pendLength=1.0，d_pendMass=1.0；//摆锤特性
双d_viscParam=1.0，d_重力=1.0//9.80665; // 环境因素
双d_阻尼=0.0，d_dFreq=0.0；//驱动力
双d_初始θ=0.0，d_初始波=0.0//初始条件
void v_rungekutta（双d_时间，标准：：矢量d_摆，双d_步）；
void v_-eulercromer（双d_时间，标准：：矢量d_摆，双d_步）；
双d_导数（双d_时间，标准：：向量d_摆，整数）；
内部主（空）
{
//数值变量
双d_步长=0.01，d_时间=1，d_时间=300；
//全局变量
双d_时间=0.0，d_周期=0.0，d_极限；
//函数向量
std：：矢量d_摆（2）；
//背景
std:：string plot=“theta”，algo=“rk4”；
std：：cout 0；i--）t3[i]=d_摆。at（i）+（k3[i]=d_阶跃*d_导数（d_时间+h，t2，i））；
对于（i=N；i>0；i--）k4[i]=d_阶跃*d_导数（d_时间+d_阶跃，t3，i）；
对于（i=N；i>0；i--）d_摆，在（i）+=（k1[i]+2*k2[i]+2*k3[i]+k4[i]）/6.0；
}

之后：

    void v_rungekutta(double d_time, std::vector<double> d_pendulum, double d_step)
    {
        double h=d_step/2.0;  
        std::vector<double> t1 (2), t2 (2), t3 (2), k1 (2), k2 (2), k3 (2), k4 (2);
        int i;

        for (i=N;i>0;i--) t1.at(i)=d_pendulum.at(i)+0.5*(k1.at(i)=d_step*d_derivative(d_time, d_pendulum, i));
        for (i=N;i>0;i--) t2.at(i)=d_pendulum.at(i)+0.5*(k2.at(i)=d_step*d_derivative(d_time+h, t1, i));
        for (i=N;i>0;i--) t3.at(i)=d_pendulum.at(i)+ (k3.at(i)=d_step*d_derivative(d_time+h, t2, i));
        for (i=N;i>0;i--) k4.at(i)=d_step*d_derivative(d_time+d_step, t3, i);

        for (i=N;i>0;i--) d_pendulum.at(i) += (k1[i]+2*k2[i]+2*k3[i]+k4[i])/6.0;
    }

void v_rungekutta（双d_时间，标准：：矢量d_摆，双d_步）
{
双h=d_阶/2.0；
std：：载体t1（2）、t2（2）、t3（2）、k1（2）、k2（2）、k3（2）、k4（2）；
int i；
对于（i=N；i>0；i--）t1.at（i）=d_摆，at（i）+0.5*（k1.at（i）=d_阶跃*d_导数（d_时间，d_摆，i））；
对于（i=N；i>0；i--）t2.at（i）=d_摆at（i）+0.5*（k2.at（i）=d_阶跃*d_导数（d_时间+h，t1，i））；
对于（i=N；i>0；i--）t3.at（i）=d_摆，at（i）+（k3.at（i）=d_阶跃*d_导数（d_时间+h，t2，i））；
对于（i=N；i>0；i--）k4.at（i）=d_阶跃*d_导数（d_时间+d_阶跃，t3，i）；
对于（i=N；i>0；i--）d_摆，在（i）+=（k1[i]+2*k2[i]+2*k3[i]+k4[i]）/6.0；
}

我第一眼看到的是，您试图访问空向量中的元素。尝试用

at（）

方法替换

[]

运算符。区别在于前者不检查可能产生segfault的边界，而后者则检查，如果索引超出边界，则会引发异常。

尝试使用gdb、lldb或Visual Studio中的调试器。花在学习上的时间花得很好。顺便说一句，函数声明是不会执行的。编译器将生成一个可执行文件，该文件从

main（）

函数的开头开始（可能需要先进行一些静态初始化）。我发现我没有在一些数组上使用.at（I），而且我也没有给出一些数组的大小。非常感谢你！我怎样才能抓住这样一个例外？如果没有对@NictraSavios的问题的回答，这只是半个答案。

    void v_rungekutta(double d_time, std::vector<double> d_pendulum, double d_step)
    {
        double h=d_step/2.0;  
        std::vector<double> t1 (2), t2 (2), t3 (2), k1 (2), k2 (2), k3 (2), k4 (2);
        int i;

        for (i=N;i>0;i--) t1.at(i)=d_pendulum.at(i)+0.5*(k1.at(i)=d_step*d_derivative(d_time, d_pendulum, i));
        for (i=N;i>0;i--) t2.at(i)=d_pendulum.at(i)+0.5*(k2.at(i)=d_step*d_derivative(d_time+h, t1, i));
        for (i=N;i>0;i--) t3.at(i)=d_pendulum.at(i)+ (k3.at(i)=d_step*d_derivative(d_time+h, t2, i));
        for (i=N;i>0;i--) k4.at(i)=d_step*d_derivative(d_time+d_step, t3, i);

        for (i=N;i>0;i--) d_pendulum.at(i) += (k1[i]+2*k2[i]+2*k3[i]+k4[i])/6.0;
    }