API tools faq
paste
Advertisement
mrAnderson33

полиномы

mrAnderson33
Nov 24th, 2017
133
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 16.91 KB | None | 0 0
raw download clone embed print report
  1. /*CScherbakovNide.h*/
  2. #include "cScherbakovMonom.h"
  3.  
  4. using std::bad_alloc;
  5.  
  6. class cScherbakovNode
  7. {
  8.  
  9.     cScherbakovMonom* cScherbakovMonomPointer;
  10.     cScherbakovNode* next;
  11.  
  12. public:
  13.  
  14.     cScherbakovNode(char* str);
  15.     cScherbakovNode(int c = 0, unsigned d = 0);
  16.     cScherbakovNode(const cScherbakovMonom& m);
  17.     cScherbakovNode(const cScherbakovNode& n);
  18.  
  19.     cScherbakovNode& operator=(const cScherbakovNode& n);
  20.  
  21.     void setCoeff(int c = 0) { cScherbakovMonomPointer->setCoeff(c); }
  22.     void setDegree(unsigned d = 0){ cScherbakovMonomPointer->setDegree(d); }
  23.  
  24.     int getCoeff() const { return cScherbakovMonomPointer->getCoeff(); }
  25.     unsigned getDegree() const { return cScherbakovMonomPointer->getDegree(); }
  26.  
  27.     bool getSign() const { return cScherbakovMonomPointer->getSign(); }
  28.  
  29.     cScherbakovMonom* getcScherbakovMonomPointer() const { return cScherbakovMonomPointer; }
  30.  
  31.     void setNext(cScherbakovNode* cScherbakovNodePtr) { next = cScherbakovNodePtr; }
  32.  
  33.     cScherbakovNode* getNext() const { return next; }
  34.  
  35.     cScherbakovNode operator-() const;
  36.  
  37.     cScherbakovNode operator+(const cScherbakovNode& sum) const;
  38.     cScherbakovNode operator-(const cScherbakovNode& sub) const;
  39.     cScherbakovNode operator*(const cScherbakovNode& mul) const;
  40.     cScherbakovNode operator/(const cScherbakovNode& div) const;
  41.     cScherbakovNode operator%(const cScherbakovNode& mod) const;
  42.  
  43.     friend ostream& operator<<(ostream& stream, const cScherbakovNode& n);
  44.  
  45.     ~cScherbakovNode();
  46.  
  47. };
  48.  
  49. /*CScherbakovNode.cpp*/
  50. #include "cScherbakovNode.h"
  51.  
  52. cScherbakovNode::cScherbakovNode(char* str) : next(nullptr)
  53. {
  54.     try
  55.     {
  56.         cScherbakovMonomPointer = new cScherbakovMonom(str);
  57.     }
  58.     catch (const bad_alloc& exc) { std::cout << exc.what(); }
  59. }
  60.  
  61. cScherbakovNode::cScherbakovNode(int c, unsigned d) : next(nullptr)
  62. {
  63.     try
  64.     {
  65.         cScherbakovMonomPointer = new cScherbakovMonom(c, d);
  66.     }
  67.     catch (const bad_alloc& exc) { std::cout << exc.what(); }
  68. }
  69.  
  70. cScherbakovNode::cScherbakovNode(const cScherbakovMonom& m) : next(nullptr)
  71. {
  72.     try
  73.     {
  74.         cScherbakovMonomPointer = new cScherbakovMonom(m);
  75.     }
  76.     catch (const bad_alloc& exc) { std::cout << exc.what(); }
  77. }
  78.  
  79. cScherbakovNode::cScherbakovNode(const cScherbakovNode& n) : next(nullptr)
  80. {
  81.     try
  82.     {
  83.         cScherbakovMonomPointer = new cScherbakovMonom(*n.getcScherbakovMonomPointer());
  84.     }
  85.     catch (const bad_alloc& exc) { std::cout << exc.what(); }
  86. }
  87.  
  88. cScherbakovNode& cScherbakovNode::operator=(const cScherbakovNode& n)
  89. {
  90.     setCoeff(n.getCoeff());
  91.     setDegree(n.getDegree());
  92.     return *this;
  93. }
  94.  
  95. cScherbakovNode cScherbakovNode::operator-() const
  96. {
  97.     return cScherbakovNode(-*cScherbakovMonomPointer);
  98. }
  99.  
  100. cScherbakovNode cScherbakovNode::operator+(const cScherbakovNode& sum) const
  101. {
  102.     return cScherbakovNode(*cScherbakovMonomPointer + *sum.getcScherbakovMonomPointer());
  103. }
  104.  
  105. cScherbakovNode cScherbakovNode::operator-(const cScherbakovNode& sub) const
  106. {
  107.     return cScherbakovNode(*cScherbakovMonomPointer - *sub.getcScherbakovMonomPointer());
  108. }
  109.  
  110. cScherbakovNode cScherbakovNode::operator*(const cScherbakovNode& mul) const
  111. {
  112.     return cScherbakovNode(*cScherbakovMonomPointer * *mul.getcScherbakovMonomPointer());
  113. }
  114.  
  115. cScherbakovNode cScherbakovNode::operator/(const cScherbakovNode& div) const
  116. {
  117.     return cScherbakovNode(*cScherbakovMonomPointer / *div.getcScherbakovMonomPointer());
  118. }
  119.  
  120. cScherbakovNode cScherbakovNode::operator%(const cScherbakovNode& mod) const
  121. {
  122.     return cScherbakovNode(*cScherbakovMonomPointer % *mod.getcScherbakovMonomPointer());
  123. }
  124.  
  125. ostream& operator<<(ostream& stream, const cScherbakovNode& n)
  126. {
  127.     return stream << *n.getcScherbakovMonomPointer();
  128. }
  129.  
  130. cScherbakovNode::~cScherbakovNode()
  131. {
  132.     delete cScherbakovMonomPointer;
  133. }
  134. /*CScherbakovMonom.h*/
  135. #include "exceptions.h"
  136.  
  137. // '+' = true
  138. // '-' = false
  139.  
  140. int fromStringToInt(char*);
  141.  
  142. class cScherbakovMonom
  143. {
  144.  
  145.     int iScherbakovCoeff;
  146.     unsigned uScherbakovDegree;
  147.  
  148. public:
  149.  
  150.     cScherbakovMonom(int c = 0, unsigned d = 0) : iScherbakovCoeff(c), uScherbakovDegree(c ? d : 0) {  }
  151.     cScherbakovMonom(char* str);
  152.    
  153.     void setCoeff(int c = 0) { iScherbakovCoeff = c; }
  154.     void setDegree(unsigned d = 0) { uScherbakovDegree = d; }
  155.  
  156.     int getCoeff() const { return iScherbakovCoeff; }
  157.     unsigned getDegree() const { return uScherbakovDegree; }
  158.    
  159.     bool getSign() const { return iScherbakovCoeff >= 0; }
  160.  
  161.     cScherbakovMonom operator-() const;
  162.  
  163.     cScherbakovMonom operator+(const cScherbakovMonom& sum) const;
  164.     cScherbakovMonom operator-(const cScherbakovMonom& sub) const;
  165.     cScherbakovMonom operator*(const cScherbakovMonom& mul) const;
  166.     cScherbakovMonom operator/(const cScherbakovMonom& div) const;
  167.     cScherbakovMonom operator%(const cScherbakovMonom& mod) const;
  168.    
  169.     friend ostream& operator<<(ostream& stream, const cScherbakovMonom& m);
  170.  
  171. };
  172. /*CScherbakovMonom.cpp*/
  173. #include "cScherbakovMonom.h"
  174.  
  175. int fromStringToNum(char *str)
  176. {
  177.     char* s = str;
  178.     int result = 0;
  179.     while (*s)
  180.         result = result * 10 + *s++ - '0';
  181.     return result;
  182. }
  183.  
  184. cScherbakovMonom::cScherbakovMonom(char* str) : iScherbakovCoeff(0), uScherbakovDegree(0)
  185. {
  186.     if (*str == 'x')
  187.     {
  188.         iScherbakovCoeff = 1;
  189.         char* s = str + 1;
  190.         if (!*s) uScherbakovDegree = 1;
  191.         else if (*s == '^') uScherbakovDegree = fromStringToNum(s + 1);
  192.     }
  193.     else if (isdigit(*str))
  194.     {
  195.         char* s = str;
  196.         while (*s && isdigit(*s)) s++;
  197.         if (!*s) iScherbakovCoeff = fromStringToNum(str);
  198.         else
  199.         {
  200.             char buf[100] = "", *b = buf, *s1 = str;
  201.             while (s1 != s) *b++ = *s1++;
  202.             *b = 0;
  203.             iScherbakovCoeff = fromStringToNum(buf);
  204.             if (!*(s + 1)) uScherbakovDegree = 1;
  205.             else if (*(s + 1) == '^') uScherbakovDegree = fromStringToNum(s + 2);
  206.         }
  207.     }
  208.     else if (*str == '+' || *str == '-')
  209.     {
  210.         bool flag = *str == '+';
  211.         char *s = str + 1;
  212.         if (*s == 'x')
  213.         {
  214.             iScherbakovCoeff = 1;
  215.             s++;
  216.             if (!*s) uScherbakovDegree = 1;
  217.             else if (*s == '^') uScherbakovDegree = fromStringToNum(s + 1);
  218.         }
  219.         else if (isdigit(*s))
  220.         {
  221.             char *s1 = s;
  222.             while (s1 && isdigit(*s1)) s1++;
  223.             if (!*s1) iScherbakovCoeff = fromStringToNum(s);
  224.             else
  225.             {
  226.                 char buf[100] = "", *b = buf, *s2 = s;
  227.                 while (s2 != s1) *b++ = *s2++;
  228.                 *b = 0;
  229.                 iScherbakovCoeff = fromStringToNum(buf);
  230.                 if (!*(s1 + 1)) uScherbakovDegree = 1;
  231.                 else if (*(s1 + 1) == '^') uScherbakovDegree = fromStringToNum(s1 + 2);
  232.             }
  233.         }
  234.         if (!flag) iScherbakovCoeff = -iScherbakovCoeff;
  235.     }
  236. }
  237.  
  238. cScherbakovMonom cScherbakovMonom::operator-() const
  239. {
  240.     return cScherbakovMonom(-iScherbakovCoeff, uScherbakovDegree);
  241. }
  242.  
  243. cScherbakovMonom cScherbakovMonom::operator+(const cScherbakovMonom& sum) const
  244. {
  245.     return cScherbakovMonom(iScherbakovCoeff + sum.getCoeff(), uScherbakovDegree);
  246. }
  247. cScherbakovMonom cScherbakovMonom::operator-(const cScherbakovMonom& sub) const
  248. {
  249.     return cScherbakovMonom(iScherbakovCoeff - sub.getCoeff(), uScherbakovDegree);
  250. }
  251.  
  252. cScherbakovMonom cScherbakovMonom::operator*(const cScherbakovMonom& mul) const
  253. {
  254.     return cScherbakovMonom(iScherbakovCoeff * mul.getCoeff(), uScherbakovDegree + mul.getDegree());
  255. }
  256.  
  257. cScherbakovMonom cScherbakovMonom::operator/(const cScherbakovMonom& div) const
  258. {
  259.     try
  260.     {
  261.         if (!div.getCoeff()) throw dividing_by_zero();
  262.     }
  263.     catch (const dividing_by_zero& exc) { std::cout << exc.what(); }
  264.     if (uScherbakovDegree < div.getDegree()) return cScherbakovMonom();
  265.     else return cScherbakovMonom(iScherbakovCoeff / div.getCoeff(), uScherbakovDegree - div.getDegree());
  266. }
  267.  
  268. cScherbakovMonom cScherbakovMonom::operator%(const cScherbakovMonom& mod) const
  269. {
  270.     return *this - *this / mod * mod;
  271. }
  272.  
  273. ostream& operator<<(ostream& stream, const cScherbakovMonom& m)
  274. {
  275.     if (!m.getCoeff()) return stream << '0';
  276.     else if (abs(m.getCoeff()) != 1 || !m.getDegree()) stream << abs(m.getCoeff());
  277.     if (m.getDegree()) stream << 'x';
  278.     if (m.getDegree() != 1 && m.getDegree()) stream << '^' << m.getDegree();
  279.     return stream;
  280. }
  281.  
  282. /*CScherbakovPolynom.h*/
  283.  
  284. #include "cScherbakovNode.h"
  285.  
  286. class cScherbakovPolynom
  287. {
  288.  
  289.     cScherbakovNode* first;
  290.  
  291. public:
  292.  
  293.     cScherbakovPolynom();
  294.     cScherbakovPolynom(char* str);
  295.     cScherbakovPolynom(int c, unsigned d);
  296.     cScherbakovPolynom(const cScherbakovMonom& m);
  297.     cScherbakovPolynom(const cScherbakovNode& n);
  298.     cScherbakovPolynom(const cScherbakovPolynom& p);
  299.  
  300.     cScherbakovPolynom& operator=(const cScherbakovPolynom& p);
  301.  
  302.     cScherbakovNode* getFirst() const { return first; }
  303.  
  304.     void add(char* str);
  305.     void add(int c = 0, unsigned d = 0);
  306.     void add(const cScherbakovMonom& m);
  307.     void add(const cScherbakovNode& n);
  308.  
  309.     cScherbakovPolynom operator-() const;
  310.  
  311.     cScherbakovPolynom operator+(const cScherbakovPolynom& sum) const;
  312.     cScherbakovPolynom operator-(const cScherbakovPolynom& sub) const;
  313.     cScherbakovPolynom operator*(const cScherbakovPolynom& mul) const;
  314.     cScherbakovPolynom operator/(const cScherbakovPolynom& div) const;
  315.     cScherbakovPolynom operator%(const cScherbakovPolynom& mod) const;
  316.  
  317.     friend ostream& operator<<(ostream& stream, const cScherbakovPolynom& p);
  318.     friend istream& operator>>(istream& stream, cScherbakovPolynom& p);
  319.  
  320.     ~cScherbakovPolynom();
  321.  
  322. };
  323.  
  324. /*CScherbakovPolynom.cpp*/
  325. #include "cScherbakovPolynom.h"
  326.  
  327. cScherbakovPolynom::cScherbakovPolynom() : first(nullptr) {  }
  328.  
  329. cScherbakovPolynom::cScherbakovPolynom(char* str) : first(nullptr)
  330. {
  331.     char *s = str, buf[100] = "", *b = buf;
  332.     if (*s == '+' || *s == '-') *b++ = *s++;
  333.     while (*s)
  334.     {
  335.         *b++ = *s++;
  336.         if (!*s || *s == '+' || *s == '-')
  337.         {
  338.             *b = 0;
  339.             b = buf;
  340.             add(buf);
  341.             if (*s) *b++ = *s++;
  342.         }
  343.     }
  344. }
  345.  
  346. cScherbakovPolynom::cScherbakovPolynom(int c, unsigned d) : first(nullptr)
  347. {
  348.     if (c)
  349.     {
  350.         try
  351.         {
  352.             first = new cScherbakovNode(c, d);
  353.         }
  354.         catch (const bad_alloc& exc) { std::cout << exc.what(); }
  355.     }
  356. }
  357.  
  358. cScherbakovPolynom::cScherbakovPolynom(const cScherbakovMonom& m) : first(nullptr)
  359. {
  360.     if (m.getCoeff())
  361.     {
  362.         try
  363.         {
  364.             first = new cScherbakovNode(m);
  365.         }
  366.         catch (const bad_alloc& exc) { std::cout << exc.what(); }
  367.     }
  368. }
  369.  
  370. cScherbakovPolynom::cScherbakovPolynom(const cScherbakovNode& n) : first(nullptr)
  371. {
  372.     if (n.getCoeff())
  373.     {
  374.         try
  375.         {
  376.             first = new cScherbakovNode(n);
  377.         }
  378.         catch (const bad_alloc& exc) { std::cout << exc.what(); }
  379.     }
  380. }
  381.  
  382. cScherbakovPolynom::cScherbakovPolynom(const cScherbakovPolynom& p) : first(nullptr)
  383. {
  384.     if (p.getFirst())
  385.     {
  386.         try
  387.         {
  388.             first = new cScherbakovNode(*p.getFirst());
  389.         }
  390.         catch (const bad_alloc& exc) { std::cout << exc.what(); }
  391.         cScherbakovNode* pPtr = p.getFirst();
  392.         cScherbakovNode* tPtr = first;
  393.         while (pPtr->getNext())
  394.         {
  395.             try
  396.             {
  397.                 tPtr->setNext(new cScherbakovNode(*pPtr->getNext()));
  398.             }
  399.             catch (const bad_alloc& exc) { std::cout << exc.what(); }
  400.             pPtr = pPtr->getNext();
  401.             tPtr = tPtr->getNext();
  402.         }
  403.     }
  404. }
  405.  
  406. cScherbakovPolynom& cScherbakovPolynom::operator=(const cScherbakovPolynom& p)
  407. {
  408.     if (first)
  409.     {
  410.         cScherbakovNode* runner1 = first;
  411.         cScherbakovNode* runner2 = first->getNext();
  412.         while (runner2)
  413.         {
  414.             delete runner1;
  415.             runner1 = runner2;
  416.             runner2 = runner2->getNext();
  417.         }
  418.         delete runner1;
  419.     }
  420.     first = nullptr;
  421.     if (p.getFirst())
  422.     {
  423.         try
  424.         {
  425.             first = new cScherbakovNode(*p.getFirst());
  426.         }
  427.         catch (const bad_alloc& exc) { std::cout << exc.what(); }
  428.         cScherbakovNode* pPtr = p.getFirst();
  429.         cScherbakovNode* tPtr = first;
  430.         while (pPtr->getNext())
  431.         {
  432.             try
  433.             {
  434.                 tPtr->setNext(new cScherbakovNode(*pPtr->getNext()));
  435.             }
  436.             catch (const bad_alloc& exc) { std::cout << exc.what(); }
  437.             pPtr = pPtr->getNext();
  438.             tPtr = tPtr->getNext();
  439.         }
  440.     }
  441.     return *this;
  442. }
  443.  
  444. void cScherbakovPolynom::add(char* str)
  445. {
  446.     add(cScherbakovNode(str));
  447. }
  448.  
  449. void cScherbakovPolynom::add(int c, unsigned d)
  450. {
  451.     add(cScherbakovNode(c, d));
  452. }
  453.  
  454. void cScherbakovPolynom::add(const cScherbakovMonom& m)
  455. {
  456.     add(cScherbakovNode(m));
  457. }
  458.  
  459. void cScherbakovPolynom::add(const cScherbakovNode& n)
  460. {
  461.     if (n.getCoeff())
  462.     {
  463.         if (!first)
  464.         {
  465.             try
  466.             {
  467.                 first = new cScherbakovNode(n);
  468.             }
  469.             catch (const bad_alloc& exc) { std::cout << exc.what(); }
  470.         }
  471.         else
  472.         {
  473.             if (n.getDegree() > first->getDegree())
  474.             {
  475.                 cScherbakovNode* newFirst = nullptr;
  476.                 try
  477.                 {
  478.                     newFirst = new cScherbakovNode(n);
  479.                 }
  480.                 catch (const bad_alloc& exc) { std::cout << exc.what(); }
  481.                 newFirst->setNext(first);
  482.                 first = newFirst;
  483.             }
  484.             else if (n.getDegree() == first->getDegree())
  485.             {
  486.                 first->setCoeff(first->getCoeff() + n.getCoeff());
  487.                 if (!first->getCoeff())
  488.                 {
  489.                     cScherbakovNode* newFirst = first->getNext();
  490.                     delete first;
  491.                     first = newFirst;
  492.                 }
  493.             }
  494.             else
  495.             {
  496.                 cScherbakovNode* runner = first;
  497.                 while (runner->getNext() && runner->getNext()->getDegree() > n.getDegree()) runner = runner->getNext();
  498.                 if (!runner->getNext())
  499.                 {
  500.                     cScherbakovNode* newLast = nullptr;
  501.                     try
  502.                     {
  503.                         newLast = new cScherbakovNode(n);
  504.                     }
  505.                     catch (const bad_alloc& exc) { std::cout << exc.what(); }
  506.                     runner->setNext(newLast);
  507.                 }
  508.                 else if (n.getDegree() > runner->getNext()->getDegree())
  509.                 {
  510.                     cScherbakovNode* tmp = runner->getNext();
  511.                     cScherbakovNode* elemToAdd = nullptr;
  512.                     try
  513.                     {
  514.                         elemToAdd = new cScherbakovNode(n);
  515.                     }
  516.                     catch (const bad_alloc& exc) { std::cout << exc.what(); }
  517.                     runner->setNext(elemToAdd);
  518.                     elemToAdd->setNext(tmp);
  519.                 }
  520.                 else if (n.getDegree() == runner->getNext()->getDegree())
  521.                 {
  522.                     runner->getNext()->setCoeff(runner->getNext()->getCoeff() + n.getCoeff());
  523.                     if (!runner->getNext()->getCoeff())
  524.                     {
  525.                         cScherbakovNode* tmp = runner->getNext()->getNext();
  526.                         delete runner->getNext();
  527.                         runner->setNext(tmp);
  528.                     }
  529.                 }
  530.             }
  531.         }
  532.     }
  533. }
  534.  
  535. cScherbakovPolynom cScherbakovPolynom::operator-() const
  536. {
  537.     cScherbakovPolynom result;
  538.     cScherbakovNode* runner = first;
  539.     while (runner)
  540.     {
  541.         result.add(-*runner);
  542.         runner = runner->getNext();
  543.     }
  544.     return result;
  545. }
  546.  
  547. cScherbakovPolynom cScherbakovPolynom::operator+(const cScherbakovPolynom& sum) const
  548. {
  549.     cScherbakovPolynom result = *this;
  550.     cScherbakovNode* runner = sum.getFirst();
  551.     while (runner)
  552.     {
  553.         result.add(*runner);
  554.         runner = runner->getNext();
  555.     }
  556.     return result;
  557. }
  558.  
  559. cScherbakovPolynom cScherbakovPolynom::operator-(const cScherbakovPolynom& sub) const
  560. {
  561.     cScherbakovPolynom result = *this;
  562.     cScherbakovNode* runner = sub.getFirst();
  563.     while (runner)
  564.     {
  565.         result.add(-*runner);
  566.         runner = runner->getNext();
  567.     }
  568.     return result;
  569. }
  570.  
  571. cScherbakovPolynom cScherbakovPolynom::operator*(const cScherbakovPolynom& mul) const
  572. {
  573.     cScherbakovPolynom result;
  574.     cScherbakovNode* runnerThis = first;
  575.     cScherbakovNode* runnerMul = mul.getFirst();
  576.     while (runnerThis)
  577.     {
  578.         while (runnerMul)
  579.         {
  580.             result.add(*runnerThis * *runnerMul);
  581.             runnerMul = runnerMul->getNext();
  582.         }
  583.         runnerMul = mul.getFirst();
  584.         runnerThis = runnerThis->getNext();
  585.     }
  586.     return result;
  587. }
  588.  
  589. cScherbakovPolynom cScherbakovPolynom::operator/(const cScherbakovPolynom& div) const
  590. {
  591.     if (first->getDegree() < div.getFirst()->getDegree()) return cScherbakovPolynom();
  592.     else if (first->getDegree() == div.getFirst()->getDegree()) return cScherbakovPolynom(first->getCoeff() / div.getFirst()->getCoeff(), 0);
  593.     else
  594.     {
  595.         cScherbakovPolynom result, maincScherbakovPolynom = *this;
  596.         while (maincScherbakovPolynom.getFirst() && maincScherbakovPolynom.getFirst()->getDegree() >= div.getFirst()->getDegree())
  597.         {
  598.             cScherbakovNode n(maincScherbakovPolynom.getFirst()->getCoeff() / div.getFirst()->getCoeff(), maincScherbakovPolynom.getFirst()->getDegree() - div.getFirst()->getDegree());
  599.             if (!n.getCoeff())
  600.             {
  601.                 maincScherbakovPolynom.add(-*maincScherbakovPolynom.getFirst());
  602.                 if (!maincScherbakovPolynom.getFirst()) break;
  603.             }
  604.             else
  605.             {
  606.                 result.add(n);
  607.                 maincScherbakovPolynom = maincScherbakovPolynom - cScherbakovPolynom(n) * div;
  608.                 if (maincScherbakovPolynom.getFirst()->getDegree() == n.getDegree() + div.getFirst()->getDegree()) maincScherbakovPolynom.add(-*maincScherbakovPolynom.getFirst());
  609.             }
  610.         }
  611.         return result;
  612.     }
  613. }
  614.  
  615. cScherbakovPolynom cScherbakovPolynom::operator%(const cScherbakovPolynom& mod) const
  616. {
  617.     return *this - *this / mod * mod;
  618. }
  619.  
  620. ostream& operator<<(ostream& stream, const cScherbakovPolynom& p)
  621. {
  622.     stream << '<';
  623.     cScherbakovNode* runner = p.getFirst();
  624.     if (!runner) stream << '0';
  625.     else while (runner)
  626.     {
  627.         if (runner == p.getFirst())
  628.         {
  629.             if (!runner->getSign()) stream << '-';
  630.             stream << *runner;
  631.             if (runner->getNext()) stream << ' ';
  632.         }
  633.         else
  634.         {
  635.             stream << (runner->getSign() ? '+' : '-') << ' ' << *runner;
  636.             if (runner->getNext()) stream << ' ';
  637.         }
  638.         runner = runner->getNext();
  639.     }
  640.     return stream << '>';
  641. }
  642.  
  643. istream& operator>>(istream& stream, cScherbakovPolynom& p)
  644. {
  645.     static char buf[1000] = "";
  646.     char* b = buf, c;
  647.     while ((c = (char)stream.get()) != '>') *b++ = c;
  648.     *b = 0;
  649.     p = cScherbakovPolynom(buf);
  650.     return stream;
  651. }
  652.  
  653. cScherbakovPolynom::~cScherbakovPolynom()
  654. {
  655.     if (first)
  656.     {
  657.         cScherbakovNode* runner = first->getNext();
  658.         while (runner)
  659.         {
  660.             delete first;
  661.             first = runner;
  662.             runner = runner->getNext();
  663.         }
  664.         delete first;
  665.     }
  666. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!