Quanto pessimo sarebbe questo algoritmo che converte una stringa in un numero a precisione multipla?

Ho sviluppato una libreria C ++ per calcoli multipli di precisione (numeri interi / punto fisso), assumo numeri positivi.

La classe è qualcosa di simile a:

class Integer {
 public:
   //constructor
   //destructor
   //set
   //overload operators
 private;
  uint32_t *mem;
  int n_bits_stored;
};

Specificamente il //overload operatos ha operatori binari come

Integer Integer::operator+(const Integer& rhs);
Integer Integer::operator-(const Integer& rhs);
Integer Integer::operator*(const Integer& rhs);
Integer Integer::operator/(const Integer& rhs);
Integer Integer::operator%(const Integer& rhs);

ma anche

Integer Integer::operator<<(const int& l);
Integer Integer::operator>>(const int& l);
Integer& Integer::operator<<=(const int& l);
Integer& Integer::operator>>=(const int& l);

con il significato ovvio.

L'idea è di estendere i tipi interi C ++ di base, a parte il fatto che puoi cambiare la larghezza di banda in tempo reale.

Ad ogni modo ... Mi piacerebbe sovraccaricare l'operatore = , che convertirà un oggetto string in un oggetto Integer , qualcosa come

Integer x = "0xFE3425452783DFEABC34532FCAA"

(puoi supporre che i numeri esadecimali siano passati come stringa, quindi posso omettere il prefisso 0x )

Ecco l'approccio che pensavo di poter usare

• Input: una stringa str che memorizza le cifre esadecimali

• Output: un Integer oggetto x

  1. Crea una mappa Map m oggetto in cui la chiave appartiene al set {'0','1',...,'E','F'} e i valori sono nel set {0,1,...,E,F} (i primi sono caratteri, i secondi sono numeri interi).
  2. Per ogni elemento nella mappa, memorizza il numero intero equivalente
  3. Init x = 0 (presumiamo anche che sia già dimensionato correttamente, eventualmente se la dimensione non è sufficiente quindi posso semplicemente tritare la stringa equivalente).

  4. Per i = 0 ... str_digits.len-1 (la scansione dovrebbe essere dalla cifra più significativa alla cifra meno significativa).

     4.1. %codice%; // Left shifiting

     4.2. %codice%; // Lancio implicito eseguito

  5. return x = x << 4

So che mi mancano alcuni dettagli ma, si può presumere che il casting da tipi interi sia implementato, come costruttori, il sovraccarico di ogni tipo di operatori è implementato, eccetto per quello specifico che voglio implementare. Ecco le mie domande:

1. Il mio algoritmo è corretto?
2. Supponendo che sia corretto è in particolare la parte di memorizzazione delle cifre implementata utilizzando la struttura dei dati della mappa efficiente? Quello che mi preoccupa un po 'è il costo computazionale del recupero di una cifra, perché nel caso in cui la base sia alta questo approccio potrebbe non essere efficiente, giusto? Cosa consiglieresti diversamente?