Newsgroup: it.comp.lang.c++
Titolo: Gestire Numeri di 100+ Cifre

Salve a tutti, vorrei implementare una libreria che mi consenta di gestire
numeri con 100+ cifre e che mi permetta di fare le 4 operazioni di base
(+-*/)
Mi servirebbe avere un'idea dell' implementazione piu' semplice possibile,
eventualmente poi pensero' ad ottimizzare il tutto.
I src che ho trovato in giro sono ovviamente gia' tutti ottimizzati e ci
metterei una vita per cercare di capire il ragionamento che sta alla base
del tutto.
Qualcuno ha esperienza in merito???
Ciau, Il.Socio

 wrote

Ti ho risposto sul NG di C (it.comp.lang.c).
Tommy

 wrote in message
news:b7lup2$3ul$1...@newsreader.mailgate.org...

Be non deve essere difficile se devi gestire solo le operazioni aritmetiche.
Se i numeri devono essere solo interi non penso che ci siano problemi nel
fare la
seguente classe:
class MyInteger {
    std::vector<unsigned char> theDigit;
    boolean                             theSign;
    public:
        MyInteger();
        ~MyInteger();
        const  MyInteger operator+(const MyInteger&);
        const  MyInteger operator-(const MyInteger&);
        const  MyInteger operator*(const MyInteger&);
        const  MyInteger operator/(const MyInteger&);
};
e poi implementi i quattro operatori ( non e' difficile ).
Nota il distruttore non virtuale, e il const no reference tornato dagli
operatori.
Ciao
Gaetano

 Nota il distruttore non virtuale
???
Tommy

Ho scritto una piccola libreria per gestire i numeri...
ti riporto la dichiarazione di classe:
class CNumber
{
public:
 // Costruttori, copy constructor, e distruttore
 CNumber();
 CNumber(const CNumber &Number);
 CNumber(const CVString& Number);
 ~CNumber();
 // Operazioni generiche
 void Reset(void);
 bool SetNumber(const CVString &Number);
 const char *ToString(void);
 void Print(void);
 inline void ChangeSign(void) const;
 inline bool IsInteger(void) const;
 // Operazioni elementari: +, -, *, /
 bool Add(const CNumber &n, CNumber &Result) const;
 bool Sub(const CNumber &n, CNumber &Result) const;
 bool Mult(const CNumber &n, CNumber &Result) const;
 bool Mult(unsigned long n, CNumber &Result) const;
 bool Div(const CNumber &n, CNumber &Result, int precision) const;
 bool Inverse(CNumber &Result, int precision) const;
 // Assegnamento e algebra booleana
 CNumber& operator =(const CNumber &n);
 bool operator ==(const CNumber &n) const;
 bool operator !=(const CNumber &n) const;
 bool operator >(const CNumber &n) const;
 bool operator <(const CNumber &n) const;
 // Operatori matematici
 CNumber operator +(const CNumber &n);
 CNumber operator -(const CNumber &n);
 CNumber operator *(const CNumber &n);
 CNumber operator *(unsigned long n);
 CNumber operator /(const CNumber &n);
 bool AddNumber(const CNumber &n, CNumber &Result) const;
 bool SubtractNumber(const CNumber &n, CNumber &Result) const;
 bool MultiplyNumber(const CNumber &n, CNumber &Result) const;
 bool DivideNumber(const CNumber &n, CNumber &Result, int precision) const;
 void DecimalShift(long n);
private:
 CVString m_IntegerStr;   // Stringa contenente la parte intera del numero
 CVString m_MantixStr;   // Stringa contenente la mantissa del numero
 mutable char m_Sign;   // Segno del numero
private:
 static int m_sNumOfIstances; // Numero di CNumber creati
 int m_nID;      // Numero di identificazione della istanza
};
Ho scritto una piccola implementazione di stringa che va un pelo più veloce
delle string delle stl microsoft:
class CVString
{
public:
 // Costruttori, copy constructor, distruttore
 CVString();
 CVString(const CVString &s);
 CVString(const char *s);
 ~CVString();
 void Destroy();
 // Operazioni generali
 inline int GetLength(void) const { return m_Len; }
 inline const char *GetData(void) const { return (const char*) m_Buffer; }
 inline int GetBufferSize(void) const { return m_BufferSize; }
 inline bool IsEmpty(void) const { if( m_Buffer == NULL ) return true;
return false; }
 // Operazioni sul buffer di stringa
 void Reserve(int nBytes);
 void Erase(void);
 void Insert(int iPos, int n, char c);
 void HeadInsert(int n, char c);
 void TailInsert(int n, char c);
 void SubStr(CVString &s, int start, int end) const;
 bool Truncate(int start);
 bool Remove(int start, int end);
 inline void SetAt(int iPos, char c);
 void MemSet(char c, int n);
 void MemSet(char c, int start, int end);
 void MemCat(const char *src, int size);
 void MemCpy(const char *src, int size);
 char *MemCpy(char *dst, const char *src, int size);
 // Operatori di lavoro sul buffer di stringa
 CVString operator = (const CVString &s);
 CVString operator = (char c);
 CVString& operator += (const CVString &s);
 CVString& operator += (char c);
 inline char operator [] (int iIndex) const;
 // Operazioni di confronto
 int IntegerCmp(const CVString &s) const;
 int MantixCmp(const CVString &s) const;
 // Utility
 void VectorSum(const CVString &s);
 void Reverse(void);
private:
 char *m_Buffer;
 int m_Len;
 int m_BufferSize;
};
Fondamentalmente devi scrivere due classi del genere (una sola se usi
std::string)
Dome

 ???
Immagino voglia dire che dalla sua classe non si deriva; inoltre se in
assoluto non ci sono funzioni virtuali non ci sara' una vtable il che,
su classi che emulano tipi primitivi, mi sembra una buona cosa.
Ciao
Gian Michele

 su classi che emulano tipi primitivi, mi sembra una buona cosa.
Si anche a me sembra una cosa buona, solo che non mi sembrava il fulcro
della questione...
Tommy