Derived class can't declare

Ok, somehow i think this is weird. I'm gonna summarized my whole code:

Code:

---

class Sphere;
class Rectangle;
class Segment;


class Body
{
  public:
  vect2 Velocity, Position;
  float mass
    Body(){}
    //then other stuff and functions will go on
  //I also have some virtual bool function in here named "Collision"
};

class Sphere: public Body
{
public:
  float Radius;
  Sphere(){}
  //Then the collision functions will go on

};

---

So that's basically it. Then when i tried to do this:

Code:

---

Sphere ball;

---

it gave an error like this:

Code:

---

error C2259: 'Sphere' : cannot instantiate abstract class due to following members:
see declaration of 'Sphere'

---

Can someone help me out here?

EDIT: post removed because I realized that what I suggested would not work/make a difference.

Try this

Sphere ball = new body;

Among other things... Make the base destructor virtual... if you have one.. Nothing else I can think of with the code given..

Are you overriding all your pure virtual functions, like the collision ones?

Quote:

---

Originally Posted by ichijoji

Are you overriding all your pure virtual functions, like the collision ones?

---

No, not that i know now. I was thinking about it but stuck with the derived class

@Shamio
It still give me the same error with your method.

Got it, i have to use pointer.

Yeah, I ment to put this:

Sphere * ball = new body;

@Shamio:
It's still giving me same error but with the Body class.

So, pointer is not working, can anyone have any suggestions?

Paste all the code...

As ichijoji suggested, you probably have not provided a definition in your derived class for a pure virtual function in your base class.

Quote:

---

Originally Posted by Shamino

Yeah, I ment to put this:

Sphere * ball = new body;

---

Don't you mean Body* ball = new Sphere(); ?
A body is not (neccessarily) a sphere!

All the virtual function in the Body class had been overrided. Here is my code:

Code:

---

#ifndef objects_h
#define objects_h
#include "vector2d.h"

class Event;
class Sphere;
class Rect;
class Segment;



class Body
{
public:
        vect2 Position;
        vect2 Velocity;
        float Mass, InvMass;

        Body(){}

        void Initialize(const vect2& Pos, const vect2& Vel, float o_Mass) //take object's position, Velocity, and mass
        {
                Position = Pos;
                Velocity = Vel;
                Mass = o_Mass;               
                InvMass = (Mass > 0.0f)? 1.0f/Mass : 0.0f;
        }

        virtual void Update(float dt)
        {
                Position += Velocity * dt;
        }

        virtual void ComputeVelocity(float mouse_X, float mouse_Y, float dt)
        {
                Velocity = (vect2(mouse_X, mouse_Y) - Position) / dt;
        }
                virtual bool Collision(const Body& bBody, Event& eEvent, float tMax)const = 0;
        virtual bool Collision(const Sphere& bBall,          Event& eEvent, float tMax) const = 0;
        virtual bool Collision(const Rect& rRect,          Event& eEvent, float tMax) const = 0;
};

class Event
{
public:

        vect2 Pcoll, Ncoll, Vcoll;
        Body* pBody[2];

        union
        {
                float tcoll, dcoll;
        };

        void RunCollision()
        {
                vect2 Vel = pBody[0]->Velocity - pBody[1]->Velocity;
                float mass1 = pBody[0]->InvMass;
                float mass2 = pBody[1]->InvMass;
                float totalMass = mass1 + mass2;

                float vn = Vel.Dot(Ncoll);
                float elasticity = 1.0f;
                float grip = 0.0f;

                vect2 Vn = vn * Ncoll;
                vect2 Vt = Vel - Vn;

                Vel = -(1.0f + elasticity) * Vn - Vt * (grip);

                if(mass1 > 0.0f) pBody[0]->Velocity += Vel*(mass1/totalMass);

                if(mass2 > 0.0f) pBody[1]->Velocity -= Vel*(mass2/totalMass);

                //make the object seperate

                vect2 rPosition = pBody[0]->Position - pBody[1]->Position;
                float sgn = sign(rPosition.Dot(Ncoll));

                float threshold = 0.1f;
                if(mass1 > 0.0f) pBody[0]->Position += sgn * threshold * Ncoll;

                if(mass2 > 0.0f) pBody[1]->Position -= sgn * threshold * Ncoll;

        }

};

class Segment
{
public:
        vect2 Vertex[2];
        vect2 Dir;
        vect2 Perp;
        float length;
        Body* bBody;

        Segment(){ bBody = NULL; }

        Segment(const vect2& P0, const vect2& P1, Body *b_Body)
        {
                Vertex[0] = P0;
                Vertex[1] = P1;
                bBody = b_Body;
                Dir = Vertex[0] - Vertex[1];
                length = Dir.Normalize();
                Perp = Dir.Perp();
        }

};

class Sphere : public Body
{
public:
        float Radius;
        int numVer;
        vect2* Vertices;

        Sphere(){}

        void Initialize(const vect2& Pos, const vect2& Vel, float radius)
        {
                Body::Initialize(Pos, Vel, 1.0f);
                Radius = radius;
                numVer = 32;
                Vertices = new vect2[numVer];
        }

        bool Collision(const Segment& sSegment, Event& eEvent, float& tMax) const;

        bool Collision(const Segment& sSegment, int i, Event& eEvent, float& tMax) const;

        bool Collision(const Body& bBody, Event& eEvent, float& tMax) const
        {
                return bBody.Collision(*this, eEvent, tMax);
        }

        bool Collision(Sphere& sSphere, Event& eEvent, float& tMax) const{ return false; }

        bool Collision(const Rect& rRect, Event& eEvent, float& tMax) const;

        void Render() const
        {
       
                glBegin(GL_TRIANGLE_FAN);
                        for(int j=0; j<numVer; j++)
                        {
                                float a = 2*PI*(j/numVer);
                                Vertices[j] = vect2(cos(a)*Radius + Position.x, sin(a)*Radius + Position.y);
                                glVertex2f(Vertices[j].x, Vertices[j].y);
                        }

                glEnd();
        }

};

class Rect : public Body
{
public:
        Segment Seg[4];
        vect2 Extent;
        Rect(){}

        void Initialize(const vect2& Pos, const vect2& Ext, float mass)
        {
                Body::Initialize(Pos, vect2(0, 0), 10.0f);
                Extent = Ext;
                UpdateSegment();
        }

        void UpdateSegment()
        {
                vect2 Min = Position - Extent;
                vect2 Max = Position + Extent;

                Seg[0] = Segment(vect2(Min.x, Min.y), vect2(Max.x, Min.y), this);
                Seg[1] = Segment(vect2(Max.x, Min.y), vect2(Max.x, Max.y), this);
                Seg[2] = Segment(vect2(Max.x, Max.y), vect2(Min.x, Max.y), this);
                Seg[3] = Segment(vect2(Min.x, Max.y), vect2(Min.x, Min.y), this);
        }

        void Update(float dt)
        {
                Body::Update(dt);
                UpdateSegment();
        }

        void Render() const
        {
                vect2 V[4] = {Seg[0].Vertex[0], Seg[1].Vertex[0], Seg[2].Vertex[0], Seg[3].Vertex[0] };
                glBegin(GL_QUADS);
                        glVertex2fv(&V[0].x);
                        glVertex2fv(&V[1].x);
                        glVertex2fv(&V[2].x);
                        glVertex2fv(&V[3].x);
                glEnd();
        }

        bool Collision(const Body& bBody, Event& eEvent, float tMax)const
        {
                return bBody.Collision(*this, eEvent, tMax);
        }

        bool Collision(const Rect& rRect, Event& eEvent, float tMax)const{ return false; }

        bool Collision(const Sphere& sSphere, Event& eEvent, float tMax) const
        {
                bool Collide = false;
                Collide |= sSphere.Collision(Seg[0], eEvent, tMax);
                Collide |= sSphere.Collision(Seg[1], eEvent, tMax);
                Collide |= sSphere.Collision(Seg[2], eEvent, tMax);
                Collide |= sSphere.Collision(Seg[3], eEvent, tMax);

                return Collide;
        }

};

---

Logically, there would be no problem when declare a Sphere object, but somehow this is getting so weird

Quote:

---

bool Collision(const Rect& rRect, Event& eEvent, float& tMax) const;

---

Sphere doesn't implement this pure virtual method!

Nevermind, i forgot to put the '&' sign in the virtual function for "float& tMax" in the Body class. Everything is ok now.