高精度数(C++)

huang_yue

高精度整数，小数，以及复数
（才不会告诉你复数是直接取自标准库）
代码2楼发~

huang_yue

bignum.h 整数
[mw_shl_code=applescript,true]#include<cstring>
#include<string>
#include<algorithm>
#include<iostream>
#include<ctime>
#include<complex>
//#include"debug_new.h"

#pragma once
#pragma warning(disable: 4800) //implicit cast from 'int' to 'bool' (performance warning)

#ifndef BIGNUM
#define BIGNUM

namespace math {

        using namespace std;

        template<class T>
        inline T* ptrcpy(const T* p, size_t size) {
                T* copy = new T[size];
                memcpy(copy, p, size*sizeof(T));
                return copy;
        }

        class Bignum {
                bool negative;
                short* dat;
                int sz;
        public:
                typedef unsigned int size_t;

                //Bignum operator=(Bignum&& a) { swap(a); return *this; }
                Bignum& operator=(const Bignum&);
                Bignum& operator+=(Bignum);
                Bignum& operator-=(Bignum);
                Bignum& operator*=(Bignum);
                Bignum& operator/=(Bignum);
                Bignum& operator<<=(int);
                Bignum& operator>>=(int);
                Bignum& operator^=(Bignum);
                Bignum& operator%=(const Bignum&);
                Bignum& operator++() { return (*this += 1); }
                Bignum& operator--() { return (*this -= 1); }
                Bignum& multiply_10(int);
                Bignum& abs() { negative = false; return *this; }
                Bignum& negate() { negative = !negative; return *this; }
                Bignum& to_negative() { negative = true; return *this; }
                Bignum& to_positive() { return this->abs(); }
                Bignum& pow(const Bignum&);
                Bignum& deleteFrontZeros();

                const Bignum operator+(const Bignum& t) const { return Bignum(*this) += t; }
                const Bignum operator-(const Bignum& t) const { return Bignum(*this) -= t; }
                const Bignum operator*(const Bignum& t) const { return Bignum(*this) *= t; }
                const Bignum operator/(const Bignum& t) const { return Bignum(*this) /= t; }
                const Bignum operator%(const Bignum& t) const { return Bignum(*this) %= t; }
                const Bignum operator<<(int t) const { return Bignum(*this) <<= t; }
                const Bignum operator>>(int t) const { return Bignum(*this) >>= t; }
                const Bignum operator^(const Bignum& t) const { return Bignum(*this) ^= t; }
                const Bignum operator++(int) { Bignum p = *this; ++(*this); return p; }
                const Bignum operator--(int) { Bignum p = *this; --(*this); return p; }
                const Bignum operator-() const { Bignum d(*this); return d.negate(); }
                const Bignum operator+() const { return *this; }

                Bignum divAndMod(const Bignum&, Bignum&) const;

                void swap(Bignum& b) { short* p = dat; dat = b.dat; b.dat = p; std::swap(sz, b.sz); std::swap(negative, b.negative); }

                int length() const; //returns the numbers stored except the front zeros
                int size() const { return sz; } //returns the numbers stored including the front zeros
                short& operator[](size_t);
                const short& operator[](size_t) const;
                string toString() const;
                string toStringWithZero() const;
                long long toLongLong() const;
                bool isNegative() const { return negative; }
                short* data() { return dat; }
                void setData(short* data, int size) { delete[] dat; dat = ptrcpy(data, size); sz = size; }
                short* firstNonZero() const;
                short* end() const { return dat + sz; }
                int firstNonZeroPlace() const;
                bool isOdd() const { return dat[sz - 1]%2; }
                Bignum base2() const;

                Bignum(const Bignum&);
                Bignum(long long = 0);
                Bignum(string);
                Bignum(short* data, int size): negative(false) { dat = ptrcpy(data, size); sz = size; }
                //Bignum(Bignum&& a) { swap(a); }
                ~Bignum() { delete[] dat; }
        };

        typedef std::exception bad_bignum_exception;

        struct bad_bignum: bad_bignum_exception {
                virtual const char* what() const { return "bad bignum"; }
        };

        struct bad_bignum_operation: bad_bignum_exception {
                virtual const char* what() const { return "bad bignum operation"; }
        };

        struct bad_bignum_division: bad_bignum_operation {
                virtual const char* what() const { return "divide by zero"; }
        };

        bool operator<(const Bignum&, const Bignum&);
        bool operator==(const Bignum&, const Bignum&);

        inline bool operator<=(const Bignum& lhs, const Bignum& rhs) {
                return (lhs < rhs) || (lhs == rhs);
        }

        inline bool operator>=(const Bignum& lhs, const Bignum& rhs) {
                return !(lhs < rhs);
        }

        inline bool operator>(const Bignum& lhs, const Bignum& rhs) {
                return !(lhs <= rhs);
        }

        inline bool operator!=(const Bignum& lhs, const Bignum& rhs) {
                return !(lhs == rhs);
        }

        template<class T>
        void reverse(T* t, unsigned int sz);

        inline Bignum multiply_10(Bignum bignum, int i) { return bignum.multiply_10(i); }
       
        extern long long seed_of_random;

        ostream& operator<<(ostream& s, const Bignum& bignum);
        istream& operator>>(istream& s, Bignum& bignum);
        Bignum sqrt(const Bignum& bignum);
        Bignum abs(Bignum);
        Bignum factorial(const Bignum&);
        Bignum construct(const Bignum&); //constructs a bignum from its base-2 expression
        long long random();
        inline void srand(long long d = time(NULL)) { seed_of_random = d; }

        typedef complex<Bignum> Complexi;

}

namespace std {

        using namespace math;

        template<class T>
        void swap(T* a, T* b);

        template<>
        inline void swap(Bignum& lhs, Bignum& rhs) {         lhs.swap(rhs); }
        inline Bignum pow(Bignum lhs, Bignum rhs) { return lhs.pow(rhs); }

}

#endif[/mw_shl_code]

huang_yue

为什么1小时只能发1次帖……
这样贴代码根本贴不完
下载地址：https://pan.baidu.com/s/1miQL268

huang_yue

code004 发表于 2017-8-29 16:28
不错的，你加油，我看好你

我发的网址被抽了，是https://pan.baidu.com/s/1miQL268