如何在C++中将多维向量数据写入文件中

Question

我有一个带有N个元素的对象obj（类Holder）向量，其中包含像x和y这样的成员，这些元素也是具有M元素的double类型的向量。我想写一个文本文件，从中创建一个MxN矩阵。我已经尝试了很多不同的东西，迄今为止无济于事。

vector<Holder> obj(N); 

void savedata(string filename, vector<Holder> obj, int M, int N) { 
    ofstream out(filename); 
    for(int i = 0; i < M; i++) { 
     for(int j = 0; j < N; j++) { 
      out << obj[i][j] << "\t" << endl; 
    } 
    } 
} 

但是，这只是最后一组值。我如何创建这样一个MxN矩阵，其中行是来自对象成员矢量x并且列来自对象矢量本身？

预先感谢您。

-

代码的更大版本如下：

// 
    // 

    #include <iostream> 
    #include <cmath> 
    #include <fstream> 
    #include <string> 
    #include <vector> 
    #include <random> 
    using namespace std; 

    typedef vector< vector<double> > Matrix; 

    // Particles making up the cell 
    class Particle{ 
    public: 
     double x; // x position 
     double y; // y position 
     double vx; // velocity in the x direction 
     double vy; // velocity in the y direction 
     double Fx; // force in the x direction 
     double Fy; // force in the y direction 

     // Default constructor 
     Particle() 
     : x(0.0),y(0.0),vx(0.0),vy(0.0),Fx(0.0),Fy(0.0){ 
     } 
    }; 

    // Holder for storing data 
    class HoldPar{ 
    public: 
     vector<double> x; 
     vector<double> y; 
     vector<double> vx; 
     vector<double> vy; 

     // Default constructor 
     HoldPar() 
     : x(0.0),y(0.0),vx(0.0),vy(0.0){ 
     } 

     // Add elements to vectors 
     void add_Xelement(double a) { 
      x.push_back(a); 
     } 

     void add_Yelement(double a) { 
      y.push_back(a); 
     } 

     void add_VXelement(double a) { 
      vx.push_back(a); 
     } 

     void add_VYelement(double a) { 
      vy.push_back(a); 
     } 

    }; 

    int main() { 

     // Initialization of x, v and F 

     const float pi = 3.14; 
     int N = 30; // Number of 'particles' that make up the cell 
     float theta = 2*pi/N; // Angle between two particles in radians 
     float x0 = 0; // Center of the cell [x] 
     float y0 = 0; // Center of the cell [y] 
     float R = 5e-6; // Radius of the cell 
     vector<Particle> particles(N); // particles 

     // Assigning the initial points onto the circle 
     for(int i = 0; i < N; i++) { 
      particles[i].x = x0 + R*cos(theta*i); 
      particles[i].y = y0 + R*sin(theta*i); 
     } 

     float k = 4.3e-7; // Spring constant connecting the particles 
     float m = 2e-8; // Mass of the particles 

     // Calculating the initial spring force between the particles on the cell 
     particles[0].Fx = -k*(particles[1].x - particles[N].x); 
     particles[0].Fy = -k*(particles[1].y - particles[N].y); 
     for(int i = 1; i < N-1; i++) { 
      particles[i].Fx = -k*(particles[i+1].x - particles[i-1].x); 
      particles[i].Fy = -k*(particles[i+1].y - particles[i-1].y); 
     } 
     particles[N].Fx = -k*(particles[0].x - particles[N-1].x); 
     particles[N].Fy = -k*(particles[0].y - particles[N-1].y); 

     // Initial velocities are given to each particle randomly from a Gaussian distribution 
     random_device rdx; // Seed 
     default_random_engine generatorx(rdx()); // Default random number generator 
     random_device rdy; // Seed 
     default_random_engine generatory(rdy()); // Default random number generator 
     normal_distribution<float> distributionx(0,1); // Gaussian distribution with 0 mean and 1 variance 
     normal_distribution<float> distributiony(0,1); // Gaussian distribution with 0 mean and 1 variance 
     for(int i = 0; i < N; i++) { 
      float xnumber = distributionx(generatorx); 
      float ynumber = distributiony(generatory); 
      particles[i].vx = xnumber; 
      particles[i].vy = ynumber; 
     } 


     // Molecular dynamics simulation with velocity Verlet algorithm 

     // 'Old' variables 
     vector<Particle> particles_old(N); 

     for(int i = 0; i < N; i++) { 
      particles_old[i].x = particles[i].x; 
      particles_old[i].y = particles[i].y; 
      particles_old[i].vx = particles[i].vx; 
      particles_old[i].vy = particles[i].vy; 
      particles_old[i].Fx = particles[i].Fx; 
      particles_old[i].Fy = particles[i].Fy; 
     } 

     // Sampling variables 
     int sampleFreq = 2; 
     int sampleCounter = 0; 

     // MD variables 
     float dt = 1e-4; 
     float dt2 = dt*dt; 
     float m2 = 2*m; 
     int MdS = 1e+5; // Molecular dynamics step number 

     // Holder variables 
     vector<HoldPar> particles_hold(N); 

     // MD 
     for(int j = 0; j < MdS; j++) { 

      // Update x 
      for(int i = 0; i < N; i++) { 
       particles[i].x = particles_old[i].x + dt*particles_old[i].vx + dt2*particles_old[i].Fx/m2; 
       particles[i].y = particles_old[i].y + dt*particles_old[i].vy + dt2*particles_old[i].Fy/m2; 
      } 

      // Update F 
      particles[0].Fx = -k*(particles[1].x - particles[N].x); 
      particles[0].Fy = -k*(particles[1].y - particles[N].y); 
      for(int i = 1; i < N-1; i++) { 
       particles[i].Fx = -k*(particles[i+1].x - particles[i-1].x); 
       particles[i].Fy = -k*(particles[i+1].y - particles[i-1].y); 
      } 
      particles[N].Fx = -k*(particles[0].x - particles[N-1].x); 
      particles[N].Fy = -k*(particles[0].y - particles[N-1].y); 

      // Update v 
      for(int i = 0; i < N; i++) { 
       particles[i].vx = particles_old[i].vx + dt*(particles_old[i].Fx + particles[i].Fx)/m2; 
       particles[i].vy = particles_old[i].vy + dt*(particles_old[i].Fy + particles[i].Fy)/m2; 
      } 

      // Copy new variables to old variables 
      for(int i = 0; i < N; i++) { 
       particles_old[i].x = particles[i].x; 
       particles_old[i].y = particles[i].y; 
       particles_old[i].vx = particles[i].vx; 
       particles_old[i].vy = particles[i].vy; 
       particles_old[i].Fx = particles[i].Fx; 
       particles_old[i].Fy = particles[i].Fy; 
      } 

      // Store variables 
      if(j % sampleFreq == 0) { 
       for(int i = 0; i < N; i++) { 

        particles_hold[i].add_Xelement(particles[i].x); 
        particles_hold[i].add_Yelement(particles[i].y); 
        particles_hold[i].add_VXelement(particles[i].vx); 
        particles_hold[i].add_VYelement(particles[i].vy); 

       } 

       sampleCounter += 1; 

      } 

     } 

     //* End of molecular dynamics simulation 

    } 

    // 
    //* 
    // 

基本上我试图写一个txt文件，其中particles_hold元件（从1到N）是列和构件像x这样的particles_hold元素（从1到某个值M）是行。

Answer 1

如果你的意思是视觉方式是把endl或“\ n”放到外部循环中，并从内部循环中移除endl，但我不知道你的Holder对象是否有任何关于如果你有[]运算符定义的那个是答案。

vector<Holder> obj(N); 

void savedata(string filename, vector<Holder> obj, int M, int N) { 
    ofstream out(filename); 
    for(int i = 0; i < M; i++) { 
     for(int j = 0; j < N; j++) { 
      out << obj[i][j] << "\t"; 
     } 
     out<< "\n"; 
    } 
} 

Answer 2

你的方法没问题，但是做了一些小的改动，让你有M行，每行代表obj [i]，i = 0 .. M-1。因此，每列（第j个索引）打印为每行中分开的制表符

vector<Holder> obj(N); 

void savedata(string filename, vector<Holder> obj, int M, int N) { 
    ofstream out(filename); 
    for(int i = 0; i < M; i++) { 
     for(int j = 0; j < N; j++) { 
      out << obj[i][j] << "\t"; 
     } 
     out << endl; 
    } 
}