0

我有一堂课，像这样：

class Particle()
{

    void CalcSomething(Super& arg){
        for(unsigned long long index = 0; index < arg.NumberOfParticle(); index ++){                              
            if(this != arg.ParticleMemoryPointer(index)){
                // Do the calculations
            }
        }
    }

}

以下类包含粒子：

class Super()
{

    const Particle* const ParticleMemoryPointer(unsigned int index)
    {
        std::list<Particle>::iterator iter = mParticles.begin();
        std::advance(iter, index);
        return &(*iter);
    }

    std::list<Particle> mParticles;
}

这个想法是，调用 CalcSomething 的粒子实例需要检测何时从与函数内部索引所寻址的粒子实例相同的 Particle 实例调用 CalcSomething CalcSomething。（这有意义吗？我的措辞不是很好……）

您意识到这样做的原因是，如果我们要在两个粒子之间进行计算，我们需要确保它们是不同的粒子。

一些 cout 语句显示 ParticleMemoryPointer 返回的内存地址this与列表中有一项时的指针不同。（它们应该是，对于一个项目，我们用同一个粒子进行两次计算。）

我希望这是可以理解的。

编辑Super 中调用 CalcSomething 的函数：

void Super::UpdateParticles(double time_step)
{
    std::list<Particle>::iterator iter = mParticles.begin();

    for(unsigned long long index = 0; index < mParticles.size(); index ++){
        std::advance(iter, 1);
        iter->CalcSomething(*this);
    }
}

编辑 2我们不能使用 std::vector。（我们知道你在想它！）

4

2 回答 2

1

将元素插入 a 后list，只要该列表和该元素存在，它的指针就永远不会失效。有关更多信息，请参阅此答案：指向 std::vector 和 std::list 元素的指针

只需确保在插入列表后，您不会将未插入的原始元素与插入的元素进行比较 - 插入会将元素移动或复制到列表中。

出于您的预期目的，我不禁觉得有一种更简单的方法，一种不需要Particle了解任何关于的方法Super，甚至不需要检查指针：

（伪代码）

for particle in particles(start, end - 1):
    for otherParticle in particles(particle + 1, end)
        DoSomething(particle, otherParticle)
于 2013-02-27T23:43:38.057 回答
0 
template<typename Iter, typename Func>
void pair_wise(Iter it, Iter last, Func func) {
    while(it != last) {
        Iter other = it;
        ++other;
        while(other != last) {
            func(*it, *other);
            ++other;
        }
        ++it;
    }
}

例如，这将使用 4 个值1、2、进行迭代3，4并将它们配对：

(1, 2), (1, 3), (1, 4)
(2, 3), (2, 4)
(3, 4)

您可以将它与 C++11 中的 lambda 函数一起使用：

int main() {
    list<Particle> particles;

    pair_wise(particles.begin(), particles.end(),
              [](Particle& lhs, Particle& rhs) {
                  lhs.doSomething(rhs);
              });                  
}

或 C++11 之前的版本，例如，使用函数指针：

void calcSomething(Particle& lhs, Particle& rhs) {
    lhs.calcSomething(rhs);
}

int main() {
    list<Particle> particles;

    pair_wise(particles.begin(), particles.end(),
              calcSomething);                  
}
于 2013-02-28T01:12:57.897 回答