C++ std:：vector上的嵌套循环

在我的模拟中，我有一个粒子类和一个nbody类

struct Particle{
    double m;           // mass
    double x[DIM];      // position
    double v[DIM];      // velocity
    double F[DIM];      // force 
    double F_old[DIM];  // force past time step
    void update_position(double dt);
    void update_velocity(double dt);
    void update_force(Particle*, Particle*);
};

class Nbody {
    private:
        const double dt;                // step size
        const double t_max;             // max simulation time
        std::vector<Particle> p;
    public:
        Nbody(unsigned int n_, double dt_, double t_max_);
        void comp_force();
        void comp_position();
        void comp_velocity();
};

在下面的代码片段中，我展示了计算新位置的更新规则

void Particle::update_position(double dt) {
    const double a = dt * 0.5 / m;
    for (unsigned int d=0; d<DIM; ++d) {
        x[d] += dt * (v[d] + a * F[d]);
        F_old[d] = F[d];
    }
}

---

我是否可以编写类似于

update\u position

方法的代码？

您正在调用

update\u force

，该函数定义为

粒子上的成员函数，来自
NBody
的成员函数。在
NBody
的范围内没有功能
update\u force
，因此出现错误。我的建议是不要将
update_force
定义为粒子上的成员函数，而是定义为
particle
之外的自由函数：

struct Particle{
    double m;           // mass
    double x[DIM];      // position
    double v[DIM];      // velocity
    double F[DIM];      // force 
    double F_old[DIM];  // force past time step
    void update_position(double dt);
    void update_velocity(double dt);
};

...

void update_particle_force(Particle& i, Particle& j) {
    double r=EPS; // smoothing
    for (unsigned int d=0; d<DIM; d++) {
        r += sqr(j.x[d] - i.x[d]);
    }
    const double f = i.m * j.m / (sqrt(r) * r);
    for (unsigned int d=0; d<DIM; d++) {
        i.F[d] += f * (j.x[d] - i.x[d]);
        j.F[d] -= f * (j.x[d] - i.x[d]);
    }
}

对于
update\u particle\u force
的参数，在指针上使用引用的优点是，在一定程度上可以避免空指针解引用；空指针检查的潜在负担现在落在
update\u particle\u force
@unjustitute\u mark的调用者身上对不起，你是对的。将更新我的问题。建议：向量类（不是
std:：vector
而是数学向量）可以让你的位置、速度和力量都受益<代码>模板类向量{…

Particle:：update\u force

正在从

Nbody:：comp\u force

调用。请注意不同的范围。看起来

Particle:：update\u force

可以被设置为

静态

（或者是

friend

免费函数，但是

静态

在这里似乎对我更有吸引力）@TedLyngmo你能详细说明一下你的建议吗？我无法想象我怎么能实现它。哈。它没有点击

Particle

是一个

struct

，消除了我对

update\u force

是一个自由函数的反对意见。

void Particle::update_force(Particle* i, Particle* j) {
    double r=EPS; // smoothing
    for (unsigned int d=0; d<DIM; d++) {
        r += sqr(j->x[d] - i->x[d]);
    }
    const double f = i->m * j->m / (sqrt(r) * r);
    for (unsigned int d=0; d<DIM; d++) {
        i->F[d] += f * (j->x[d] - i->x[d]);
        j->F[d] -= f * (j->x[d] - i->x[d]);
    }
}

void Nbody::comp_force() {
    for (Particle& particle: p) {
        for (unsigned int d=0; d<DIM; ++d) {
            particle.F[d] = 0.;
        }
    }
    for (unsigned int i=0; i<n; i++) {
        for (unsigned int j=i+1; j<n; j++) {
            update_force(&p[i], &p[j]);
        }
    }
}

nbody.cpp: In member function ‘void Nbody::comp_force()’:
nbody.cpp:84:13: error: ‘update_force’ was not declared in this scope
             update_force(&p[i], &p[j]);
             ^~~~~~~~~~~~

struct Particle{
    double m;           // mass
    double x[DIM];      // position
    double v[DIM];      // velocity
    double F[DIM];      // force 
    double F_old[DIM];  // force past time step
    void update_position(double dt);
    void update_velocity(double dt);
};

...

void update_particle_force(Particle& i, Particle& j) {
    double r=EPS; // smoothing
    for (unsigned int d=0; d<DIM; d++) {
        r += sqr(j.x[d] - i.x[d]);
    }
    const double f = i.m * j.m / (sqrt(r) * r);
    for (unsigned int d=0; d<DIM; d++) {
        i.F[d] += f * (j.x[d] - i.x[d]);
        j.F[d] -= f * (j.x[d] - i.x[d]);
    }
}

...
update_particle_force(p[i], p[j]);
...