l'allocation d'un objet de la classe abstraite type d'erreur

Salut, je reçois l'erreur suivante et je suis vraiment pas sûr pourquoi.

class InteSiVis: public ofBaseApp //{
,  public ofxMidiListener{

Cela se produit lorsque je fais de la classe inresivis hériter de la ofxMidiListener classe et j'obtiens l'erreur suivante dans le fichier source principal

int main( ){

ofSetupOpenGL(1920,1080, OF_WINDOW);            
ofRunApp( new InteSiVis()); //<-------- The error is here Allocating object of type abstract

}

C'est vraiment à confusion, comme j'ai essayé avec un autre exemple de la façon exacte et ne pas faire cette erreur.

class testApp : public ofBaseApp, public ofxMidiListener {

int main(){
    ofSetupOpenGL(640, 480, OF_WINDOW);
    ofRunApp(new testApp());
}

Pourriez-vous me donner une idée de pourquoi j'obtiens cette erreur, je vais appeler la classe exactement de la même façon. Merci à l'avance.

///----------------------------------Modifier
InteSiVis.h

class InteSiVis: public ofBaseApp //{
,  public ofxMidiListener{
public:
InteSiVis() ;
void setup();
void update();
void draw();
void exit();
void keyPressed(int key);
void keyReleased(int key);
//Make an Array of Particle Systems
vector<FluidBodySim> mArrayFluidBodySim;
FluidBodySim        mFluidBodySim       ;   ///< Simulation of fluid and rigid bodies
int                 mStatusWindow       ;   ///< Identifier for status window
unsigned            mFrame              ;   ///< Frame counter
double              mTimeNow            ;   ///< Current virtual time
int                 mMouseButtons[3]    ;   ///< Mouse buttons pressed
bool                mInitialized        ;   ///< Whether this application has been initialized
int                 mScenario           ;   ///< Which scenario is being simulated now
//Scene stuff
ofEasyCam mEasyCam;
ofLight light;
//Setting Shader stuff
ofShader shader;
ofxPostProcessing post;
//Sound
float   * lAudioOut; /* outputs */
float   * rAudioOut;
float * lAudioIn; /* inputs */
float * rAudioIn;
int     initialBufferSize; /* buffer size */
int     sampleRate;
double wave,sample,outputs[2];
maxiSample piano_A1, piano_AS1, piano_B1, piano_C1, piano_CS1, piano_D1, piano_DS1, piano_E1, piano_F1, piano_FS1, piano_G1, piano_GS1;
vector<maxiPitchStretch<grainPlayerWin>*> stretches;
maxiPitchStretch<grainPlayerWin> *ts, *ts2, *ts3, *ts4, *ts5;
int nAverages;
float *ifftOutput;
int ifftSize;
//   //Playing the Wav Files
void audioOut(float *output, int bufferSize, int nChannels);
double speed, grainLength, rate;
ofxMaxiFFT fft;
ofxMaxiFFTOctaveAnalyzer oct;
int current;
double pos;
} ;

testApp.h

class testApp : public ofBaseApp, public ofxMidiListener {
public:
void setup();
void draw();
void exit();
void keyPressed(int key);
void keyReleased(int key);
void mouseMoved(int x, int y );
void mouseDragged(int x, int y, int button);
void mousePressed(int x, int y, int button);
void mouseReleased();
stringstream text;
vector<ParticleSystem> ps;
//----------------------Sound---------------------------
void newMidiMessage(ofxMidiMessage& eventArgs);
ofxMidiIn midiIn;
ofxMidiOut midiOut;
ofxMidiMessage midiMessage;
void audioOut(float *output, int bufferSize, int nChannnels);
};

//----------------FONCTION VIRTUELLE
vorticitydistribution.h

class IVorticityDistribution
{
public:
virtual Vec3 GetDomainSize( void ) const = 0 ;
virtual void AssignVorticity( Vec3 & vorticity , const Vec3 & position , const Vec3 & vCenter ) const = 0 ;
} ;
class JetRing : public IVorticityDistribution
{
public:
/*! \brief Initialize parameters for a vortex ring (using a different formula from the other).
The vorticity profile resulting from this is such that the induced velocity is in [0,1].
\param fRadiusSlug - radius of central region where velocity is constant
\param fThickness - thickness of vortex ring, i.e. radius of annular core
\param vDirection - vector of ring axis, also vector of propagation
\param fSpeed   - speed of slug
*/
JetRing( const float & fRadiusSlug , const float & fThickness , const Vec3 & vDirection )
: mRadiusSlug( fRadiusSlug )
, mThickness( fThickness )
, mRadiusOuter( mRadiusSlug + mThickness )
, mDirection( vDirection )
{
}
virtual Vec3 GetDomainSize( void ) const
{
const float boxSideLength   = 2.f * ( mRadiusOuter ) ;    //length of side of virtual cube
return Vec3( 1.0f , 1.0f , 1.0f ) * boxSideLength ;
}
virtual void AssignVorticity( Vec3 & vorticity , const Vec3 & position , const Vec3 & vCenter ) const
{
} ;

OriginalL'auteur user3737372 | 2014-06-26