title: allocating an object of abstract class type error
body: <p>Hi I'm getting the following error and am really unsure why. </p>
  
  <pre><code>class InteSiVis: public ofBaseApp //{
  ,  public ofxMidiListener{
  </code></pre>
  
  <p>This occurs when I make class inresivis inherit from the ofxMidiListener class and I get the following error in the main source file</p>
  
  <p>int main( ){</p>
  
  <pre><code>ofSetupOpenGL(1920,1080, OF_WINDOW);            
  ofRunApp( new InteSiVis()); // &lt;-------- The error is here Allocating object of type abstract
  </code></pre>
  
  <p>}</p>
  
  <p>This is really confusing as I have tried this with another example in the exact way and do not get this error.</p>
  
  <pre><code>class testApp : public ofBaseApp, public ofxMidiListener {
  
  int main(){
      ofSetupOpenGL(640, 480, OF_WINDOW);
      ofRunApp(new testApp());
  }
  </code></pre>
  
  <p>Could you give me an idea as to why I'm getting this error I'm calling the class in the exact same way. Thanks in advance.</p>
  
  <p>///----------------------------------Edit
  InteSiVis.h</p>
  
  <pre><code>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&lt;FluidBodySim&gt; mArrayFluidBodySim;
  
      FluidBodySim        mFluidBodySim       ;   ///&lt; Simulation of fluid and rigid bodies
  
      int                 mStatusWindow       ;   ///&lt; Identifier for status window
      unsigned            mFrame              ;   ///&lt; Frame counter
      double              mTimeNow            ;   ///&lt; Current virtual time
      int                 mMouseButtons[3]    ;   ///&lt; Mouse buttons pressed
      bool                mInitialized        ;   ///&lt; Whether this application has been initialized
      int                 mScenario           ;   ///&lt; 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&lt;maxiPitchStretch&lt;grainPlayerWin&gt;*&gt; stretches;
  
      maxiPitchStretch&lt;grainPlayerWin&gt; *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;
  
  
  } ;
  </code></pre>
  
  <p>testApp.h</p>
  
  <pre><code>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&lt;ParticleSystem&gt; ps;
  
      //----------------------Sound---------------------------
  
      void newMidiMessage(ofxMidiMessage&amp; eventArgs);
  
  
      ofxMidiIn midiIn;
      ofxMidiOut midiOut;
      ofxMidiMessage midiMessage;
  
      void audioOut(float *output, int bufferSize, int nChannnels);
  
  };
  </code></pre>
  
  <p>//----------------VIRTUAL FUNCTION
  vorticitydistribution.h</p>
  
  <pre><code>class IVorticityDistribution
  {
      public:
          virtual Vec3 GetDomainSize( void ) const = 0 ;
          virtual void AssignVorticity( Vec3 &amp; vorticity , const Vec3 &amp; position , const Vec3 &amp; 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 &amp; fRadiusSlug , const float &amp; fThickness , const Vec3 &amp; 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 &amp; vorticity , const Vec3 &amp; position , const Vec3 &amp; vCenter ) const
          {
  
  } ;
  </code></pre>