C++ 具有大型阵列的分段故障（堆芯转储）

我是

C++

编程新手，并编写了此

C++

代码：

//colpitts high freq 1 GHz working with delay
#include <iostream>
#include <cmath>
#include <string>
#include <cstring>
using namespace std;

const double pi = 3.1415926;

int main(){
    double c0, dx, dt,C1,C2,L,fs,Ceq, freq, tau, Rload, gload, Re, ge,gm,gc1,gc2,ic1,ic2,il,gl ;
    c0=20000000000;
    dx=0.01;
    dt=dx/(2 * c0);
    cout<<dt<<"\n";
    double V1 [1000000]={};
    double V2 [1000000]={};
    V1[0]=1e-3; 
    C1=1e-12;
    C2=5e-12;
    L=30.4e-9;
    fs=4e12;
    Ceq=(C1 * C2)/(C1+C2);
    cout<<Ceq<<"\n";
    freq=1/(2 * pi * (sqrt(L*Ceq)));
    cout<<freq<<"\n";
    tau=1/freq;
    cout<<tau<<"\n";
    Rload=50;
    Re=1e6; 
    ge=1/Re;
    cout<<ge<<"\n";
    gm=0;
    gc1=(C1)/dt;
    cout<<gc1<<"\n";
    ic1=-((C1)/dt) * V1[0];  
    cout<<ic1<<"\n";
    gc2=(C2)/dt;
    cout<<gc2<<"\n";
    ic2=-((C2)/dt) * V2[0];
    cout<<ic2<<"\n";
    gl=dt/(L);
    cout<<gl<<"\n";
    il=gl * (V2[0]-V1[0]);
    cout<<il<<"\n";
    gload=1/Rload;
    cout<<gload<<"\n";
    return (0);
}

//colpitts高频1 GHz延迟工作
#包括
#包括
#包括
#包括
使用名称空间std；
常数双pi=3.1415926；
int main（）{
双c0、dx、dt、C1、C2、L、fs、Ceq、freq、tau、Rload、gload、Re、ge、gm、gc1、gc2、ic1、ic2、il、gl；
c0=20000000；
dx=0.01；
dt=dx/（2*c0）；
cout这是堆栈。您使用大约16Mb的堆栈来存储这两个双精度数组（每个双精度数组8字节*2个数组*1000000）

设置一个更大的堆栈，如下所示：

ulimit -s 32000

但将16Mb的数据块放在堆栈上并不是一个好主意

如果您像这样将它们从堆栈中移出（并使用一些空行使代码更易于阅读：），那么它工作得很好。但是，如上所述，我还建议您查看向量，而不是使用C样式的原始数组：


#包括
#包括
#包括
#包括
使用名称空间std；
常数双pi=3.1415926；
双V1[1000000]={}；
双V2[1000000]={}；
int main（）{
双c0，dx，dt，C1，C2，L，fs，Ceq；
双频、tau、Rload、gload；
双Re、ge、gm、gc1、gc2、ic1、ic2、il、gl；
c0=20000000；
dx=0.01；
dt=dx/（2*c0）；
cout这是堆栈。您使用大约16Mb的堆栈来存储这两个双精度数组（每个双精度数组8字节*2个数组*1000000）

设置一个更大的堆栈，如下所示：

ulimit -s 32000

但将16Mb的数据块放在堆栈上并不是一个好主意

如果您像这样将它们从堆栈中移出（并使用一些空行使代码更易于阅读：），那么它工作得很好。但是，如上所述，我还建议您查看向量，而不是使用C样式的原始数组：


#包括
#包括
#包括
#包括
使用名称空间std；
常数双pi=3.1415926；
双V1[1000000]={}；
双V2[1000000]={}；
int main（）{
双c0，dx，dt，C1，C2，L，fs，Ceq；
双频、tau、Rload、gload；
双Re、ge、gm、gc1、gc2、ic1、ic2、il、gl；
c0=20000000；
dx=0.01；
dt=dx/（2*c0）；
coutpaulr是对的。函数中声明的变量使用“堆栈”。局部变量可以使用的空间是有限的

他建议将这些局部数组声明设置为全局、静态和动态分配，这意味着这些变量将不会使用堆栈空间。使用STL中的向量也会起作用

此链接可能会让您了解堆栈空间大小


一个快速而肮脏的解决方案是使用limit/ulimit。缺点是在运行程序之前必须使用此命令。只需使数组全局化就可以了

通常，当您遇到堆栈大小问题时，是因为您有失控或无限递归。对递归函数的每次调用可能不会使用堆栈中的太多数据，但如果函数不断调用自己，最终将耗尽堆栈空间。
Paul R是对的。函数中声明的变量使用“堆栈”。局部变量可以使用的空间有限

他建议将这些局部数组声明设置为全局、静态和动态分配，这意味着这些变量将不会使用堆栈空间。使用STL中的向量也会起作用

此链接可能会让您了解堆栈空间大小


一个快速而肮脏的解决方案是使用limit/ulimit。缺点是在运行程序之前必须使用此命令。只需使数组全局化就可以了

通常，当您遇到堆栈大小问题时，是因为您有失控或无限递归。对递归函数的每次调用可能不会使用堆栈中的太多数据，但如果函数不断调用自己，您最终将耗尽堆栈空间。
确实，堆栈中的数据太多

您可以使用标准模板类（即使在堆栈上分配向量，其数据也在堆中）

  std::vector<double> v1, v2;
  v1.push_back(2.512);
  v1.push_back(3.17);
  v2.resize(37);
  v2[0] = v1[0] + v1[1]; 
  v2[17] = sqrt(10.0) + 11.0;

标准：向量v1，v2；
v1.推回（2.512）；
v1.推回（3.17）；
v2.调整大小（37）；
v2[0]=v1[0]+v1[1]；
v2[17]=sqrt（10.0）+11.0；

阅读一些；BTW，使用和学习C++ 11（不是以前的C++标准）。所以使用最近的编译器（例如4.9，用它编写代码< G++-STD= C++ 11 -墙-G < /COD>……），使用<代码> GDB < /C>调试程序。
 < P>确实，你的堆栈数据太多了。
您可以使用标准模板类（即使在堆栈上分配向量，其数据也在堆中）

  std::vector<double> v1, v2;
  v1.push_back(2.512);
  v1.push_back(3.17);
  v2.resize(37);
  v2[0] = v1[0] + v1[1]; 
  v2[17] = sqrt(10.0) + 11.0;

标准：向量v1，v2；
v1.推回（2.512）；
v1.推回（3.17）；
v2.调整大小（37）；
v2[0]=v1[0]+v1[1]；
v2[17]=sqrt（10.0）+11.0；

阅读一些；BTW，使用和学习C++ 11（不是以前的C++标准）。所以使用最近的编译器（例如4.9，用它编写代码< G++-STD= C++ 11 -墙-G < /代码>……）并使用
gdb
调试器。
当然。你需要在调试器中运行你的程序。在Linux上，这可能意味着gdb.V1和V2太大，并且你有堆栈溢出。你需要使它们全局或静态，或者更好的是动态分配它们。
我知道问题在于分配给我的物理内存。
这是n解决这个问题。使用
std:：vector
而不是那些数组。谢谢std:：vector工作得很好，代码现在运行得很好。谢谢大家。在编写代码时空格键有问题吗？当然。你需要在调试器中运行你的程序。在Linux上，这可能意味着gdb.V1和V2太大，并且你有堆栈溢出。你可以需要使它们成为全局的，或者是静态的，或者更好的是动态地分配它们。
我知道问题在于分配给我的物理内存。
T