#include <iostream>
#include <vector>
using namespace std;


class Ray
{
public:
       float test;  
};

class Geometry
{
   public:   
   virtual float GetDistanceUntilHit(Ray &r);
};

float Geometry::GetDistanceUntilHit(Ray &r) 
{
      return 1.0f;
};
 
class Object
{          
   private:     
   Geometry* Geom;         
   public:
   Object(Geometry *geometry);
   Geometry& GetGeom(){ return *Geom; }
   Object(){}
};

class Sphere :  public Geometry
{
   private:
           
   public:  
   Sphere(){Radius=10.0f;}
   float Radius; 
   virtual float GetDistanceUntilHit(Ray &r);    
};


float Sphere::GetDistanceUntilHit(Ray &R) 
{
      return 2.0f;
};

class Scene
{
   private:
           
   public:   
   Scene(){};
   std::vector<Object*> Objects; 
   void AddObject(Object* Obj);
};
 
Scene TestScene;
int main()
{
Sphere* Sp= new Sphere();
Object* Obj= new Object(Sp);
TestScene.AddObject(Obj);
system("PAUSE");
return EXIT_SUCCESS;
}

class Object{             ...   Object(Geometry *geometry);   Object(){}   ...};

class Object{   ...   Object(Geometry *geometry)   {      ...   }}

Object::Object(Geometry *geometry){   ...}

#include <iostream>#include <vector>using namespace std;class Ray{public:       float test;  };class Geometry{   public:      virtual float GetDistanceUntilHit(Ray &r);};float Geometry::GetDistanceUntilHit(Ray &r) {      return 1.0f;}; class Object{             private:        Geometry* Geom;            public:   Object(Geometry *geometry){};   Geometry& GetGeom(){ return *Geom; }   Object(){}};class Sphere :  public Geometry{   private:              public:     Sphere(){Radius=10.0f;}   float Radius;    virtual float GetDistanceUntilHit(Ray &R);    };float Sphere::GetDistanceUntilHit(Ray &R) {      return 2.0f;};class Scene{   private:              public:      Scene(){};   std::vector<Object*> Objects;    void AddObject(Object* Obj);};void Scene::AddObject(Object* Obj){   Objects.push_back(Obj);                                         } Scene TestScene;int main(){Sphere* Sp= new Sphere();Object* Obj= new Object(Sp);TestScene.AddObject(Obj);Ray r;cout<<TestScene.Objects[0]->GetGeom().GetDistanceUntilHit(r)<<endl;system("PAUSE");return EXIT_SUCCESS;}

#include <iostream>#include <vector>#include <algorithm> // I'll be using this later.// In C++, classes and structs are interchangeable; all that differs is// the default of public vs. private access. So if you're going to make// all your members (all 1 of them) public anyway, just use struct.struct Ray { float test; };// If you're putting everything in one file anyway, there's nothing to gain// by pulling a member function's declaration out of the class body. Just define// it inside. But really, we shouldn't try to make a "default" implementation// of "geometry" in this case. Creating an instance of the base class is// probably an error, so let's define things in a way that will let the// compiler catch that for us:struct Geometry {  virtual float GetDistanceUntilHit(Ray &r) = 0;  // The '= 0' denotes a "pure" virtual function. A class which contains these  // And we'll need two more functions...  // First off, any time you have virtual member functions, you should have  // a virtual destructor, too. That's because destructors are subject to the  // same rules as normal functions when it comes to dispatch. If you call  // 'delete' on a base class pointer, you'll want to make sure the derived  // version of the destructor gets called.  virtual ~Geometry() = 0;  // Don't worry about this one yet. I'll explain later.  virtual Geometry* clone() = 0;};// Like that.class Object {  Geometry* g;         public:  // This is how we will set the pointer:  Object(Geometry* g = 0): g(g) {} // i.e., via an initialization list.  // Notice how a default argument is used, to make sure that we still  // have a default constructor, and so that the 'g' pointer gets initialized  // in that case, too.  // Instead of asking the object for its geometry and talking to it directly,  // OO design dictates that we ask the object to talk to the geometry on our  // behalf. Thus:  float GetDistanceUntilHit(Ray& r) { return g->GetDistanceUntilHit(r); }  // Notice how this function isn't virtual itself, but it will dispatch to  // one that is, so we still can get polymorphic behaviour.  // Now, the hard part.  // Our Object "owns" the Geometry that was passed to it, so it must clean it  // up when it dies:  ~Object() { delete g; }  // If we make a copy of the Object (and the std::vector will do so), we need  // to make sure that the copy gets a copy of the underlying Geometry. We can't  // just trust the compiler here, because it will mindlessly copy the *pointer*  // to geometry instead. And that's bad because it means the two Objects are  // suddenly sharing their Geometry. If one changes the Geometry, the other  // gets affected (sometimes desirable, but not here); and if both get  // destroyed, there will be two separate attempts to delete the pointed-at  // Geometry (absolutely, definitely never desirable; undefined behaviour).  // Therefore, we define a "copy constructor" which uses that 'clone' function  // to make a copy of the underlying geometry:  Object(const Object& o): g(o.g->clone()) {}  // And finally, there's one other way that an Object could be effectively  // "copied": by assignment to an existing Object. Thus we have to implement  // an "assignment operator" as well, which dictates what happens when the  // current Object is assigned to from another Object. There are a few ways to  // handle this, but the following is safe and general-purpose. Our strategy  // is to make a copy using the copy constructor, and then swap pointers  // between ourself and the copy. Then, the copy will automatically get its  // destructor called (because it's a local variable), taking our old Geometry  // with it (because of the pointer swap).  Object& operator=(const Object& o) {    Object copy(o);    std::swap(g, copy.g); // std::swap lives in <algorithm>.    return *this;  }};// Now we can implement the Geometry interface...struct Sphere : Geometry {  float Radius;   // This technique should look familiar now:  Sphere(float Radius = 10.0f): Radius(Radius) {}  // in C++, "once virtual, always virtual"; we don't need to say again  // that this is a virtual function.  float GetDistanceUntilHit(Ray &r) { return 2.0f; }  // Each derived instance will have to implement clone() similarly to this:  Geometry* clone() { return new Sphere(*this); }  // Of course, if the derived class is complicated enough, it might need  // its own copy constructor, which gets used here ;)  // There is no need to fill in the destructor, in this case.};class Scene {  // Don't bother defining constructors that will be empty.  // Anyway, now we can store objects by value:  std::vector<Object> Objects;  // And add them by value:  public:  void AddObject(Object& Obj) { Objects.push_back(Obj); }  // And again, let's not have outside code reach into our guts:  float DistanceUntilHit(Ray& r, int index) {    return Objects[index].GetDistanceUntilHit(r);  }};int main() {  // Why not put the test scene in here? :)  Scene TestScene;  // We don't need any more variable declarations in order to add an object:  TestScene.AddObject(Object(new Sphere()));  // Similarly here:  std::cout << TestScene.GetDistanceUntilHit(Ray(), 0) << std::endl;  // Don't pause your programs artificially at the end.}

  Object TestObj(new Sphere());  TestScene.AddObject(TestObj);  Ray r;  std::cout << TestScene.DistanceUntilHit(r, 0) << std::endl;