kan variabele ” niet declareren als van het abstracte type ”

EDIT: na wat tijd te hebben besteed aan het begrijpen van de code die ik heb geschreven, weet ik nog steeds niet wat er mis mee is. Dit is de basisklasse waaruit ik mijn klasse heb afgeleid:

///ContactResultCallback is used to report contact points
struct  ContactResultCallback
{
    short int   m_collisionFilterGroup;
    short int   m_collisionFilterMask;
    ContactResultCallback()
        :m_collisionFilterGroup(btBroadphaseProxy::DefaultFilter),
        m_collisionFilterMask(btBroadphaseProxy::AllFilter)
    {
    }
    virtual ~ContactResultCallback()
    {
    }
    virtual bool needsCollision(btBroadphaseProxy* proxy0) const
    {
        bool collides = (proxy0->m_collisionFilterGroup & m_collisionFilterMask) != 0;
        collides = collides && (m_collisionFilterGroup & proxy0->m_collisionFilterMask);
        return collides;
    }
    virtual btScalar    addSingleResult(btManifoldPoint& cp,    const btCollisionObjectWrapper* colObj0Wrap,int partId0,int index0,const btCollisionObjectWrapper* colObj1Wrap,int partId1,int index1) = 0;
};

Hier is mijn afgeleide klasse:

class DisablePairCollision : public btCollisionWorld::ContactResultCallback
{
public:
    virtual btScalar addSingleResult(btManifoldPoint& cp, const btCollisionObject* colObj0, int32_t partId0, int32_t index0, const btCollisionObject* colObj1, int32_t partId1, int32_t index1);
    btDiscreteDynamicsWorld* DynamicsWorld;
};

En hieronder implementeer ik de hoofdfunctie. Ik weet nog steeds niet waarom ik deze foutmelding krijg.

Ik gebruikte de onderstaande code probleemloos op Windows met zowel vc2010 als codeblokken:

btScalar DisablePairCollision::addSingleResult(btManifoldPoint& cp, const btCollisionObject* colObj0, int32_t partId0, int32_t index0, const btCollisionObject* colObj1, int32_t partId1, int32_t index1)
{
    // Create an identity matrix.
    btTransform frame;
    frame.setIdentity();
    // Create a constraint between the two bone shapes which are contacting each other.
    btGeneric6DofConstraint* Constraint;
    Constraint = new btGeneric6DofConstraint( *(btRigidBody*)colObj0, *(btRigidBody*)colObj1, frame, frame, true );
    // Set limits to be limitless.
    Constraint->setLinearLowerLimit( btVector3(1, 1, 1 ) );
    Constraint->setLinearUpperLimit( btVector3(0, 0, 0 ) );
    Constraint->setAngularLowerLimit( btVector3(1, 1, 1 ) );
    Constraint->setAngularUpperLimit( btVector3(0, 0, 0 ) );
    // Add constraint to scene.
    DynamicsWorld->addConstraint(Constraint, true);
    return 0;
}

Nu probeer ik mijn project op Ubuntu te compileren, maar ik krijg deze foutmelding wanneer ik die klasse probeer te gebruiken:

/home/steven/Desktop/ovgl/src/OvglScene.cpp:211: error: cannot declare variable ‘Callback’ to be of abstract type ‘Ovgl::DisablePairCollision’

Antwoord 1, autoriteit 100%

De reden dat de basisklasse abstract is, is deze pure virtuele functie:

virtual btScalar addSingleResult(
  btManifoldPoint& cp,
  const btCollisionObjectWrapper* colObj0Wrap,
  int partId0,
  int index0,
  const btCollisionObjectWrapper* colObj1Wrap,
  int partId1,
  int index1) = 0;

De afgeleide klasse DisablePairCollisionprobeert die functie te definiëren, maar doet dit niet correct:

virtual btScalar addSingleResult(
   btManifoldPoint& cp,
   const btCollisionObject* colObj0,
   int32_t partId0,
   int32_t index0,
   const btCollisionObject* colObj1,
   int32_t partId1,
   int32_t index1);

Zoals je kunt zien, hebben sommige argumenten verschillende typen. bijv. colObj0is van het type const btCollisionObject*, maar moet van het type const btCollisionObjectWrapper*zijn.

Daarom definieert de afgeleide klasse een nieuwe functie met verschillende argumenten, maar definieert niet de pure virtuele functie van de basisklasse, dus de afgeleide klasse is nog steeds abstract.

Je moet de functie definiëren met exact dezelfde argumenttypes als in de basisklasse.

Antwoord 2, autoriteit 24%

Ovgl::DisablePairCollisionis een abstracte klasse, wat betekent dat het minstens één pure virtuele functiebevat.

Je moet van deze klasse afleiden en de abstractefunctionaliteit ervan implementeren.

Bijvoorbeeld:

class DisablePairCollision { virtual void foo() = 0; };
class DerivedClass : public DisablePairCollision { virtual void foo() {} };
DisablePairCollision* pCallback;
pCallback = new DerivedClass;
pCallback->foo();