Is this class design correct? A better way?

Hi,

I was wondering if someone would be able to give me some comments on
the following class structure, it feels to me as if there must be a
better way, but I'm unsure what it is, perhaps I should be using
multiple inheritance?

Basically I have a pure virtual class called Body, this contains a
number of integration algorithms which are applied to the Body.
Generally only one integration algorithm will be used with a
particular Body. The integration algorithm is called by the
integrate() method, which selects the integration algorithm depending
on how you have set the variable integration_type.

I'm not sure if it's relevant to this discussion but Body is the base
class from which two others are derived, these implement the
calculate_force() method, this method updates a variable used by the
integrate() method.

Compilable example code implementing this design follows. Apologies if
I've been overly verbose.

Any help greatly appreciated!

#include <iostream>

using namespace std;

class Body {

  public:
  double x, y, z;
  double a;

  static const int BODY_INTEGRATE_EULER=1;
  static const int BODY_INTEGRATE_VERLET=2;
  static const int BODY_INTEGRATE_LEAPFROG=3;

  int integration_type;

  virtual bool calculate_force(Body &b) = 0;

  Body() {
    integration_type=BODY_INTEGRATE_EULER;
  }

  bool integrate() {
    if(integration_type == BODY_INTEGRATE_EULER) {
      // .. do euler
      cout << "Euler integration" << endl;
      return true;
    } else
    if(integration_type == BODY_INTEGRATE_VERLET) {
      // .. do verlet
      cout << "Verlet integration" << endl;
      return true;
    } else
    if(integration_type == BODY_INTEGRATE_LEAPFROG) {
      // .. do leapfrog
      cout << "Leapfrog integration" << endl;
      return true;
    }
  }
};

class Planet : public Body {

  virtual bool calculate_force(Body &b) {
    // do force calculation for planet... updates a
  }
};

class SimpleHarmonic : public Body {

  virtual bool calculate_force(Body &b) {
    // do force calculation for simple harmonic motion... updates a
  }
};

int main(void) {
  Planet p;
  Planet p2;
  SimpleHarmonic s;

  p.integration_type = Body::BODY_INTEGRATE_LEAPFROG;
  p2.integration_type = Body::BODY_INTEGRATE_VERLET;
  s.integration_type = Body::BODY_INTEGRATE_VERLET;

  cout << "planet,leapfrog: ";
  p.integrate();

  cout << "planet,verlet: ";
  p2.integrate();

  cout << "simpleharmonic,verlet: ";
  s.integrate();

  return 0;
}