Come progettare le classi nel modo giusto (inviare messaggi)

Cercando di progettare un piccolo progetto nel modo giusto e avere un problema in esso: \

sull'attività: è necessario realizzare la moltiplicazione di grandi numeri, usando fft

Per prima cosa ho le classi

class LargeNumber{};
class Field{}; -- abstract (maybe interface would be better)
class C_C:public virtual Field{};
class Z_p:public virtual Field{};

Quindi, LargeNumber può usare le classi Z_P (modulo P) o C_C (complesso) (più corretto: C_C e Z_P hanno funzioni Mul e Sum per moltiplicare gli oggetti LargeNumber)

ma un altro compito più interessante e difficile.

Devo calcolare tutte le operazioni e il tempo necessari per ogni operazione "grande". E anche bisogno di gettare messaggi e creare registri.

Come risolvere questo problema? (cosa dovrei fare?)

Sarà anche fantastico, se commenterai i modelli e le tue migliori pratiche. e così queste classi:

class LargeNumber {
  private:
  int length;
  vector <short int> number;
  public:
  //prototype
  LargeNumber clone(){            
        return (*this);
  }
  //get
  int Length() const;
  vector <short int> Number()const;      
  //static
  static LargeNumber& GenerateOne(int);// create new LargeNumber
  static void Print(const LargeNumber& print);
  //constructors
  LargeNumber();
  LargeNumber(const LargeNumber& obj);
  explicit LargeNumber(int len);      
  explicit LargeNumber(vector <short int>);
  LargeNumber(int,int);
  //destructors
  ~LargeNumber();    
  void Kill();
  //operators
  LargeNumber& operator= (const LargeNumber& );
  LargeNumber& operator--();    
  LargeNumber& operator++();
  bool operator<(const LargeNumber&)const;


  };


 class Field {
  private:
  inline int max(const int a, const int b){return (a>b?a:b);}       
  inline int min(const int a, const int b){return (a<b?a:b);}     
  int i;
  //need Mod and 2**P-1
  LargeNumber& Deux (const int );

  LargeNumber& Mod (LargeNumber&);
  public:
         virtual ~Field();
         virtual LargeNumber& Sum (const LargeNumber& , const LargeNumber& );
         virtual LargeNumber& Sub (const LargeNumber& , const LargeNumber& );
         virtual LargeNumber& Mul (const LargeNumber& , const LargeNumber& );        
         virtual LargeNumber& Pow (const LargeNumber& , const LargeNumber& );
         virtual bool Prime (LargeNumber& );


  };