设为首页收藏本站
切换到窄版

鱼C论坛

 找回密码
 立即注册
鱼C论坛»论坛 › 技术交流 › C\C++交流 › x的y次幂，大数运算，不要求使用数组！！
返回列表 发新帖
查看: 2910|回复: 4

x的y次幂，大数运算，不要求使用数组！！

[复制链接]
IIIIIIIIIIIIIII
发表于 2018-5-27 12:52:28 | 显示全部楼层 |阅读模式

马上注册，结交更多好友，享用更多功能^_^

您需要 登录 才可以下载或查看，没有账号？立即注册

x
RT，求助啊
想知道小甲鱼最近在做啥？请访问 -> ilovefishc.com
回复

使用道具 举报

皮林重甲
发表于 2018-5-27 14:15:18 | 显示全部楼层
本帖最后由 皮林重甲 于 2018-5-27 14:16 编辑

#幂函数x
def ipow(x, y):
    if y == 0:
        return 1
    return x*ipow(x, y - 1)
想知道小甲鱼最近在做啥？请访问 -> ilovefishc.com
回复 支持 反对

使用道具 举报

故梦L
发表于 2018-5-27 18:14:49 | 显示全部楼层
  1. #include "stdio.h"
  2. #include "math.h"
  3. int main()
  4. {
  5.         int sum;
  6.         double x,y;
  7.         scanf("%lf%lf",&x,&y);
  8.         sum=pow(x,y);
  9.         printf("%d",sum);
  10. }
复制代码
想知道小甲鱼最近在做啥？请访问 -> ilovefishc.com
回复 支持 反对

使用道具 举报

人造人
发表于 2018-5-28 14:05:26 | 显示全部楼层
这个问题我比较感兴趣，就帮你写了
如果我说 你为什么不自己写，你一定会说你不会，为什么不愿意尝试一下呢？
我在写这个程序之前，我也不会，我愿意尝试，写这个程序遇到了各种各样的问题，都一一解决了，这个程序也就写完了
非常建议你自己也动手写一写，把遇到的无法解决的问题提出来，会有人给你解答

我明白，这个程序你就只是来要答案的，而这个程序我比较感兴趣
其他的就不一定了，也许其他的问题会有其他人感兴趣，会帮你写



下面的程序完全按书上的方法写，效率非常不高，就只适合学习原理
Number.hpp
  1. #ifndef _NUMBER_HPP_
  2. #define _NUMBER_HPP_

  4. #include <string>

  6. class Number
  7. {
  8. public:
  9.         Number();
  10.         Number(const Number &s);
  11.         Number(const std::string &s);
  12.         Number(const char *s);
  13.         ~Number();

  15.         operator bool();

  17.         bool operator==(const Number &s);
  18.         bool operator==(const std::string &s);
  19.         bool operator==(const char *s);
  20.         bool operator!=(const Number &s);
  21.         bool operator!=(const std::string &s);
  22.         bool operator!=(const char *s);
  23.         bool operator<(const Number &s);
  24.         bool operator<(const std::string &s);
  25.         bool operator<(const char *s);
  26.         bool operator>(const Number &s);
  27.         bool operator>(const std::string &s);
  28.         bool operator>(const char *s);
  29.         Number operator++();                        // 前缀++
  30.         Number operator++(int);                        // 后缀++
  31.         Number operator--();                        // 前缀--
  32.         Number operator--(int);                        // 后缀--
  33.         Number &operator=(const Number &s);
  34.         Number &operator=(const std::string &s);
  35.         Number &operator=(const char *s);
  36.         Number operator+(const Number &s);
  37.         Number operator+(const std::string &s);
  38.         Number operator+(const char *s);
  39.         Number operator-(const Number &s);
  40.         Number operator-(const std::string &s);
  41.         Number operator-(const char *s);
  42.         Number operator*(const Number &s);
  43.         Number operator*(const std::string &s);
  44.         Number operator*(const char *s);
  45.         Number operator/(const Number &s);
  46.         Number operator/(const std::string &s);
  47.         Number operator/(const char *s);
  48.         Number operator%(const Number &s);
  49.         Number operator%(const std::string &s);
  50.         Number operator%(const char *s);
  51.         Number operator^(const Number &s);                // 幂运算
  52.         Number operator^(const std::string &s);                // 幂运算
  53.         Number operator^(const char *s);                // 幂运算
  54.         friend std::ostream &operator<<(std::ostream &out, const Number &n);
  55.         //std::string &DebugGetNum(void);
  56. private:
  57.         std::string num;

  59.         bool IsPositiveNumber(const std::string &s);
  60.         std::string SymbolEqualAdd(const std::string &s1, const std::string &s2);        // 符号相同的加法
  61.         std::string SymbolNotEqualAdd(const std::string &s1, const std::string &s2);        // 符号不同的加法
  62.         std::string StringAdd(const std::string &s1, const std::string &s2);
  63.         std::string StringSub(const std::string &s1, const std::string &s2);
  64.         //std::string::const_reverse_iterator GetMaxR_Iterator(const std::string &s1, const std::string &s2);        // 获取最大的字符串的逆序迭代器（失败的设计）
  65.        
  66.         // 获取最大的字符串的逆序迭代器（失败的设计），这已经不是迭代器了，忘了改名字了(^_^)，不过无所谓了
  67.         //const std::string *GetMaxR_Iterator(const std::string &s1, const std::string &s2);
  68.         const std::string *GetAbsoluteMaxString(const std::string &s1, const std::string &s2);                        // 获取绝对值最大的字符串

  70.         std::string OppositeNumber(const std::string &s);        // 相反数
  71.         Number OppositeNumber(const Number &n);                        // 相反数
  72.         bool IsZero(const std::string &s);
  73.         Number AbsoluteValue(const Number &n);                        // 绝对值
  74.         std::string RemoveZero(const std::string &s);                // 去掉数字前面的0，例如 "010",去掉前面的0，变成 "10"
  75. };

  77. #endif
复制代码


Number.cpp
  1. #include "Number.hpp"

  3. Number::Number()
  4. {
  5. }

  7. Number::Number(const Number &s)
  8. {
  9.         this->num = s.num;
  10. }

  12. Number::Number(const std::string &s)
  13. {
  14.         this->num = s;
  15. }

  17. Number::Number(const char *s)
  18. {
  19.         this->num = std::string(s);
  20. }

  22. Number::~Number()
  23. {
  24. }

  26. Number::operator bool()
  27. {
  28.         if(this->IsZero(this->num))
  29.                 return false;
  30.         else
  31.                 return true;
  32. }

  34. bool Number::operator==(const Number &s)
  35. {
  36.         return *this == s.num;
  37. }

  39. bool Number::operator==(const std::string &s)
  40. {
  41.         return this->num == s;
  42. }

  44. bool Number::operator==(const char *s)
  45. {
  46.         return *this == std::string(s);
  47. }

  49. bool Number::operator!=(const Number &s)
  50. {
  51.         return !(*this == s);
  52. }

  54. bool Number::operator!=(const std::string &s)
  55. {
  56.         return !(*this == s);
  57. }

  59. bool Number::operator!=(const char *s)
  60. {
  61.         return !(*this == s);
  62. }

  64. bool Number::operator<(const Number &s)
  65. {
  66.         return *this < s.num;
  67. }

  69. bool Number::operator<(const std::string &s)
  70. {
  71.         Number n = *this - s;
  72.         if(n == "0")
  73.                 return false;
  74.         return !(this->IsPositiveNumber(n.num));
  75. }

  77. bool Number::operator<(const char *s)
  78. {
  79.         return *this < std::string(s);
  80. }

  82. bool Number::operator>(const Number &s)
  83. {
  84.         return *this > s.num;
  85. }

  87. bool Number::operator>(const std::string &s)
  88. {
  89.         Number n = *this - s;
  90.         if(n == "0")
  91.                 return false;
  92.         return this->IsPositiveNumber(n.num);
  93. }

  95. bool Number::operator>(const char *s)
  96. {
  97.         return *this > std::string(s);
  98. }

  100. Number Number::operator++()
  101. {
  102.         *this = *this + "1";
  103.         return *this;
  104. }

  106. Number Number::operator++(int)
  107. {
  108.         Number t(*this);
  109.         ++*this;
  110.         return t;
  111. }

  113. Number Number::operator--()
  114. {
  115.         *this = *this - "1";
  116.         return *this;
  117. }

  119. Number Number::operator--(int)
  120. {
  121.         Number t(*this);
  122.         --*this;
  123.         return t;
  124. }

  126. Number &Number::operator=(const Number &s)
  127. {
  128.         *this = s.num;
  129.         return *this;
  130. }

  132. Number &Number::operator=(const std::string &s)
  133. {
  134.         this->num = s;
  135.         return *this;
  136. }

  138. Number &Number::operator=(const char *s)
  139. {
  140.         *this = std::string(s);
  141.         return *this;
  142. }

  144. Number Number::operator+(const Number &s)
  145. {
  146.         return *this + s.num;
  147. }

  149. Number Number::operator+(const std::string &s)
  150. {
  151.         std::string sum;

  153.         if(*this == "0")
  154.                 return Number(s);
  155.         if(s == "0")
  156.                 return Number(*this);

  158.         bool b1 = this->IsPositiveNumber(this->num);
  159.         bool b2 = this->IsPositiveNumber(s);
  160.         if(b1 == b2)
  161.                 sum = this->SymbolEqualAdd(this->num, s);
  162.         else
  163.                 sum = this->SymbolNotEqualAdd(this->num, s);

  165.         return Number(sum);
  166. }

  168. Number Number::operator+(const char *s)
  169. {
  170.         return *this + std::string(s);
  171. }

  173. Number Number::operator-(const Number &s)
  174. {
  175.         return *this - s.num;
  176. }

  178. Number Number::operator-(const std::string &s)
  179. {
  180.         // 减一个数，等于加这个数的相反数
  181.         return *this + this->OppositeNumber(s);
  182. }

  184. Number Number::operator-(const char *s)
  185. {
  186.         return *this - std::string(s);
  187. }

  189. Number Number::operator*(const Number &s)
  190. {
  191.         return *this * s.num;
  192. }

  194. Number Number::operator*(const std::string &s)
  195. {
  196.         if(*this == "0")
  197.                 return Number("0");
  198.         if(s == "0")
  199.                 return Number("0");

  201.         Number a = this->AbsoluteValue(*this);
  202.         Number b = this->AbsoluteValue(Number(s));
  203.         Number result("0");
  204.         for(Number i = a; i != "0"; i = i - "1")
  205.         {
  206.                 result = result + b;
  207.         }

  209.         bool b1 = this->IsPositiveNumber(this->num);
  210.         bool b2 = this->IsPositiveNumber(s);
  211.         if(b1 == b2)
  212.                 return result;
  213.         else
  214.                 return this->OppositeNumber(result);
  215. }

  217. Number Number::operator*(const char *s)
  218. {
  219.         return *this * std::string(s);
  220. }

  222. Number Number::operator/(const Number &s)
  223. {
  224.         return *this / s.num;
  225. }

  227. Number Number::operator/(const std::string &s)
  228. {
  229.         if(this->IsZero(this->num))
  230.                 return Number("0");
  231.         if(this->IsZero(s))
  232.                 throw "除数为0";
  233.        
  234.         Number a = this->AbsoluteValue(*this);
  235.         Number b = this->AbsoluteValue(Number(s));

  237.         Number result;
  238.         for(result = "0"; result * b < a; result = result + "1")
  239.                 /* nothing */;

  241.         result = result - "1";

  243.         bool b1 = this->IsPositiveNumber(this->num);
  244.         bool b2 = this->IsPositiveNumber(s);
  245.         if(b1 == b2)
  246.                 return result;
  247.         else
  248.                 return this->OppositeNumber(result);
  249. }

  251. Number Number::operator/(const char *s)
  252. {
  253.         return *this / std::string(s);
  254. }

  256. Number Number::operator%(const Number &s)
  257. {
  258.         return *this % s.num;
  259. }

  261. Number Number::operator%(const std::string &s)
  262. {
  263.         Number n = *this / s;
  264.         return *this - n * s;
  265. }

  267. Number Number::operator%(const char *s)
  268. {
  269.         return *this % std::string(s);
  270. }

  272. Number Number::operator^(const Number &s)
  273. {
  274.         return *this ^ s.num;
  275. }

  277. Number Number::operator^(const std::string &s)
  278. {
  279.         Number b = this->AbsoluteValue(Number(s));
  280.         Number result = "1";
  281.         for(Number i = "0"; i < b; ++i)
  282.         {
  283.                 result = result * (*this);
  284.         }
  285.        
  286.         if(this->IsPositiveNumber(s))
  287.                 return result;
  288.         else
  289.                 return Number("1") / result;
  290. }

  292. Number Number::operator^(const char *s)
  293. {
  294.         return *this ^ std::string(s);
  295. }

  297. bool Number::IsPositiveNumber(const std::string &s)
  298. {
  299.         if(s[0] == '-')
  300.                 return false;
  301.         else
  302.                 return true;
  303. }

  305. std::string Number::SymbolEqualAdd(const std::string &s1, const std::string &s2)
  306. {
  307.         std::string sum = this->StringAdd(s1, s2);
  308.         if(this->IsPositiveNumber(s1))
  309.                 return sum;
  310.         else
  311.         {
  312.                 sum.insert(sum.begin(), '-');
  313.                 return sum;
  314.         }
  315. }

  317. #if 0
  318. std::string Number::SymbolNotEqualAdd(const std::string &s1, const std::string &s2)
  319. {
  320.         return this->StringSub(s1, s2);
  321. }
  322. #endif

  324. std::string Number::SymbolNotEqualAdd(const std::string &s1, const std::string &s2)
  325. {
  326.         std::string result = this->StringSub(s1, s2);
  327.         result = this->RemoveZero(result);

  329.         // 会出现 "000" 的情况，例如 100 + (-100)
  330.         // 对这类问题特殊处理
  331.         if(this->IsZero(result))
  332.                 return std::string("0");

  334.         const std::string *max = this->GetAbsoluteMaxString(s1, s2);
  335.         if(this->IsPositiveNumber(*max))
  336.                 return result;
  337.         else
  338.         {
  339.                 result.insert(result.begin(), '-');
  340.                 return result;
  341.         }
  342. }

  344. std::string Number::StringAdd(const std::string &s1, const std::string &s2)
  345. {       
  346.         auto i1_begin = s1.rbegin();
  347.         auto i1_end = s1.rend();
  348.         auto i2_begin = s2.rbegin();
  349.         auto i2_end = s2.rend();
  350.         if((*(i1_end - 1) == '-') || (*(i1_end - 1) == '+'))
  351.                 --i1_end;
  352.         if((*(i2_end - 1) == '-') || (*(i2_end - 1) == '+'))
  353.                 --i2_end;

  355.         std::string sum;
  356.         bool carry = false;                // 进位
  357.         while((i1_begin != i1_end) && (i2_begin != i2_end))
  358.         {
  359.                 int tmp = (*i1_begin - '0') + (*i2_begin - '0') + carry;
  360.                 sum.insert(sum.begin(), (tmp % 10) + '0');

  362.                 if(10 <= tmp)
  363.                         carry = true;
  364.                 else
  365.                         carry = false;

  367.                 ++i1_begin;
  368.                 ++i2_begin;
  369.         }
  370.        
  371.         while(i1_begin != i1_end)
  372.         {
  373.                 int tmp = (*i1_begin - '0') + carry;
  374.                 sum.insert(sum.begin(), (tmp % 10) + '0');
  375.                 if(10 <= tmp)
  376.                         carry = true;
  377.                 else
  378.                         carry = false;
  379.                 ++i1_begin;
  380.         }

  382.         while(i2_begin != i2_end)
  383.         {
  384.                 int tmp = (*i2_begin - '0') + carry;
  385.                 sum.insert(sum.begin(), (tmp % 10) + '0');
  386.                 if(10 <= tmp)
  387.                         carry = true;
  388.                 else
  389.                         carry = false;
  390.                 ++i2_begin;
  391.         }

  393.         if(carry)
  394.                 sum.insert(sum.begin(), '1');

  396.         return sum;
  397. }

  399. // 好吧，此函数无效，重写一个
  400. #if 0
  401. // StringSub 工作量太大了，也许应该分给 SymbolNotEqualAdd 一些？
  402. // 不想改了，目前就这样了
  403. std::string Number::StringSub(const std::string &s1, const std::string &s2)
  404. {
  405.         /*std::string::const_reverse_iterator i1_begin = this->GetMaxR_Iterator(s1, s2);
  406.         std::string::const_reverse_iterator i1_end;
  407.         std::string::const_reverse_iterator i2_begin;
  408.         std::string::const_reverse_iterator i2_end;*/
  409.        
  410.         // C++ 要如何判断迭代器所属的对象？
  411.         // 我也没有什么好方法， try catch 一下吧
  412.         /*try
  413.         {
  414.                 i1_begin == s1.rbegin();

  416.                 i1_end = s1.rend();
  417.                 i2_begin = s2.rbegin();
  418.                 i2_end = s2.rend();
  419.         }
  420.         catch(...)
  421.         {
  422.                 i1_end = s2.rend();
  423.                 i2_begin = s1.rbegin();
  424.                 i2_end = s1.rend();
  425.         }*/
  426.         // 好吧 try catch 也不行
  427.         // 就只是让 i1_begin 指向最大的字符串开始，i1_end 指向最大的字符串结尾
  428.         // i2_begin 指向最小的字符串开始，i2_end 指向最小的字符串结尾
  429.         // 这样的方法要多少有多少

  431.         /*if(i1_begin == s1.rbegin())
  432.         {
  433.                 i1_end = s1.rend();
  434.                 i2_begin = s2.rbegin();
  435.                 i2_end = s2.rend();
  436.         }
  437.         else
  438.         {
  439.                 i1_end = s2.rend();
  440.                 i2_begin = s1.rbegin();
  441.                 i2_end = s1.rend();
  442.         }*/

  444.         std::string::const_reverse_iterator i1_begin;
  445.         std::string::const_reverse_iterator i1_end;
  446.         std::string::const_reverse_iterator i2_begin;
  447.         std::string::const_reverse_iterator i2_end;

  449.         const std::string *s = this->GetMaxR_Iterator(s1, s2);
  450.         if(s == &s1)
  451.         {
  452.                 i1_begin = s1.rbegin();
  453.                 i1_end = s1.rend();
  454.                 i2_begin = s2.rbegin();
  455.                 i2_end = s2.rend();
  456.         }
  457.         else
  458.         {
  459.                 i1_begin = s2.rbegin();
  460.                 i1_end = s2.rend();
  461.                 i2_begin = s1.rbegin();
  462.                 i2_end = s1.rend();
  463.         }

  465.        


  468.         if((*(i1_end - 1) == '-') || (*(i1_end - 1) == '+'))
  469.                 --i1_end;
  470.         if((*(i2_end - 1) == '-') || (*(i2_end - 1) == '+'))
  471.                 --i2_end;

  473.         bool borrow = false;                // 借位
  474.         std::string result;
  475.         while((i1_begin != i1_end) && (i2_begin != i2_end))
  476.         {
  477.                 int tmp = (*i1_begin - '0') - (*i2_begin - '0') - borrow;
  478.                 if(tmp < 0)
  479.                 {
  480.                         borrow = true;
  481.                         tmp += 10;
  482.                 }
  483.                 else
  484.                 {
  485.                         borrow = false;
  486.                 }
  487.                 result.insert(result.begin(), tmp + '0');

  489.                 ++i1_begin;
  490.                 ++i2_begin;
  491.         }

  493.         while(i1_begin != i1_end)
  494.         {
  495.                 int tmp = (*i1_begin - '0') - borrow;
  496.                 if(tmp < 0)
  497.                 {
  498.                         borrow = true;
  499.                         tmp += 10;
  500.                 }
  501.                 else
  502.                 {
  503.                         borrow = false;
  504.                 }
  505.                 result.insert(result.begin(), tmp + '0');

  507.                 ++i1_begin;
  508.         }

  510.         while(i2_begin != i2_end)
  511.         {
  512.                 int tmp = (*i2_begin - '0') - borrow;
  513.                 if(tmp < 0)
  514.                 {
  515.                         borrow = true;
  516.                         tmp += 10;
  517.                 }
  518.                 else
  519.                 {
  520.                         borrow = false;
  521.                 }
  522.                 result.insert(result.begin(), tmp + '0');

  524.                 ++i2_begin;
  525.         }

  527.         const std::string *max;
  528.         if(s == &s1)
  529.                 max = &s1;
  530.         else
  531.                 max = &s2;
  532.         /*if(i1_begin == s1.rbegin())
  533.                 max = &s1;
  534.         else
  535.                 max = &s2;*/

  537.         if(this->IsPositiveNumber(*max))
  538.         {
  539.                 return result;
  540.         }
  541.         else
  542.         {
  543.                 result.insert(result.begin(), '-');
  544.                 return result;
  545.         }
  546. }
  547. #endif

  549. // 绝对值大的减绝对值小的，不管符号
  550. std::string Number::StringSub(const std::string &s1, const std::string &s2)
  551. {
  552.         std::string::const_reverse_iterator i1_begin;
  553.         std::string::const_reverse_iterator i1_end;
  554.         std::string::const_reverse_iterator i2_begin;
  555.         std::string::const_reverse_iterator i2_end;

  557.         const std::string *max = this->GetAbsoluteMaxString(s1, s2);
  558.         if(max == &s1)
  559.         {
  560.                 i1_begin = s1.rbegin();
  561.                 i1_end = s1.rend();
  562.                 i2_begin = s2.rbegin();
  563.                 i2_end = s2.rend();
  564.         }
  565.         else
  566.         {
  567.                 i1_begin = s2.rbegin();
  568.                 i1_end = s2.rend();
  569.                 i2_begin = s1.rbegin();
  570.                 i2_end = s1.rend();
  571.         }

  573.         if((*(i1_end - 1) == '-') || (*(i1_end - 1) == '+'))
  574.                 --i1_end;
  575.         if((*(i2_end - 1) == '-') || (*(i2_end - 1) == '+'))
  576.                 --i2_end;

  578.         bool borrow = false;                // 借位
  579.         std::string result;
  580.         while((i1_begin != i1_end) && (i2_begin != i2_end))
  581.         {
  582.                 int tmp = (*i1_begin - '0') - (*i2_begin - '0') - borrow;
  583.                 if(tmp < 0)
  584.                 {
  585.                         borrow = true;
  586.                         tmp += 10;
  587.                 }
  588.                 else
  589.                 {
  590.                         borrow = false;
  591.                 }
  592.                 result.insert(result.begin(), tmp + '0');

  594.                 ++i1_begin;
  595.                 ++i2_begin;
  596.         }

  598.         while(i1_begin != i1_end)
  599.         {
  600.                 int tmp = (*i1_begin - '0') - borrow;
  601.                 if(tmp < 0)
  602.                 {
  603.                         borrow = true;
  604.                         tmp += 10;
  605.                 }
  606.                 else
  607.                 {
  608.                         borrow = false;
  609.                 }
  610.                 result.insert(result.begin(), tmp + '0');

  612.                 ++i1_begin;
  613.         }

  615.         while(i2_begin != i2_end)
  616.         {
  617.                 int tmp = (*i2_begin - '0') - borrow;
  618.                 if(tmp < 0)
  619.                 {
  620.                         borrow = true;
  621.                         tmp += 10;
  622.                 }
  623.                 else
  624.                 {
  625.                         borrow = false;
  626.                 }
  627.                 result.insert(result.begin(), tmp + '0');

  629.                 ++i2_begin;
  630.         }

  632.         return result;
  633. }


  636. //std::string::const_reverse_iterator Number::GetMaxR_Iterator(const std::string &s1, const std::string &s2)
  637. //{
  638. //        size_t len1 = s1.size();
  639. //        size_t len2 = s2.size();
  640. //        if((s1[0] == '-') || (s1[0] == '+'))
  641. //                --len1;
  642. //        if((s2[0] == '-') || (s2[0] == '+'))
  643. //                --len2;
  644. //       
  645. //        if(len1 == len2)
  646. //        {
  647. //                auto i1_begin = s1.rbegin();
  648. //                auto i1_end = s1.rend();
  649. //                auto i2_begin = s2.rbegin();
  650. //                auto i2_end = s2.rend();
  651. //                if((*(i1_end - 1) == '-') || (*(i1_end - 1) == '+'))
  652. //                        --i1_end;
  653. //                if((*(i2_end - 1) == '-') || (*(i2_end - 1) == '+'))
  654. //                        --i2_end;
  655. //
  656. //                if(std::string(i1_begin, i1_end) > std::string(i2_begin, i2_end))
  657. //                        return s1.rbegin();
  658. //                else
  659. //                        return s2.rbegin();
  660. //        }
  661. //        else
  662. //        {
  663. //                if(len1 > len2)
  664. //                        return s1.rbegin();
  665. //                else
  666. //                        return s2.rbegin();
  667. //        }
  668. //}

  670. //const std::string *Number::GetMaxR_Iterator(const std::string &s1, const std::string &s2)
  671. //{
  672. //        size_t len1 = s1.size();
  673. //        size_t len2 = s2.size();
  674. //        if((s1[0] == '-') || (s1[0] == '+'))
  675. //                --len1;
  676. //        if((s2[0] == '-') || (s2[0] == '+'))
  677. //                --len2;
  678. //
  679. //        if(len1 == len2)
  680. //        {
  681. //                auto i1_begin = s1.rbegin();
  682. //                auto i1_end = s1.rend();
  683. //                auto i2_begin = s2.rbegin();
  684. //                auto i2_end = s2.rend();
  685. //                if((*(i1_end - 1) == '-') || (*(i1_end - 1) == '+'))
  686. //                        --i1_end;
  687. //                if((*(i2_end - 1) == '-') || (*(i2_end - 1) == '+'))
  688. //                        --i2_end;
  689. //
  690. //                if(std::string(i1_begin, i1_end) > std::string(i2_begin, i2_end))
  691. //                        return &s1;
  692. //                else
  693. //                        return &s2;
  694. //        }
  695. //        else
  696. //        {
  697. //                if(len1 > len2)
  698. //                        return &s1;
  699. //                else
  700. //                        return &s2;
  701. //        }
  702. //}

  704. const std::string * Number::GetAbsoluteMaxString(const std::string & s1, const std::string & s2)
  705. {
  706.                 size_t len1 = s1.size();
  707.                 size_t len2 = s2.size();
  708.                 if((s1[0] == '-') || (s1[0] == '+'))
  709.                         --len1;
  710.                 if((s2[0] == '-') || (s2[0] == '+'))
  711.                         --len2;
  712.        
  713.                 if(len1 == len2)
  714.                 {
  715.                         std::string::const_iterator i1 = s1.begin();
  716.                         std::string::const_iterator i2 = s2.begin();
  717.                         if((*i1 == '-') || (*i1 == '+'))
  718.                                 ++i1;
  719.                         if((*i2 == '-') || (*i2 == '+'))
  720.                                 ++i2;
  721.        
  722.                         if(std::string(i1, s1.end()) > std::string(i2, s2.end()))
  723.                                 return &s1;
  724.                         else
  725.                                 return &s2;
  726.                 }
  727.                 else
  728.                 {
  729.                         if(len1 > len2)
  730.                                 return &s1;
  731.                         else
  732.                                 return &s2;
  733.                 }
  734. }

  736. //std::string &Number::DebugGetNum(void)
  737. //{
  738. //        return this->num;
  739. //}

  741. std::string Number::OppositeNumber(const std::string &s)
  742. {
  743.         std::string result(s);
  744.         if(this->IsPositiveNumber(result))
  745.         {
  746.                 if(result[0] == '+')
  747.                         result[0] = '-';
  748.                 else
  749.                         result.insert(result.begin(), '-');
  750.         }
  751.         else
  752.         {
  753.                 result.erase(result.begin());
  754.         }

  756.         return result;
  757. }

  759. Number Number::OppositeNumber(const Number &n)
  760. {
  761.         return Number(this->OppositeNumber(n.num));
  762. }

  764. bool Number::IsZero(const std::string &s)
  765. {
  766.         for(auto iter = s.begin(); iter != s.end(); ++iter)
  767.         {
  768.                 if(*iter != '0')
  769.                         return false;
  770.         }
  771.         return true;
  772. }

  774. Number Number::AbsoluteValue(const Number &n)
  775. {
  776.         if(this->IsPositiveNumber(n.num))
  777.                 return Number(n);
  778.         else
  779.                 return Number(this->OppositeNumber(n.num));
  780. }

  782. std::string Number::RemoveZero(const std::string &s)
  783. {
  784.         std::string result(s);
  785.         while(!result.empty())
  786.         {
  787.                 if(result[0] != '0')
  788.                         break;
  789.                 else
  790.                         result.erase(result.begin());
  791.         }

  793.         if(!result.empty())
  794.                 return result;
  795.         else
  796.                 return std::string("0");
  797. }

  799. std::ostream &operator<<(std::ostream &out, const Number &n)
  800. {
  801.         out << n.num;
  802.         return out;
  803. }

  805. #if 0
  806. int main()
  807. {
  808.         std::string num = "100";

  810.         Number n1 = "1234";
  811.         Number n2("1234");
  812.         Number n3 = num;
  813.         Number n4(num);
  814.         Number n5 = n4;

  816.         n1 == n2;
  817.         n1 == num;
  818.         n1 == "123";

  820.         n1 = num;
  821.         n1 = n2 = "100";

  823.         n1 + n2;
  824.         n1 + num;
  825.         n1 + "123";

  827. #if 0
  828.         num = n1.StringAdd("1234", "56");
  829.         std::cout << num << "\t" << 1234 + 56 << std::endl;
  830.         num = n1.StringAdd("1234", "567890");
  831.         std::cout << num << "\t" << 1234 + 567890 << std::endl;
  832.         num = n1.StringAdd("-1234", "56");
  833.         std::cout << num << "\t" << 1234 + 56 << std::endl;
  834.         num = n1.StringAdd("1234", "-56");
  835.         std::cout << num << "\t" << 1234 + 56 << std::endl;
  836.         num = n1.StringAdd("+1234", "56");
  837.         std::cout << num << "\t" << 1234 + 56 << std::endl;
  838.         num = n1.StringAdd("1234", "+56");
  839.         std::cout << num << "\t" << 1234 + 56 << std::endl;
  840.         num = n1.StringAdd("-1234", "-56");
  841.         std::cout << num << "\t" << 1234 + 56 << std::endl;
  842.         num = n1.StringAdd("-1234", "+56");
  843.         std::cout << num << "\t" << 1234 + 56 << std::endl;
  844.         num = n1.StringAdd("+1234", "-56");
  845.         std::cout << num << "\t" << 1234 + 56 << std::endl;
  846.         num = n1.StringAdd("+1234", "+56");
  847.         std::cout << num << "\t" << 1234 + 56 << std::endl;

  849.         n1 = "-1234";
  850.         n2 = "-456789";
  851.         n3 = n1 + n2;

  853.         std::cout << (-1234) + (-456789) << std::endl;



  857.         num = n1.StringSub("1234", "56");
  858.         std::cout << num << "\t" << 1234 - 56 << std::endl;
  859.         num = n1.StringSub("1234", "567890");
  860.         std::cout << num << "\t" << 567890 - 1234 << std::endl;
  861.         num = n1.StringSub("-1234", "56");
  862.         std::cout << num << "\t" << 1234 - 56 << std::endl;
  863.         num = n1.StringSub("1234", "-56");
  864.         std::cout << num << "\t" << 1234 - 56 << std::endl;
  865.         num = n1.StringSub("+1234", "56");
  866.         std::cout << num << "\t" << 1234 - 56 << std::endl;
  867.         num = n1.StringSub("1234", "+56");
  868.         std::cout << num << "\t" << 1234 - 56 << std::endl;
  869.         num = n1.StringSub("-1234", "-56");
  870.         std::cout << num << "\t" << 1234 - 56 << std::endl;
  871.         num = n1.StringSub("-1234", "+56");
  872.         std::cout << num << "\t" << 1234 - 56 << std::endl;
  873.         num = n1.StringSub("+1234", "-56");
  874.         std::cout << num << "\t" << 1234 - 56 << std::endl;
  875.         num = n1.StringSub("+1234", "+56");
  876.         std::cout << num << "\t" << 1234 - 56 << std::endl;

  878.         n2 = "1234";
  879.         n3 = "56";
  880.         n1 = n2 + n3;
  881.         std::cout << n1.DebugGetNum() << "\t" << 1234 + 56 << std::endl;
  882.         n2 = "1234";
  883.         n3 = "567890";
  884.         n1 = n2 + n3;
  885.         std::cout << n1.DebugGetNum() << "\t" << 1234 + 567890 << std::endl;
  886.         n2 = "-1234";
  887.         n3 = "56";
  888.         n1 = n2 + n3;
  889.         std::cout << n1.DebugGetNum() << "\t" << (-1234) + 56 << std::endl;
  890.         n2 = "1234";
  891.         n3 = "-56";
  892.         n1 = n2 + n3;
  893.         std::cout << n1.DebugGetNum() << "\t" << 1234 + (-56) << std::endl;
  894.         n2 = "+1234";
  895.         n3 = "56";
  896.         n1 = n2 + n3;
  897.         std::cout << n1.DebugGetNum() << "\t" << 1234 + 56 << std::endl;
  898.         n2 = "1234";
  899.         n3 = "+56";
  900.         n1 = n2 + n3;
  901.         std::cout << n1.DebugGetNum() << "\t" << 1234 + 56 << std::endl;
  902.         n2 = "-1234";
  903.         n3 = "-56";
  904.         n1 = n2 + n3;
  905.         std::cout << n1.DebugGetNum() << "\t" << (-1234) + (-56) << std::endl;
  906.         n2 = "-1234";
  907.         n3 = "+56";
  908.         n1 = n2 + n3;
  909.         std::cout << n1.DebugGetNum() << "\t" << (-1234) + 56 << std::endl;
  910.         n2 = "+1234";
  911.         n3 = "+56";
  912.         n1 = n2 + n3;
  913.         std::cout << n1.DebugGetNum() << "\t" << 1234 + 56 << std::endl;
  914.         n2 = "+1234";
  915.         n3 = "-56";
  916.         n1 = n2 + n3;
  917.         std::cout << n1.DebugGetNum() << "\t" << 1234 + (-56) << std::endl;


  920.         n2 = "1234";
  921.         n3 = "56";
  922.         n1 = n2 - n3;
  923.         std::cout << n1.DebugGetNum() << "\t" << 1234 - 56 << std::endl;
  924.         n2 = "1234";
  925.         n3 = "567890";
  926.         n1 = n2 - n3;
  927.         std::cout << n1.DebugGetNum() << "\t" << 1234 - 567890 << std::endl;
  928.         n2 = "-1234";
  929.         n3 = "56";
  930.         n1 = n2 - n3;
  931.         std::cout << n1.DebugGetNum() << "\t" << (-1234) - 56 << std::endl;
  932.         n2 = "1234";
  933.         n3 = "-56";
  934.         n1 = n2 - n3;
  935.         std::cout << n1.DebugGetNum() << "\t" << 1234 - (-56) << std::endl;
  936.         n2 = "+1234";
  937.         n3 = "56";
  938.         n1 = n2 - n3;
  939.         std::cout << n1.DebugGetNum() << "\t" << 1234 - 56 << std::endl;
  940.         n2 = "1234";
  941.         n3 = "+56";
  942.         n1 = n2 - n3;
  943.         std::cout << n1.DebugGetNum() << "\t" << 1234 - 56 << std::endl;
  944.         n2 = "-1234";
  945.         n3 = "-56";
  946.         n1 = n2 - n3;
  947.         std::cout << n1.DebugGetNum() << "\t" << (-1234) - (-56) << std::endl;
  948.         n2 = "-1234";
  949.         n3 = "+56";
  950.         n1 = n2 - n3;
  951.         std::cout << n1.DebugGetNum() << "\t" << (-1234) - 56 << std::endl;
  952.         n2 = "+1234";
  953.         n3 = "+56";
  954.         n1 = n2 - n3;
  955.         std::cout << n1.DebugGetNum() << "\t" << 1234 - 56 << std::endl;
  956.         n2 = "+1234";
  957.         n3 = "-56";
  958.         n1 = n2 - n3;
  959.         std::cout << n1.DebugGetNum() << "\t" << 1234 - (-56) << std::endl;


  962.         n1 != n2;
  963.         n1 != num;
  964.         n1 != "1234";

  966.         n2 = "3";
  967.         n1 = n2 * "4";

  969.         std::cout << Number("1234") * Number("56") << "\t" << 1234 * 56 << std::endl;
  970.         std::cout << Number("1234") * Number("567890") << "\t" << 1234 * 567890 << std::endl;
  971.         std::cout << Number("-1234") * Number("56") << "\t" << (-1234) * 56 << std::endl;
  972.         std::cout << Number("1234") * Number("-56") << "\t" << 1234 * (-56) << std::endl;
  973.         std::cout << Number("+1234") * Number("56") << "\t" << 1234 * 56 << std::endl;
  974.         std::cout << Number("1234") * Number("+56") << "\t" << 1234 * 56 << std::endl;
  975.         std::cout << Number("-1234") * Number("-56") << "\t" << (-1234) * (-56) << std::endl;
  976.         std::cout << Number("-1234") * Number("+56") << "\t" << (-1234) * 56 << std::endl;
  977.         std::cout << Number("+1234") * Number("-56") << "\t" << 1234 * (-56) << std::endl;
  978.         std::cout << Number("+1234") * Number("+56") << "\t" << 1234 * 56 << std::endl;

  980.         n1 - n2;
  981.         n1 - num;
  982.         n1 - "123";

  984.         n1 * n2;
  985.         n1 * num;
  986.         n1 * "123";

  988.         n1 / n2;
  989.         n1 / num;
  990.         n1 / "123";

  992.         if(Number("1"))
  993.                 std::wcout << "1" << std::endl;
  994.         if(Number("0"))
  995.                 std::wcout << "0" << std::endl;
  996.         if(Number("123"))
  997.                 std::wcout << "123" << std::endl;


  1000.         std::cout << Number("10") / Number("3") << "\t" << 10 / 3 << std::endl;

  1002.         std::cout << Number("1234") / Number("56") << "\t" << 1234 / 56 << std::endl;
  1003.         std::cout << Number("1234") / Number("567890") << "\t" << 1234 / 567890 << std::endl;
  1004.         std::cout << Number("-1234") / Number("56") << "\t" << (-1234) / 56 << std::endl;
  1005.         std::cout << Number("1234") / Number("-56") << "\t" << 1234 / (-56) << std::endl;
  1006.         std::cout << Number("+1234") / Number("56") << "\t" << 1234 / 56 << std::endl;
  1007.         std::cout << Number("1234") / Number("+56") << "\t" << 1234 / 56 << std::endl;
  1008.         std::cout << Number("-1234") / Number("-56") << "\t" << (-1234) / (-56) << std::endl;
  1009.         std::cout << Number("-1234") / Number("+56") << "\t" << (-1234) / 56 << std::endl;
  1010.         std::cout << Number("+1234") / Number("-56") << "\t" << 1234 / (-56) << std::endl;
  1011.         std::cout << Number("+1234") / Number("+56") << "\t" << 1234 / 56 << std::endl;

  1013.         n1 % n2;
  1014.         n1 % num;
  1015.         n1 % "123";

  1017.         std::cout << Number("10") % Number("3") << "\t" << 10 % 3 << std::endl;

  1019.         std::cout << Number("1234") % Number("56") << "\t" << 1234 % 56 << std::endl;
  1020.         std::cout << Number("1234") % Number("567890") << "\t" << 1234 % 567890 << std::endl;
  1021.         std::cout << Number("-1234") % Number("56") << "\t" << (-1234) % 56 << std::endl;
  1022.         std::cout << Number("1234") % Number("-56") << "\t" << 1234 % (-56) << std::endl;
  1023.         std::cout << Number("+1234") % Number("56") << "\t" << 1234 % 56 << std::endl;
  1024.         std::cout << Number("1234") % Number("+56") << "\t" << 1234 % 56 << std::endl;
  1025.         std::cout << Number("-1234") % Number("-56") << "\t" << (-1234) % (-56) << std::endl;
  1026.         std::cout << Number("-1234") % Number("+56") << "\t" << (-1234) % 56 << std::endl;
  1027.         std::cout << Number("+1234") % Number("-56") << "\t" << 1234 % (-56) << std::endl;
  1028.         std::cout << Number("+1234") % Number("+56") << "\t" << 1234 % 56 << std::endl;


  1031.         n1 = "2";
  1032.         n2 = "10";
  1033.         num = "10";
  1034.         n1 ^ n2;
  1035.         n1 ^ num;
  1036.         n1 ^ "10";

  1038.         std::cout << (Number("2") ^ Number("10")) << "\t" << pow(2, 10) << std::endl;
  1039.         std::cout << (Number("10") ^ Number("2")) << "\t" << pow(10, 2) << std::endl;
  1040.         std::cout << (Number("-2") ^ Number("10")) << "\t" << pow(-2, 10) << std::endl;
  1041.         std::cout << (Number("2") ^ Number("-10")) << "\t" << pow(2, -10) << std::endl;
  1042.         std::cout << (Number("+2") ^ Number("10")) << "\t" << pow(2, 10) << std::endl;
  1043.         std::cout << (Number("2") ^ Number("+10")) << "\t" << pow(2, 10) << std::endl;
  1044.         std::cout << (Number("-2") ^ Number("-10")) << "\t" << pow(-2, -10) << std::endl;
  1045.         std::cout << (Number("-2") ^ Number("+10")) << "\t" << pow(-2, 10) << std::endl;
  1046.         std::cout << (Number("+2") ^ Number("+10")) << "\t" << pow(2, 10) << std::endl;
  1047.         std::cout << (Number("+2") ^ Number("-10")) << "\t" << pow(2, -10) << std::endl;
  1048. #endif
  1049.         return 0;
  1050. }

  1052. #endif
复制代码


main.cpp
  1. #include <iostream>
  2. #include "Number.hpp"

  4. int main()
  5. {
  6.         std::cout << (Number("2") ^ Number("10")) << std::endl;                // 2的10次方
  7.         std::cout << (Number("2") ^ Number("16")) << std::endl;
  8.         return 0;
  9. }
复制代码
想知道小甲鱼最近在做啥？请访问 -> ilovefishc.com
回复 支持 反对

使用道具 举报

人造人
发表于 2018-5-28 14:09:28 | 显示全部楼层
附上源文件吧
Number.zip (4.53 KB, 下载次数: 1)
想知道小甲鱼最近在做啥？请访问 -> ilovefishc.com
回复 支持 反对

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

小黑屋|手机版|Archiver|鱼C工作室 ( 粤ICP备18085999号-1 | 粤公网安备 44051102000585号)

GMT+8, 2024-4-30 22:32

Powered by Discuz! X3.4

© 2001-2023 Discuz! Team.

快速回复 返回顶部 返回列表