fork download
copy 
  1. //-------------------------------------------------------------------main.cpp
  2. #include "HugeInt.h" 
  3. #include <iostream>
  4. #include <conio.h> 
  5. using namespace std;
  6.  
  7.  
  8. int main()
  9. {
  10. 	unsigned int seed;
  11. 	cout << "Enter seed: ";
  12. 	cin >> seed;
  13. 	srand(seed);
  14.  
  15. 	int length1, length2, length3;
  16. 	cout << "Enter the lengths of three huge integers: ";
  17. 	cin >> length1 >> length2 >> length3;
  18.  
  19. 	const HugeInt n1(length1), n2(length2); 
  20. 	HugeInt n3(length3);
  21. 	cout << "n1: " << n1 << endl; //randomized
  22. 	cout << "n2: " << n2 << endl;
  23. 	cout << "n3: " << n3 << endl;
  24.  
  25.  
  26.  
  27. 	int x = 1, y = 3, z = 7;
  28.  
  29. 	//cout << "Enter three test value x, y, z (integer type): ";
  30. 	//cin >> x >> y >> z;
  31.  
  32. 	cout << "x: " << x << endl;
  33. 	cout << "y: " << y << endl;
  34. 	cout << "z: " << z << endl;
  35.  
  36. 	HugeInt n4, n5, n6;
  37. 	cout << "n1 + n3 = " << (n1 + n3) << endl; 
  38. 	cout << "n4 = n2 - n3 = " << (n4 = n2 - n3) << endl; 
  39.  
  40. 	//cout << "x + n1 = " << x + n1 << endl;
  41. 	//cout << "n1 + x = " << n1 + x << endl;
  42. 	//cout << "n5 = y - n2 = " << (n5 = y - n2) << endl;
  43. 	//cout << "n2 - y = " << n2 - y << endl;
  44. 	//cout << "n3 = n3 - n2 - n1 - x = " << (n3 = n3 - n2 - n1 - x) << endl;
  45. 	//cout << "n6 = y + z = " << (n6 = y + z) << endl << endl;
  46.  
  47. 	cout << "n1: " << n1 << endl;
  48. 	cout << "n2: " << n2 << endl;
  49. 	cout << "n3: " << n3 << endl;
  50. 	cout << "n4: " << n4 << endl;
  51. 	cout << "n5: " << n5 << endl;
  52. 	cout << "n6: " << n6 << endl;
  53.  
  54. 	cin >> length1;
  55. 	return 0;
  56. }
  57. //-------------------------------------------------------------------HugeInt.h
  58. #ifndef HUGE_UINTEGER_H
  59. #define HUGE_UINTEGER_H
  60. #include <vector>
  61. using namespace std;
  62. #define MAX 1000 //< max length of huge interger
  63. class HugeInt
  64. {
  65. 	friend ostream &operator<<(ostream &output, const HugeInt &in);
  66.  
  67. public:
  68. 	HugeInt(); 
  69. 	HugeInt(const HugeInt &in); //< copy constructor
  70. 	static HugeInt random(unsigned int size);
  71.  
  72. 	HugeInt operator=(const HugeInt &right);//< assignment
  73. 	bool operator==(const HugeInt &right);	//< equal to
  74. 	bool operator!=(const HugeInt &right);	//< not equal to
  75. 	bool operator<(const HugeInt &right);	//< less than
  76. 	bool operator>(const HugeInt &right);	//< greater than
  77.  
  78. 	HugeInt operator+(const HugeInt &right);
  79.  
  80. 	HugeInt  operator-(const HugeInt &right);
  81.  
  82.  
  83. private:
  84. 	vector<int> num;
  85. 	int _size;
  86. 	int n;
  87. };
  88. #endif
  89.  
  90.  
  91. //-------------------------------------------------------------------HugeInteger.cpp
  92. #include <iostream>
  93. #include "HugeInt.h"
  94. using namespace std;
  95.  
  96. ostream &operator<<(ostream &output, const HugeInt &in)
  97. {
  98. 	for (int i = in._size - 1; i >= 0; i--)
  99. 	{
  100. 		output << in.num[i];
  101. 	}
  102. 	cout << endl;
  103. 	return output;
  104. }
  105.  
  106. HugeInt::HugeInt()
  107. {
  108. 	num.clear();
  109. 	_size = 0;
  110. }
  111. HugeInt::HugeInt(const HugeInt &in) //< copy constructor
  112. {
  113. 	_size = in._size;
  114. 	num.resize(in._size);
  115. 	for (int i = 0; i < in._size; i++)
  116. 		num[i] = in.num[i];
  117. }
  118.  
  119. HugeInt HugeInt::random(unsigned int size)
  120. {
  121. 	HugeInt a;
  122. 	a._size = size;
  123. 	a.num.resize(size);
  124. 	for (int i = 0; i < size; i++)
  125. 	{
  126. 		a.num[i] = (rand() % 10);
  127. 	}
  128. 	for (int i = 0;; i++)
  129. 	{
  130. 		if (a.num[a._size - 1] == 0)
  131. 		{
  132. 			a.num[a._size - 1] += (rand() % 10);
  133. 		}
  134. 		else
  135. 			break;
  136. 	}
  137. 	return a;
  138. }
  139. HugeInt HugeInt::operator=(const HugeInt &right) //< assignment
  140. {
  141. 	_size = right._size;
  142. 	num.resize(right._size);
  143. 	for (int i = 0; i < right._size; i++)
  144. 	{
  145. 		num[i] = right.num[i];
  146. 	}
  147.  
  148. 	return *this;
  149. }
  150.  
  151. bool HugeInt::operator==(const HugeInt &right) //< equal to
  152. {
  153. 	if (_size != right._size)
  154. 		return false;
  155. 	else
  156. 	{
  157. 		for (int i = 0; i < _size; i++)
  158. 		{
  159. 			if (num[i] != right.num[i])
  160. 				return false;
  161. 		}
  162. 	}
  163. 	return true;
  164. }
  165.  
  166. bool HugeInt::operator!=(const HugeInt &right) //< not equal to
  167. {
  168. 	return !(HugeInt::operator==(right));
  169. }
  170.  
  171. bool HugeInt::operator<(const HugeInt &right)  //< less than
  172. {
  173. 	if (_size < right._size)
  174. 		return true;
  175. 	else if (_size > right._size)
  176. 		return false;
  177. 	else
  178. 	{
  179. 		for (int i = _size - 1; i >= 0; i--)
  180. 		{
  181. 			if (num[i] < right.num[i])
  182. 				return true;
  183. 			else if (num[i] > right.num[i])
  184. 				return false;
  185. 		}
  186. 		return false;
  187. 	}
  188. }
  189.  
  190. bool HugeInt::operator>(const HugeInt &right)  //< greater than
  191. {
  192. 	if (_size < right._size)
  193. 		return false;
  194. 	else if (_size > right._size)
  195. 		return true;
  196. 	else
  197. 	{
  198. 		for (int i = _size - 1; i >= 0; i--)
  199. 		{
  200. 			if (num[i] < right.num[i])
  201. 				return false;
  202. 			else if (num[i] > right.num[i])
  203. 				return true;
  204. 		}
  205. 		return false;
  206. 	}
  207. }
  208. HugeInt HugeInt::operator+(const HugeInt &right)
  209. {
  210. 	HugeInt temp;
  211.  
  212. 	if (_size < right._size)
  213. 		temp._size = right._size;
  214. 	else
  215. 		temp._size = _size;
  216.  
  217. 	temp.num.resize(temp._size);
  218.  
  219. 	for (int i = 0; i < _size; i++)
  220. 	{
  221. 		temp.num[i] = num[i];
  222. 	}
  223. 	for (int i = 0; i < temp._size; i++)
  224. 	{
  225. 		temp.num[i] += right.num[i];
  226. 	}
  227. 	for (int i = 0; i < temp._size; i++)
  228. 	{
  229. 		if (temp.num[i]>9)
  230. 		{
  231. 			temp.num[i] -= 10;
  232. 			if (i + 1 >= temp._size)
  233. 			{
  234. 				temp._size++;
  235. 				temp.num.resize(temp._size);
  236. 			}
  237. 			temp.num[i + 1] += 1;
  238. 		}
  239. 	}
  240.  
  241. 	return temp;
  242. }
  243. HugeInt  HugeInt::operator-(const HugeInt &right)//< subtraction operator; HugeInt  - HugeInt ; 
  244. {
  245. 	HugeInt temp;
  246. 	HugeInt righttemp;
  247. 	if (_size > right._size)				//left > right
  248. 	{
  249. 		temp._size = _size;
  250. 		temp.num.resize(_size);
  251.  
  252. 		for (int i = 0; i < _size; i++)	
  253. 			temp.num[i] = num[i];
  254.  
  255. 		for (int i = 0; i < right._size; i++)		//sub
  256. 			temp.num[i] -= right.num[i];
  257.  
  258. 		n = temp._size;
  259.  
  260. 		for (int i = 0; i < n; i++)					//進位
  261. 		{
  262. 			if (temp.num[i] < 0)
  263. 			{
  264. 				temp.num[i] += 10;
  265. 				if (i + 1 >= temp._size)
  266. 				{
  267. 					temp._size++;
  268. 					temp.num.resize(temp._size);
  269. 				}
  270. 				temp.num[i + 1] -= 1;
  271. 			}
  272. 		}
  273.  
  274. 		for (;temp.num[temp._size - 1] == 0;)
  275. 		{
  276. 			temp.num.resize(temp._size--);
  277. 			if (temp._size == 1)
  278. 				break;
  279. 		}
  280. 		return temp;
  281. 	}
  282. 	else if (_size == right._size)			//left.size == right.size
  283. 	{
  284. 		temp._size = _size;
  285. 		temp.num.resize(_size);
  286.  
  287. 		for (int i = 0; i < _size; i++)	
  288. 			temp.num[i] = num[i];
  289.  
  290. 		bool comparebigsmall = 0;
  291.  
  292. 		n = temp._size;
  293.  
  294. 		for (int i = n-1; i > -1; i--)
  295. 		{
  296. 			if (temp.num[i] > right.num[i])		//left > right
  297. 			{
  298. 				comparebigsmall = 0;
  299. 				break;
  300. 			}
  301. 			else if (temp.num[i] < right.num[i])	//right > left
  302. 			{
  303. 				comparebigsmall = 1;
  304. 				break;
  305. 			}
  306. 			else if (temp.num[i] == right.num[i])
  307. 				continue;
  308. 		}
  309. 		if (comparebigsmall == 0)			//left > right
  310. 		{
  311. 			for (int i = 0; i < _size; i++)	
  312. 				temp.num[i] = num[i];
  313.  
  314. 			for (int i = 0; i < right._size; i++)		//sub
  315. 				temp.num[i] -= right.num[i];
  316.  
  317. 			n = temp._size;
  318.  
  319. 			for (int i = 0; i < n; i++)					//進位
  320. 			{
  321. 				if (temp.num[i] < 0)
  322. 				{
  323. 					temp.num[i] += 10;
  324. 					if (i + 1 >= temp._size)
  325. 					{
  326. 						temp._size++;
  327. 						temp.num.resize(temp._size);
  328. 					}
  329. 					temp.num[i + 1] -= 1;
  330. 				}
  331. 			}
  332.  
  333. 			for (; temp.num[temp._size - 1] == 0;)
  334. 			{
  335. 				temp.num.resize(temp._size--);
  336. 				if (temp._size == 1)
  337. 					break;
  338. 			}
  339. 			return temp;
  340. 		}
  341. 		else if (comparebigsmall == 1)	//right > left
  342. 		{
  343. 			righttemp._size = right._size;
  344. 			righttemp.num.resize(right._size);
  345.  
  346. 			for (int i = 0; i < _size; i++)	
  347. 				righttemp.num[i] = right.num[i];
  348.  
  349. 			for (int i = 0; i < righttemp._size; i++)		//sub
  350. 				righttemp.num[i] -= temp.num[i];
  351.  
  352. 			n = righttemp._size;
  353.  
  354. 			for (int i = 0; i < n; i++)					//進位
  355. 			{
  356. 				if (righttemp.num[i] < 0)
  357. 				{
  358. 					righttemp.num[i] += 10;
  359. 					if (i + 1 >= righttemp._size)
  360. 					{
  361. 						righttemp._size++;
  362. 						righttemp.num.resize(righttemp._size);
  363. 					}
  364. 					righttemp.num[i + 1] -= 1;
  365. 				}
  366. 			}
  367.  
  368. 			for (; righttemp.num[righttemp._size - 1] == 0;)
  369. 			{
  370. 				righttemp.num.resize(temp._size--);
  371. 				if (righttemp._size == 1)
  372. 					break;
  373. 			}
  374. 			righttemp.num[righttemp._size-1] = righttemp.num[righttemp._size-1] * (-1);	//負號
  375. 			return righttemp;
  376. 		}
  377. 	}
  378. 	else if (_size < right._size)
  379. 	{
  380. 		temp._size = _size;
  381. 		temp.num.resize(_size);
  382. 		righttemp._size = right._size;
  383. 		righttemp.num.resize(right._size);
  384.  
  385. 		for (int i = 0; i < _size; i++)	
  386. 			temp.num[i] = num[i];
  387. 		for (int i = 0; i < righttemp._size; i++)	
  388. 			righttemp.num[i] = right.num[i];
  389.  
  390.  
  391. 		for (int i = 0; i < temp._size; i++)		//sub
  392. 		{
  393. 			righttemp.num[i] -= temp.num[i];
  394.  
  395. 		}
  396.  
  397. 		n = righttemp._size;
  398.  
  399. 		for (int i = 0; i < n; i++)					//進位
  400. 		{
  401. 			if (righttemp.num[i] < 0)
  402. 			{
  403. 				righttemp.num[i] += 10;
  404. 				if (i + 1 >= righttemp._size)
  405. 				{
  406. 					righttemp._size++;
  407. 					righttemp.num.resize(righttemp._size);
  408. 				}
  409. 				righttemp.num[i + 1] -= 1;
  410. 			}
  411. 		}
  412.  
  413. 		for (; righttemp.num[righttemp._size - 1] == 0;)
  414. 		{
  415. 			righttemp.num.resize(righttemp._size--);
  416. 			if (righttemp._size == 1)
  417. 				break;
  418. 		}
  419. 		righttemp.num[righttemp._size - 1] = righttemp.num[righttemp._size - 1] * (-1);	//負號
  420. 		return righttemp;
  421. 	}
  422. }
Compilation error #stdin compilation error #stdout 0s 0KB
comments (?)
stdin
copy 
Standard input is empty
compilation info 
prog.cpp:2:22: fatal error: HugeInt.h: No such file or directory
 #include "HugeInt.h"
                      ^
compilation terminated.
stdout
copy 
Standard output is empty
https://ideone.com/sEAOO4
language:
C++ (gcc 8.3)
created:
8 years ago
visibility:
secret

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!