ne peut pas déclarer une variable ‘ pour être de type abstrait ‘

EDIT: Après avoir passé un peu de temps à comprendre le code que j'ai écrit je ne sais toujours pas quel est le problème avec elle. C'est la classe de base à partir de laquelle j'ai tiré ma classe:

///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;
};

Maintenant voici ma classe dérivée:

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;
};

Et ci-dessous est là que j'ai de mettre en œuvre la fonction principale. Encore ne sais pas pourquoi je reçois ce message d'erreur.

J'ai été en utilisant le code ci-dessous sur windows avec les deux vc2010 et les blocs de code sans problème:

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;
}

Maintenant j'essaie de compiler mon projet sur Ubuntu mais j'obtiens cette erreur quand j'essaie de l'utilisation de cette classe:

/home/steven/Desktop/ovgl/src/OvglScene.cpp:211: error: cannot declare variable ‘Callback’ to be of abstract type ‘Ovgl::DisablePairCollision’
Ce qui est Callback?
mieux: Où est Callback?
quel compilateur utilisez-vous avec Code::Blocks sous Windows?
Le rappel est une variable à l'intérieur d'une fonction de classe. Je le définir comme ceci: DisablePairCollision de Rappel; j'ai utilisé GCC compilateur MinGW dans les blocs de code.
Le code que vous avez posté n'a rien à voir avec l'erreur. Pourquoi avez-vous publier? Et pourquoi n'avez-vous pas poster le code qui contient l'erreur de la ligne?

OriginalL'auteur SteveDeFacto | 2012-07-25

  1. 22

    La raison de la classe de base abstraite est cette fonction virtuelle pure:

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

    La classe dérivée DisablePairCollision tentatives de définition de cette fonction, mais il ne le fait pas correctement:

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

    Comme vous pouvez le voir, certains des arguments de types différents. E. g. colObj0 est de type const btCollisionObject*, mais il doit être de type const btCollisionObjectWrapper*.

    Par conséquent, la dérivée de la classe définit une nouvelle fonction avec des arguments différents, mais il ne définit pas la fonction virtuelle pure à partir de la classe de base, donc la classe dérivée est encore abstrait.

    Vous devez définir la fonction, avec les mêmes types d'arguments que dans la classe de base.

    Apparemment je dois avoir une version différente de la balle installé. Merci!!!!

    OriginalL'auteur jogojapan

  2. 6

    Ovgl::DisablePairCollision est une classe abstraite, en ce sens qu'il contient au moins une fonction virtuelle pure.

    Vous avez besoin de dériver de cette classe et de mettre en œuvre la résumé fonctionnalité.

    Par exemple:

    class DisablePairCollision { virtual void foo() = 0; };
class DerivedClass : public DisablePairCollision { virtual void foo() {} };

DisablePairCollision* pCallback;
pCallback = new DerivedClass;
pCallback->foo();
    Il fut un temps où j'ai compris que le code, mais maintenant, je n'ai aucune idée de comment cela fonctionne. Où je poste le code ci-dessus est en fait que la fonction/classe chose a été défini. Urg...

    OriginalL'auteur Aesthete