1. #include <cstdio>
  2. #include <cstring>
  3. #include <string>
  4. #include <iostream>
  5. #include <iomanip>
  6. #include <algorithm>
  7. using namespace std;
  8.  
  9. #define MAXN 9999
  10. #define MAXSIZE 10
  11. #define DLEN 4
  12. const long long MOD = ;
  13. class BigInteger
  14. {
  15. private:
  16. int a[]; //可以控制大数的位数
  17. int len; //大数长度
  18. public:
  19. BigInteger(){ len = ; memset(a, , sizeof(a)); } //构造函数
  20. BigInteger(const int); //将一个int类型的变量转化为大数
  21. BigInteger(const char*); //将一个字符串类型的变量转化为大数
  22. BigInteger(const BigInteger &); //拷贝构造函数
  23. BigInteger &operator=(const BigInteger &); //重载赋值运算符,大数之间进行赋值运算
  24.  
  25. friend istream& operator>>(istream&, BigInteger&); //重载输入运算符
  26. friend ostream& operator<<(ostream&, BigInteger&); //重载输出运算符
  27.  
  28. BigInteger operator+(const BigInteger &) const; //重载加法运算符,两个大数之间的相加运算
  29. BigInteger operator-(const BigInteger &) const; //重载减法运算符,两个大数之间的相减运算
  30. BigInteger operator*(const BigInteger &) const; //重载乘法运算符,两个大数之间的相乘运算
  31. BigInteger operator/(const int &) const; //重载除法运算符,大数对一个整数进行相除运算
  32.  
  33. BigInteger operator^(const int &) const; //大数的n次方运算
  34. long long operator%(const long long &) const; //大数对一个int类型的变量进行取模运算
  35. bool operator>(const BigInteger & T)const; //大数和另一个大数的大小比较
  36. bool operator>(const int & t)const; //大数和一个int类型的变量的大小比较
  37.  
  38. void print(); //输出大数
  39. };
  40. BigInteger::BigInteger(const int b) //将一个int类型的变量转化为大数
  41. {
  42. int c, d = b;
  43. len = ;
  44. memset(a, , sizeof(a));
  45. while (d > MAXN)
  46. {
  47. c = d - (d / (MAXN + )) * (MAXN + );
  48. d = d / (MAXN + );
  49. a[len++] = c;
  50. }
  51. a[len++] = d;
  52. }
  53. BigInteger::BigInteger(const char*s) //将一个字符串类型的变量转化为大数
  54. {
  55. int t, k, index, l, i;
  56. memset(a, , sizeof(a));
  57. l = strlen(s);
  58. len = l / DLEN;
  59. if (l%DLEN)
  60. len++;
  61. index = ;
  62. for (i = l - ; i >= ; i -= DLEN)
  63. {
  64. t = ;
  65. k = i - DLEN + ;
  66. if (k<)
  67. k = ;
  68. for (int j = k; j <= i; j++)
  69. t = t * + s[j] - '';
  70. a[index++] = t;
  71. }
  72. }
  73. BigInteger::BigInteger(const BigInteger & T) : len(T.len) //拷贝构造函数
  74. {
  75. int i;
  76. memset(a, , sizeof(a));
  77. for (i = ; i < len; i++)
  78. a[i] = T.a[i];
  79. }
  80. BigInteger & BigInteger::operator=(const BigInteger & n) //重载赋值运算符,大数之间进行赋值运算
  81. {
  82. int i;
  83. len = n.len;
  84. memset(a, , sizeof(a));
  85. for (i = ; i < len; i++)
  86. a[i] = n.a[i];
  87. return *this;
  88. }
  89. istream& operator>>(istream & in, BigInteger & b) //重载输入运算符
  90. {
  91. char ch[MAXSIZE * ];
  92. int i = -;
  93. in >> ch;
  94. int l = strlen(ch);
  95. int count = , sum = ;
  96. for (i = l - ; i >= ;)
  97. {
  98. sum = ;
  99. int t = ;
  100. for (int j = ; j< && i >= ; j++, i--, t *= )
  101. {
  102. sum += (ch[i] - '')*t;
  103. }
  104. b.a[count] = sum;
  105. count++;
  106. }
  107. b.len = count++;
  108. return in;
  109.  
  110. }
  111. ostream& operator<<(ostream& out, BigInteger& b) //重载输出运算符
  112. {
  113. int i;
  114. cout << b.a[b.len - ];
  115. for (i = b.len - ; i >= ; i--)
  116. {
  117. cout.width(DLEN);
  118. cout.fill('');
  119. cout << b.a[i];
  120. }
  121. return out;
  122. }
  123.  
  124. BigInteger BigInteger::operator+(const BigInteger & T) const //两个大数之间的相加运算
  125. {
  126. BigInteger t(*this);
  127. int i, big; //位数
  128. big = T.len > len ? T.len : len;
  129. for (i = ; i < big; i++)
  130. {
  131. t.a[i] += T.a[i];
  132. if (t.a[i] > MAXN)
  133. {
  134. t.a[i + ]++;
  135. t.a[i] -= MAXN + ;
  136. }
  137. }
  138. if (t.a[big] != )
  139. t.len = big + ;
  140. else
  141. t.len = big;
  142. return t;
  143. }
  144. BigInteger BigInteger::operator-(const BigInteger & T) const //两个大数之间的相减运算
  145. {
  146. int i, j, big;
  147. bool flag;
  148. BigInteger t1, t2;
  149. if (*this>T)
  150. {
  151. t1 = *this;
  152. t2 = T;
  153. flag = ;
  154. }
  155. else
  156. {
  157. t1 = T;
  158. t2 = *this;
  159. flag = ;
  160. }
  161. big = t1.len;
  162. for (i = ; i < big; i++)
  163. {
  164. if (t1.a[i] < t2.a[i])
  165. {
  166. j = i + ;
  167. while (t1.a[j] == )
  168. j++;
  169. t1.a[j--]--;
  170. while (j > i)
  171. t1.a[j--] += MAXN;
  172. t1.a[i] += MAXN + - t2.a[i];
  173. }
  174. else
  175. t1.a[i] -= t2.a[i];
  176. }
  177. t1.len = big;
  178. while (t1.a[t1.len - ] == && t1.len > )
  179. {
  180. t1.len--;
  181. big--;
  182. }
  183. if (flag)
  184. t1.a[big - ] = - t1.a[big - ];
  185. return t1;
  186. }
  187.  
  188. BigInteger BigInteger::operator*(const BigInteger & T) const //两个大数之间的相乘运算
  189. {
  190. BigInteger ret;
  191. int i, j, up;
  192. int temp, temp1;
  193. for (i = ; i < len; i++)
  194. {
  195. up = ;
  196. for (j = ; j < T.len; j++)
  197. {
  198. temp = a[i] * T.a[j] + ret.a[i + j] + up;
  199. if (temp > MAXN)
  200. {
  201. temp1 = temp - temp / (MAXN + ) * (MAXN + );
  202. up = temp / (MAXN + );
  203. ret.a[i + j] = temp1;
  204. }
  205. else
  206. {
  207. up = ;
  208. ret.a[i + j] = temp;
  209. }
  210. }
  211. if (up != )
  212. ret.a[i + j] = up;
  213. }
  214. ret.len = i + j;
  215. while (ret.a[ret.len - ] == && ret.len > )
  216. ret.len--;
  217. return ret;
  218. }
  219. BigInteger BigInteger::operator/(const int & b) const //大数对一个整数进行相除运算
  220. {
  221. BigInteger ret;
  222. int i, down = ;
  223. for (i = len - ; i >= ; i--)
  224. {
  225. ret.a[i] = (a[i] + down * (MAXN + )) / b;
  226. down = a[i] + down * (MAXN + ) - ret.a[i] * b;
  227. }
  228. ret.len = len;
  229. while (ret.a[ret.len - ] == && ret.len > )
  230. ret.len--;
  231. return ret;
  232. }
  233. long long BigInteger::operator %(const long long & b) const //大数对一个int类型的变量进行取模运算
  234. {
  235. int i;
  236. long long d = ;
  237. for (i = len - ; i >= ; i--)
  238. {
  239. d = ((d * (MAXN + )) % b + (long long)(a[i])) % b;
  240. }
  241. return d;
  242. }
  243. BigInteger BigInteger::operator^(const int & n) const //大数的n次方运算
  244. {
  245. BigInteger t, ret();
  246. int i;
  247. if (n<)
  248. exit(-);
  249. if (n == )
  250. return ;
  251. if (n == )
  252. return *this;
  253. int m = n;
  254. while (m>)
  255. {
  256. t = *this;
  257. for (i = ; i << <= m; i <<= )
  258. {
  259. t = t*t;
  260. }
  261. m -= i;
  262. ret = ret*t;
  263. if (m == )
  264. ret = ret*(*this);
  265. }
  266. return ret;
  267. }
  268. bool BigInteger::operator>(const BigInteger & T) const //大数和另一个大数的大小比较
  269. {
  270. int ln;
  271. if (len > T.len)
  272. return true;
  273. else if (len == T.len)
  274. {
  275. ln = len - ;
  276. while (a[ln] == T.a[ln] && ln >= )
  277. ln--;
  278. if (ln >= && a[ln] > T.a[ln])
  279. return true;
  280. else
  281. return false;
  282. }
  283. else
  284. return false;
  285. }
  286. bool BigInteger::operator >(const int & t) const //大数和一个int类型的变量的大小比较
  287. {
  288. BigInteger b(t);
  289. return *this>b;
  290. }
  291.  
  292. void BigInteger::print() //输出大数
  293. {
  294. int i;
  295. cout << a[len - ];
  296. for (i = len - ; i >= ; i--)
  297. {
  298. cout.width(DLEN);
  299. cout.fill('');
  300. cout << a[i];
  301. }
  302. cout << endl;
  303. }

其实这个也没多大用,大数肯定直接用Java了

C++ BigInteger模板的更多相关文章

  1. 模板-高精度BigInteger

    #include <bits/stdc++.h> using namespace std; struct BigInteger { static const int BASE = 1000 ...

  2. C++ BigInteger 大整数类模板(转)

    #include <deque> #include <vector> #include <iostream> #include <string> #in ...

  3. 【Java】-BigInteger大数类的使用【超强Java大数模板 总结】

    Scanner cin = new Scanner(new BufferedInputStream(System.in)); 这样定义Scanner类的对象读入数据可能会快一些! 参考这个博客继续补充 ...

  4. 模板——BigInteger

    #include <iostream> #include <cstring> #include <string> #include <vector> # ...

  5. BigInteger

    首先上模板(不断更新中...)(根据刘汝佳AOAPCII修改) #include <iostream> #include <sstream> #include <cstd ...

  6. 高精度模板 Luogu P1932 A+B & A-B & A*B & A/B Problem

    P1932 A+B & A-B & A*B & A/B Problem 题目背景 这个题目很新颖吧!!! 题目描述 求A.B的和差积商余! 输入输出格式 输入格式: 两个数两行 ...

  7. Java 大数、高精度模板

    介绍: java中用于操作大数的类主要有两个,一个是BigInteger,代表大整数类用于对大整数进行操作,另一个是BigDecimal,代表高精度类,用于对比较大或精度比较高的浮点型数据进行操作.因 ...

  8. 大数模板 poj3982

    1. 这个模板不是自己写的,转载的别人转载的,还没学完c++的我,想写也没有那能力. 这个模板我用在了POJ的一道题上,传送门--POJ3982 一般大数的题,都可用这个模板解决,仅仅须要改动主函数就 ...

  9. JAVA高精度模板

    刚开始还坚持用C++写高精来着,后来发现JAVA写高精方便太多了,所以也来学习一下JAVA高精度的模板. 参考:https://www.cnblogs.com/imzscilovecode/p/883 ...

随机推荐

  1. adb如何连接mumu模拟器并修改Android ID

    adb工具下载安装 https://dl.google.com/android/repository/platform-tools-latest-windows.zip 参考:https://blog ...

  2. PHP 使用 Swoole - TaskWorker 实现异步操作 Mysql

    在一般的 Server 程序中都会有一些耗时的任务,比如:发送邮件.聊天服务器发送广播等.如果我们采用同步阻塞的防水去执行这些任务,那么这肯定会非常的慢. Swoole 的 TaskWorker 进程 ...

  3. HDU——T 2444 The Accomodation of Students

    http://acm.hdu.edu.cn/showproblem.php?pid=2444 Time Limit: 5000/1000 MS (Java/Others)    Memory Limi ...

  4. 【Struts2二】结果集(result-type)

    在jsp/servlet中,结果集一般是指请求转发和重定向这两种. Struts2作为框架,提供了基于这两种的很多其它的结果集! 在struts-default.xml中定义了一些默认的结果集:   ...

  5. 计算机系统之汇编---IA32处理器数据格式及数据操作

    计算机系统之汇编---IA32处理器数据格式及数据操作 IA32数据格式: Intel用术语"字"表示16位数据类型,因此.称32位数为"双字",称64位数为& ...

  6. Excel操作之VLOOKUP

    https://support.office.com/en-us/article/VLOOKUP-function-0bbc8083-26fe-4963-8ab8-93a18ad188a1 Use V ...

  7. Android jni 二维数组 传递

    学习Android Jni时,一个二维 整数 数组的传递花了我好长时间,在网上查的资料都不全,当然最后是成功了,写在这里是为了自己记住,当然有人搜索到并利用了我会很高兴.   in Android J ...

  8. layer是什么

    layer是什么 总结 layer就是一个web弹框 简介 layer是一款web弹层组件,致力于服务各个水平段的开发人员. 可以让你想到即可做到的web弹窗 概述 [1]  layer,一个可以让你 ...

  9. OpenGL编程逐步深入(七)旋转变换

    准备知识 这一节我们来看一下旋转变换.旋转变换指的是给我们一个指点的点和角度,我们需要绕着过该点的轴线將对象旋转对应的角度.这里我们只改变X/Y/Z中的两个分量,第三个分量保持不变.这意味着我们的图形 ...

  10. 《剑指offer》调整数组顺序使奇数位于偶数前面

    一.题目描述 输入一个整数数组,实现一个函数来调整该数组中数字的顺序,使得所有的奇数位于数组的前半部分,所有的偶数位于位于数组的后半部分,并保证奇数和奇数,偶数和偶数之间的相对位置不变. 二.输入描述 ...