classe abstraite et interface (au sens Java pas graphique :d ) en C++

#ifndef IMAGE_H
#define IMAGE_H

#include "Mask.h"
#include "Struct.h"

enum IMAGE_T {
       FLOAT = 0,
       COMPLEX = 1
};

class Image
{
public:

       Image(int width, int height, IMAGE_T type = FLOAT);
       Image(Image *image);

       ~Image();

       int getWidth();
       int getHeight();

       void setMaxVal(float max);
       float getMaxVal();

       IMAGE_T getType();
       void setType(IMAGE_T type);

       Mask *getMask();

       virtual float get(int n) = 0;
       virtual float get(int x, int y) = 0;
       virtual ImageData<float> *get() = 0;

       virtual void set(int n, float val) = 0;
       virtual void set(int x, int y, float val) = 0;

private:

       int _width;
       int _height;
       float _maxVal;
       IMAGE_T _type;
       Mask *_mask;
};

#endif

#ifndef IMAGE_FLOAT_H
#define IMAGE_FLOAT_H

#include "Image.h"

class ImageFloat : public Image
{
public:

       ImageFloat(int width, int height);
       ImageFloat(ImageFloat *src);
       ~ImageFloat();

       float get(int n);
       float get(int x, int y);
       ImageData<float> *get();

       void set(int n, float val);
       void set(int x, int y, float val);

private:

       float *_data;
};

#endif

#ifndef IMAGE_COMPLEX_H
#define IMAGE_COMPLEX_H

#include <fftw3.h>
#include "Image.h"

enum COMPONENT_T {
       MODULE = 0,
       REAL = 1,
       IMAGINARY = 2,
       PHASE = 3
        };

class ImageComplex : public Image
{
public:

       ImageComplex(int width, int height);
       ImageComplex(ImageComplex *src);
       ~ImageComplex();

       float get(int n);
       float get(int x, int y);
       ImageData<float> *get();

       void set(int n, float val);
       void set(int x, int y, float val);

       // méthode propre à cette classe

       float getComponent(int n, COMPONENT_T type);
       float getComponent(int x, int y, COMPONENT_T type);
       ImageData<float> *getComponent(COMPONENT_T type);

       void setComponent(int n, float val, COMPONENT_T type);
       void setComponent(int x, int y, float val, COMPONENT_T type);

       void setMP(int n, float module, float phase);
       void setMP(int x, int y, float module, float phase);

       void setRI(int n, float real, float imaginary);
       void setRI(int x, int y, float real, float imaginary);

private:

       fftw_complex *_data;
};

#endif

A* a = new B;
A* a = new C;

C* c = static_cast<C*>(a);

B *b = static_cast<B*>(a);

B *b = (B *)a;

#include <iostream>

class A {};
class B {};

int main()
{
  A* a = new A;

  B* b1 = (B*)(a); // OK
  B* b2 = reinterpret_cast<B*>(a); // OK
  B* b2 = static_cast<B*>(a); // Erreur de compilation, car B n'hérite pas de C.
}

A* a = new A;
// action
delete a;

A a;
// action
// destruction automatique

float *_data;

image->get(x, y);