#include "Calculate.h"//此處為《初涉大數(shù)運(yùn)算（上）》中頭文件

#pragma region 初始化

Calculate::LargeDecimal::LargeDecimal()
{
??this->Integer.push_back(0);
??this->Decimal.push_back(0);
??this->bIsNegative = false;
??this->lPoint = -1;
}

Calculate::LargeDecimal::LargeDecimal(int iNumber)
{
??this->Decimal.push_back(0);
??this->lPoint = -1;
??if(iNumber < 0)
??{
????this->bIsNegative = true;
????iNumber = 0 - iNumber;
??}
??else
??{
????this->bIsNegative = false;
????if(!iNumber)
????{
??????this->Integer.push_back(0);
????}
??}
??while(iNumber)
??{
????this->Integer.insert(this->Integer.begin(), iNumber % 10000);
????iNumber /= 10000;
??}
}

Calculate::LargeDecimal::LargeDecimal(long lNumber)
{
??this->Decimal.push_back(0);
??this->lPoint = -1;
??if(lNumber < 0)
??{
????this->bIsNegative = true;
????lNumber = 0 - lNumber;
??}
??else
??{
????this->bIsNegative = false;
????if(!lNumber)
????{
??????this->Integer.push_back(0);
????}
??}
??while(lNumber)
??{
????this->Integer.insert(this->Integer.begin(), (lNumber % 10000));
????lNumber /= 10000;
??}
}

Calculate::LargeDecimal::LargeDecimal(float fNumber)
{
??String ^ strNumber = fNumber.ToString();
??int iE = strNumber->IndexOf('E');
??if(iE != -1)
??{
????strNumber = strNumber->Remove(iE);
??}
??long lTemp;
??String ^ strTemp;
??if(strNumber[0] == '-')
??{
????this->bIsNegative = true;
????strNumber = strNumber->Remove(0, 1);
??}
??else
??{
????this->bIsNegative = false;
??}
??while(strNumber->Length > 1)
??{
????if(strNumber[0] == '0')
????{
??????if(strNumber[1] == '.')
??????{
????????break;
??????}
??????else
??????{
????????strNumber = strNumber->Remove(0, 1);
??????}
????}
????else
????{
??????break;
????}
??}
??this->lPoint = strNumber->IndexOf('.');
??String ^ strInteger = strNumber;
??String ^ strDecimal = strNumber;
??if(this->lPoint != -1)
??{
????strInteger = strInteger->Remove(this->lPoint);
????strDecimal = strDecimal->Remove(0, this->lPoint + 1);
??}
??while(strInteger->Length % 4)
??{
????strInteger = strInteger->Insert(0, "0");
??}
??while(strInteger->Length)
??{
????strTemp = String::Copy(strInteger);
????if(strInteger->Length == 4)
????{
??????strInteger = strInteger->Remove(0);
????}
????else
????{
??????strTemp = strTemp->Remove(4);
??????strInteger = strInteger->Remove(0, 4);
????}
????lTemp = System::Convert::ToInt32(strTemp);
????this->Integer.push_back(lTemp);
??}
??while(strDecimal->Length % 4)
??{
????strDecimal += "0";
??}
??while(strDecimal->Length)
??{
????strTemp = String::Copy(strDecimal);
????if(strDecimal->Length == 4)
????{
??????strDecimal = strDecimal->Remove(0);
????}
????else
????{
??????strTemp = strTemp->Remove(4);
??????strDecimal = strDecimal->Remove(0, 4);
????}
????lTemp = System::Convert::ToInt32(strTemp);
????this->Decimal.push_back(lTemp);
??}
}

Calculate::LargeDecimal::LargeDecimal(double dNumber)
{
??String ^ strNumber = dNumber.ToString();
??int iE = strNumber->IndexOf('E');
??if(iE != -1)
??{
????strNumber = strNumber->Remove(iE);
??}
??long lTemp;
??String ^ strTemp;
??if(strNumber[0] == '-')
??{
????this->bIsNegative = true;
????strNumber = strNumber->Remove(0, 1);
??}
??else
??{
????this->bIsNegative = false;
??}
??while(strNumber->Length > 1)
??{
????if(strNumber[0] == '0')
????{
??????if(strNumber[1] == '.')
??????{
????????break;
??????}
??????else
??????{
????????strNumber = strNumber->Remove(0, 1);
??????}
????}
????else
????{
??????break;
????}
??}
??this->lPoint = strNumber->IndexOf('.');
??String ^ strInteger = strNumber;
??String ^ strDecimal = strNumber;
??if(this->lPoint != -1)
??{
????strInteger = strInteger->Remove(this->lPoint);
????strDecimal = strDecimal->Remove(0, this->lPoint + 1);
??}
??while(strInteger->Length % 4)
??{
????strInteger = strInteger->Insert(0, "0");
??}
??while(strInteger->Length)
??{
????strTemp = String::Copy(strInteger);
????if(strInteger->Length == 4)
????{
??????strInteger = strInteger->Remove(0);
????}
????else
????{
??????strTemp = strTemp->Remove(4);
??????strInteger = strInteger->Remove(0, 4);
????}
????lTemp = System::Convert::ToInt32(strTemp);
????this->Integer.push_back(lTemp);
??}
??while(strDecimal->Length % 4)
??{
????strDecimal += "0";
??}
??while(strDecimal->Length)
??{
????strTemp = String::Copy(strDecimal);
????if(strDecimal->Length == 4)
????{
??????strDecimal = strDecimal->Remove(0);
????}
????else
????{
??????strTemp = strTemp->Remove(4);
??????strDecimal = strDecimal->Remove(0, 4);
????}
????lTemp = System::Convert::ToInt32(strTemp);
????this->Decimal.push_back(lTemp);
??}
}

Calculate::LargeDecimal::LargeDecimal(String ^ strNumber)
{
??long lTemp;
??String ^ strTemp;
??if(strNumber[0] == '-')
??{
????this->bIsNegative = true;
????strNumber = strNumber->Remove(0, 1);
??}
??else
??{
????this->bIsNegative = false;
??}
??while(strNumber->Length > 1)
??{
????if(strNumber[0] == '0')
????{
??????if(strNumber[1] == '.')
??????{
????????break;
??????}
??????else
??????{
????????strNumber = strNumber->Remove(0, 1);
??????}
????}
????else
????{
??????break;
????}
??}
??this->lPoint = strNumber->IndexOf('.');
??String ^ strInteger = strNumber;
??String ^ strDecimal = strNumber;
??if(this->lPoint != -1)
??{
????strInteger = strInteger->Remove(this->lPoint);
????strDecimal = strDecimal->Remove(0, this->lPoint + 1);
??}
??while(strInteger->Length % 4)
??{
????strInteger = strInteger->Insert(0, "0");
??}
??while(strInteger->Length)
??{
????strTemp = String::Copy(strInteger);
????if(strInteger->Length == 4)
????{
??????strInteger = strInteger->Remove(0);
????}
????else
????{
??????strTemp = strTemp->Remove(4);
??????strInteger = strInteger->Remove(0, 4);
????}
????lTemp = System::Convert::ToInt32(strTemp);
????this->Integer.push_back(lTemp);
??}
??if(this->lPoint != -1)
??{
????while(strDecimal->Length % 4)
????{
??????strDecimal += "0";
????}
????while(strDecimal->Length)
????{
??????strTemp = String::Copy(strDecimal);
??????if(strDecimal->Length == 4)
??????{
????????strDecimal = strDecimal->Remove(0);
??????}
??????else
??????{
????????strTemp = strTemp->Remove(4);
????????strDecimal = strDecimal->Remove(0, 4);
??????}
??????lTemp = System::Convert::ToInt32(strTemp);
??????this->Decimal.push_back(lTemp);
????}
??}
??else
??{
????this->Decimal.push_back(0);
??}
}

#pragma endregion

#pragma region 數(shù)學(xué)函數(shù)

Calculate::LargeDecimal Calculate::LargeDecimal::Abs()
{
??Calculate::LargeDecimal Data;
??Data = * this;
??Data.bIsNegative = false;
??return Data;
}

Calculate::LargeDecimal Calculate::LargeDecimal::Random()
{
??return Calculate::LargeDecimal(System::Random::Random().NextDouble());;
}

#pragma endregion

#pragma region 轉(zhuǎn)換類型

String ^ Calculate::LargeDecimal::ToString()
{
??String ^ strNumber = "";
??String ^ strTemp;
??Calculate::LargeDecimal Data;
??Data = * this;
??while(!Data.Integer.empty())
??{
????strTemp = Data.Integer.back().ToString();
????while(strTemp->Length < 4)
????{
??????strTemp = strTemp->Insert(0, "0");
????}
????strNumber = strNumber->Insert(0, strTemp);
????Data.Integer.pop_back();
??}
??while((strNumber->Length - 1) > 0)
??{
????if(strNumber[0] == '0')
????{
??????strNumber = strNumber->Remove(0, 1);
????}
????else
????{
??????break;
????}
??}
??if(Data.lPoint != -1)
??{
????strNumber += ".";
????while(!Data.Decimal.empty())
????{
??????strTemp = Data.Decimal.back().ToString();
??????while(strTemp->Length < 4)
??????{
????????strTemp = strTemp->Insert(0, "0");
??????}
??????strNumber = strNumber->Insert(this->lPoint + 1, strTemp);
??????Data.Decimal.pop_back();
????}
????strNumber = strNumber->TrimEnd('0');
??}
??if(bIsNegative)
??{
????strNumber = strNumber->Insert(0, "-");
??}
??return strNumber;
}

Calculate::LargeDecimal Calculate::LargeDecimal::ToInteger()
{
??Calculate::LargeDecimal Data;
??Data = * this;
??Data.Decimal.resize(1);
??Data.Decimal[0] = 0;
??Data.lPoint = -1;
??return Data;
}

Calculate::LargeDecimal Calculate::LargeDecimal::ToDecimal()
{
??Calculate::LargeDecimal Data;
??Data = * this;
??Data.Integer.resize(1);
??Data.Integer[0] = 0;
??return Data;
}

#pragma endregion

#pragma region 加法運(yùn)算

Calculate::LargeDecimal Calculate::LargeDecimal::operator +(Calculate::LargeDecimal & ldSecond) const
{
??Calculate::LargeDecimal DataLeft;
??Calculate::LargeDecimal DataRight;
??DataLeft = * this;
??DataRight = ldSecond;
??switch(DataLeft.bIsNegative)
??{
??case true:
????{
??????switch(DataRight.bIsNegative)
??????{
??????case true://--
????????{
??????????return -((- DataLeft) + (- DataRight));
??????????break;
????????}
??????case false://-+
????????{
??????????return DataRight - (- DataLeft);
??????????break;
????????}
??????};
??????break;
????}
??case false:
????{
??????switch(DataRight.bIsNegative)
??????{
??????case true://+-
????????{
??????????return DataLeft - (- DataRight);
??????????break;
????????}
??????case false://++
????????{
??????????Calculate::LargeDecimal ldResult;
??????????int iFirst, iSecond, iCarry;
??????????int iSize;
??????????int i, j;
??????????iSize = DataLeft.Decimal.size() < DataRight.Decimal.size() ? DataRight.Decimal.size() : DataLeft.Decimal.size();
??????????ldResult.Decimal.resize(iSize);
??????????iSize = DataLeft.Decimal.size() > DataRight.Decimal.size() ? DataRight.Decimal.size() : DataLeft.Decimal.size();
??????????for(i = iSize - 1, iCarry = 0; i >= 0; i --)
??????????{
????????????iFirst = (int)DataLeft.Decimal[i];
????????????iSecond = (int)DataRight.Decimal[i];
????????????iFirst = iFirst + iSecond + iCarry;
????????????ldResult.Decimal[i] = iFirst % 10000;
????????????iCarry = iFirst / 10000;
??????????}
??????????for(i = iSize; i < (int)DataLeft.Decimal.size(); i ++)
??????????{
????????????ldResult.Decimal[i] = DataLeft.Decimal[i];
??????????}
??????????for(i = iSize; i < (int)DataRight.Decimal.size(); i ++)
??????????{
????????????ldResult.Decimal[i] = DataRight.Decimal[i];
??????????}
??????????iSize = DataLeft.Integer.size() < DataRight.Integer.size() ? DataRight.Integer.size() : DataLeft.Integer.size();
??????????ldResult.Integer.resize(iSize);
??????????for(i = DataLeft.Integer.size() - 1, j = DataRight.Integer.size() - 1; i >= 0 || j >= 0;)
??????????{
????????????if(i != -1 && j != -1)
????????????{
??????????????iFirst = DataLeft.Integer[i];
??????????????iSecond = DataRight.Integer[j];
??????????????i --;
??????????????j --;
????????????}
????????????else if(i != -1)
????????????{
??????????????iFirst = DataLeft.Integer[i];
??????????????iSecond = 0;
??????????????i --;
????????????}
????????????else if(j != -1)
????????????{
??????????????iFirst = 0;
??????????????iSecond = DataRight.Integer[j];
??????????????j --;
????????????}
????????????if(i == -1 && j == -1)
????????????{
??????????????iFirst = iFirst + iSecond + iCarry;
??????????????ldResult.Integer[0] = iFirst % 10000;
??????????????iCarry = iFirst / 10000;
??????????????if(iCarry)
??????????????{
????????????????ldResult.Integer.insert(ldResult.Integer.begin(), iCarry);//最高進(jìn)位
??????????????}
????????????}
????????????else
????????????{
??????????????iFirst = iFirst + iSecond + iCarry;
??????????????ldResult.Integer[(i > j ? i : j) + 1] = iFirst % 10000;
??????????????iCarry = iFirst / 10000;
????????????}
??????????}
??????????while(ldResult.Decimal.size() > 1)//消除小數(shù)點(diǎn)最后的零
??????????{
????????????if(!ldResult.Decimal.back())
????????????{
??????????????ldResult.Decimal.pop_back();
????????????}
????????????else
????????????{
??????????????break;
????????????}
??????????}
??????????if(ldResult.Decimal.back())
??????????{
????????????ldResult.lPoint = (ldResult.Integer.size() - 1) * 4;//小數(shù)點(diǎn)基本位數(shù)為其“整數(shù)部分”（節(jié)數(shù) - 1） * 4
????????????if(ldResult.Integer[0] / 1000)//最高位節(jié)為四位數(shù)
????????????{
??????????????ldResult.lPoint += 4;
????????????}
????????????else if(ldResult.Integer[0] / 100)
????????????{
??????????????ldResult.lPoint += 3;
????????????}
????????????else if(ldResult.Integer[0] / 10)
????????????{
??????????????ldResult.lPoint += 2;
????????????}
????????????else
????????????{
??????????????ldResult.lPoint += 1;
????????????}
??????????}
??????????else
??????????{
????????????ldResult.lPoint = -1;
??????????}
??????????return ldResult;
??????????break;
????????}
??????};
??????break;
????}
??}
??return 0;
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator +(int iNumber) const
{
??return * this + Calculate::LargeDecimal(iNumber);
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator +(long lNumber) const
{
??return * this + Calculate::LargeDecimal(lNumber);
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator +(float fNumber) const
{
??return * this + Calculate::LargeDecimal(fNumber);
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator +(double dNumber) const
{
??return * this + Calculate::LargeDecimal(dNumber);
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator +(String ^ strNumber) const
{
??return * this + Calculate::LargeDecimal(strNumber);
}

#pragma endregion

#pragma region 減法運(yùn)算

Calculate::LargeDecimal Calculate::LargeDecimal::operator -(Calculate::LargeDecimal & ldSecond) const
{
??Calculate::LargeDecimal DataLeft;
??Calculate::LargeDecimal DataRight;
??DataLeft = * this;
??DataRight = ldSecond;
??switch(DataLeft.bIsNegative)
??{
??case true:
????{
??????switch(DataRight.bIsNegative)
??????{
??????case true://--
????????{
??????????return (- DataRight) - (- DataLeft);
??????????break;
????????}
??????case false://-+
????????{
??????????return - ((- DataLeft) + DataRight);
??????????break;
????????}
??????};
??????break;
????}
??case false:
????{
??????switch(DataRight.bIsNegative)
??????{
??????case true://+-
????????{
??????????return DataLeft + (- DataRight);
??????????break;
????????}
??????case false://++
????????{
??????????Calculate::LargeDecimal ldResult;
??????????if(DataLeft < DataRight)
??????????{
????????????ldResult = DataLeft;
????????????DataLeft = DataRight;
????????????DataRight = ldResult;
????????????ldResult.bIsNegative = true;
??????????}
??????????else if(DataLeft == DataRight)//兩數(shù)相等返回 0，該處 0 為 LargeDecimal::LargeDecimal(0);
??????????{
????????????return 0;
??????????}
??????????long lFirst, lSecond;
??????????int iSize;
??????????int i, j;
??????????int iFirstSize = DataLeft.Decimal.size();
??????????int iSecondSize = DataRight.Decimal.size();
??????????iSize = iFirstSize > iSecondSize ? iFirstSize : iSecondSize;
??????????ldResult.Decimal.resize(iSize);
??????????for(i = iSize - 1; i >= 0; i --)
??????????{
????????????if(i < iFirstSize && i < iSecondSize)
????????????{
??????????????lFirst = DataLeft.Decimal[i];
??????????????lSecond = DataRight.Decimal[i];
????????????}
????????????else if(i < iFirstSize)
????????????{
??????????????lFirst = DataLeft.Decimal[i];
??????????????lSecond = 0;
????????????}
????????????else if(i < iSecondSize)
????????????{
??????????????lFirst = 0;
??????????????lSecond = DataRight.Decimal[i];
????????????}
????????????if(lFirst < lSecond)
????????????{
??????????????lFirst += 10000;
??????????????if(i > 0)
??????????????{
????????????????DataLeft.Decimal[i - 1] --;
??????????????}
??????????????else
??????????????{
????????????????DataLeft.Integer[0] --;
??????????????}
????????????}
????????????lFirst = lFirst - lSecond;
????????????ldResult.Decimal[i] = lFirst;
??????????}
??????????iFirstSize = DataLeft.Integer.size();
??????????iSecondSize = DataRight.Integer.size();
??????????iSize = iFirstSize > iSecondSize ? iFirstSize : iSecondSize;
??????????ldResult.Integer.resize(iSize);
??????????for(i = iFirstSize - 1, j = iSecondSize - 1; i >= 0 || j >= 0; i --, j --)
??????????{
????????????if(i >= 0 && j >= 0)
????????????{
??????????????lFirst = DataLeft.Integer[i];
??????????????lSecond = DataRight.Integer[j];
????????????}
????????????else if(i >= 0)
????????????{
??????????????lFirst = DataLeft.Integer[i];
??????????????lSecond = 0;
????????????}
????????????else if(j >= 0)
????????????{
??????????????lFirst = 0;
??????????????lSecond = DataRight.Integer[j];
????????????}
????????????if(lFirst < lSecond)
????????????{
??????????????lFirst += 10000;
??????????????DataLeft.Integer[i - 1] --;
????????????}
????????????lFirst = lFirst - lSecond;
????????????ldResult.Integer[(i > j ? i : j)] = lFirst;
??????????}
??????????while(ldResult.Decimal.size() > 1)
??????????{
????????????if(!ldResult.Decimal.back())
????????????{
??????????????ldResult.Decimal.pop_back();
????????????}
????????????else
????????????{
??????????????break;
????????????}
??????????}
??????????while(ldResult.Integer.size() > 1)
??????????{
????????????if(!ldResult.Integer[0])
????????????{
??????????????ldResult.Integer.erase(ldResult.Integer.begin());
????????????}
????????????else
????????????{
??????????????break;
????????????}
??????????}
??????????if(ldResult.Decimal.back())
??????????{
????????????ldResult.lPoint = (ldResult.Integer.size() - 1) * 4;//小數(shù)點(diǎn)基本位數(shù)為其“整數(shù)部分”（節(jié)數(shù) - 1） * 4
????????????if(ldResult.Integer[0] / 1000)//最高位節(jié)為四位數(shù)
????????????{
??????????????ldResult.lPoint += 4;
????????????}
????????????else if(ldResult.Integer[0] / 100)
????????????{
??????????????ldResult.lPoint += 3;
????????????}
????????????else if(ldResult.Integer[0] / 10)
????????????{
??????????????ldResult.lPoint += 2;
????????????}
????????????else
????????????{
??????????????ldResult.lPoint += 1;
????????????}
??????????}
??????????else
??????????{
????????????ldResult.lPoint = -1;
??????????}
??????????return ldResult;
??????????break;
????????}
??????};
??????break;
????}
??}
??return 0;
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator -(int iNumber) const
{
??return * this - Calculate::LargeDecimal(iNumber);
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator -(long lNumber) const
{
??return * this - Calculate::LargeDecimal(lNumber);
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator -(float fNumber) const
{
??return * this - Calculate::LargeDecimal(fNumber);
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator -(double dNumber) const
{
??return * this - Calculate::LargeDecimal(dNumber);
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator -(String ^ strNumber) const
{
??return * this - Calculate::LargeDecimal(strNumber);
}

#pragma endregion

#pragma region 乘法運(yùn)算

Calculate::LargeDecimal Calculate::LargeDecimal::operator *(Calculate::LargeDecimal & ldSecond) const
{
??if(* this == 0 || ldSecond == 0)
??{
????return 0;
??}
??long i, j, k;
??long lFirst, lSecond, lResult;
??Calculate::LargeDecimal DataLeft = * this;
??Calculate::LargeDecimal DataRight = ldSecond;
??Calculate::LargeDecimal ldResult = 0;
??DataLeft = DataLeft.Abs();
??DataRight = DataRight.Abs();
??String ^ strResult = "";
??long lFirstPointer = DataLeft.Decimal.size();
??long lSecondPointer = DataRight.Decimal.size();
??if(lFirstPointer == 1 && DataLeft.Decimal[0] == 0)
??{
????lFirstPointer = 0;
??}
??if(lSecondPointer == 1 && DataRight.Decimal[0] == 0)
??{
????lSecondPointer = 0;
??}
??long lPointer = lFirstPointer + lSecondPointer;//答案的小數(shù)位數(shù)
??while(DataLeft.Decimal.size() > 1)
??{
????DataLeft.Integer.push_back(DataLeft.Decimal[0]);
????DataLeft.Decimal.erase(DataLeft.Decimal.begin());
??}
??while(DataRight.Decimal.size() > 1)
??{
????DataRight.Integer.push_back(DataRight.Decimal[0]);
????DataRight.Decimal.erase(DataRight.Decimal.begin());
??}
??if(DataLeft.Decimal[0])
??{
????DataLeft.Integer.push_back(DataLeft.Decimal[0]);
????DataLeft.Decimal.erase(DataLeft.Decimal.begin());
??}
??if(DataRight.Decimal[0])
??{
????DataRight.Integer.push_back(DataRight.Decimal[0]);
????DataRight.Decimal.erase(DataRight.Decimal.begin());
??}
??while(DataLeft.Integer.size() > 1)
??{
????if(DataLeft.Integer[0] == 0)
????{
??????DataLeft.Integer.erase(DataLeft.Integer.begin());
????}
????else
????{
??????break;
????}
??}
??while(DataRight.Integer.size() > 1)
??{
????if(DataRight.Integer[0] == 0)
????{
??????DataRight.Integer.erase(DataRight.Integer.begin());
????}
????else
????{
??????break;
????}
??}
??DataLeft.Decimal.resize(1);
??DataRight.Decimal.resize(1);
??for(i = DataLeft.Integer.size() - 1; i >= 0; i --)
??{
????lFirst = DataLeft.Integer[i];
????if(lFirst)
????{
??????for(j = DataRight.Integer.size() - 1; j >= 0; j --)
??????{
????????lSecond = DataRight.Integer[j];
????????if(lSecond)
????????{
??????????lResult = lFirst * lSecond;
????????}
????????else
????????{
??????????lResult = 0;
????????}
????????strResult = lResult.ToString();
????????for(k = DataLeft.Integer.size() - 1 - i + DataRight.Integer.size() - 1 - j; k > 0; k --)
????????{
??????????strResult += "0000";
????????}
????????ldResult += strResult;
??????}
????}
??}
??if(lPointer)
??{
????for(i = 0; i < lPointer; i ++)
????{
??????if(ldResult.Integer.size())
??????{
????????ldResult.Decimal.insert(ldResult.Decimal.begin(), ldResult.Integer.back());
????????ldResult.Integer.pop_back();
??????}
??????else
??????{
????????ldResult.Decimal.insert(ldResult.Decimal.begin(), 0);
??????}
????}
????if(!ldResult.Integer.size())
????{
??????ldResult.Integer.resize(1);
????}
????ldResult.lPoint = ldResult.ToInteger().ToString()->Length;
??}
??while(ldResult.Decimal.size() > 1)
??{
????if(ldResult.Decimal.back())
????{
??????break;
????}
????else
????{
??????ldResult.Decimal.pop_back();
????}
??}
??ldResult.bIsNegative = this->bIsNegative != ldSecond.bIsNegative;
??return ldResult;
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator *(int iNumber) const
{
??return * this * Calculate::LargeDecimal(iNumber);
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator *(long lNumber) const
{
??return * this * Calculate::LargeDecimal(lNumber);
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator *(float fNumber) const
{
??return * this * Calculate::LargeDecimal(fNumber);
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator *(double dNumber) const
{
??return * this * Calculate::LargeDecimal(dNumber);
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator *(String ^ strNumber) const
{
??return * this * Calculate::LargeDecimal(strNumber);
}

#pragma endregion

#pragma region 除法運(yùn)算

Calculate::LargeDecimal Calculate::LargeDecimal::operator /(Calculate::LargeDecimal & ldSecond) const
{
??if(ldSecond == 0)
??{
????String ^ msg = "除數(shù)不可以為 0 ";
????throw msg;
??}
??if( * this == 0)
??{
????return 0;
??}
??Calculate::LargeDecimal ldResult = 0;
??Calculate::LargeDecimal DataLeft = * this;
??Calculate::LargeDecimal DataRight = ldSecond;
??long i;
??Calculate::LargeDecimal j, k;
??long lPointer = -1;
??String ^ strResult = "";
??bool bNegativeFlag = !(this->bIsNegative == ldSecond.bIsNegative);
??while(DataRight.lPoint != -1)
??{
????if(DataLeft.ToInteger() == 0)
????{
??????DataLeft.Integer.clear();
????}
????if(DataRight.ToInteger() == 0)
????{
??????DataRight.Integer.clear();
????}
????if(DataLeft.Decimal.size())
????{
??????DataLeft.Integer.push_back(DataLeft.Decimal[0]);
??????DataLeft.Decimal.erase(DataLeft.Decimal.begin());
??????DataLeft.lPoint += 4;
????}
????else
????{
??????DataLeft.Integer.push_back(0);
??????DataLeft.lPoint = -1;
????}
????if(DataRight.Decimal.size() > 1)
????{
??????DataRight.Integer.push_back(DataRight.Decimal[0]);
??????DataRight.Decimal.erase(DataRight.Decimal.begin());
??????DataRight.lPoint += 4;
????}
????else
????{
??????DataRight.Integer.push_back(DataRight.Decimal[0]);
??????DataRight.Decimal[0] = 0;
??????DataRight.lPoint = -1;
????}
??}
??DataLeft.Decimal.resize(1);
??DataLeft.bIsNegative = false;
??DataRight.bIsNegative = false;
??Calculate::LargeDecimal RecorderLeft;
??Calculate::LargeDecimal RecorderRight;
??Calculate::LargeDecimal RecorderMiddle;
??long lTimes;
??String ^ strValueJ;
??lTimes = DataLeft.Size() + DataRight.Size() + 1;
??for(i = 0; (DataLeft != 0) && (i < lTimes); i ++)
??{
????for(j = 0; DataLeft >= DataRight; j ++)
????{
??????DataLeft -= DataRight;
????}
????strValueJ = j.ToString();
????while(strValueJ->Length < 4)
????{
??????strValueJ = "0" + strValueJ;
????}
????strResult += strValueJ;
????if(!i)
????{
??????strResult += ".";
????}
????DataLeft *= 10000;
??}
??if(bNegativeFlag)//設(shè)定正負(fù)號(hào)，同號(hào)為正，否則為負(fù)
??{
????strResult = "-" + strResult;
??}
??if(strResult[strResult->Length - 1] == '.')//最后一位為 “.” 則刪除
??{
????strResult = strResult->Remove(strResult->Length - 1);
??}
??return strResult;
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator /(int iNumber) const
{
??return * this / Calculate::LargeDecimal(iNumber);
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator /(long lNumber) const
{
??return * this / Calculate::LargeDecimal(lNumber);
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator /(float fNumber) const
{
??return * this / Calculate::LargeDecimal(fNumber);
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator /(double dNumber) const
{
??return * this / Calculate::LargeDecimal(dNumber);
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator /(String ^ strNumber) const
{
??return * this / Calculate::LargeDecimal(strNumber);
}

#pragma endregion

#pragma region 取模計(jì)算

Calculate::LargeDecimal Calculate::LargeDecimal::operator %(Calculate::LargeDecimal & ldSecond) const
{
??if(ldSecond == 0)
??{
????return -1;
??}
??if( * this == 0)
??{
????return 0;
??}
??Calculate::LargeDecimal DataLeft = * this;
??Calculate::LargeDecimal DataRight = ldSecond;
??Calculate::LargeDecimal ldResult = DataLeft;
??if(DataLeft.ToDecimal() != 0 || DataRight.ToDecimal() != 0)
??{
????return -1;
??}
??while(DataLeft >= DataRight)
??{
????DataLeft -= DataRight;
??}
??return DataLeft;
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator %(int iNumber) const
{
??return * this % Calculate::LargeDecimal(iNumber);
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator %(long lNumber) const
{
??return * this % Calculate::LargeDecimal(lNumber);
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator %(float fNumber) const
{
??return * this % Calculate::LargeDecimal(fNumber);
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator %(double dNumber) const
{
??return * this % Calculate::LargeDecimal(dNumber);
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator %(String ^ strNumber) const
{
??return * this % Calculate::LargeDecimal(strNumber);
}

#pragma endregion

#pragma region 賦值加

Calculate::LargeDecimal Calculate::LargeDecimal::operator +=(Calculate::LargeDecimal & ldSecond)
{
??* this = * this + ldSecond;
??return * this;
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator +=(int iNumber)
{
??* this = * this + Calculate::LargeDecimal(iNumber);
??return * this;
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator +=(long lNumber)
{
??* this = * this + Calculate::LargeDecimal(lNumber);
??return * this;
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator +=(float fNumber)
{
??* this = * this + Calculate::LargeDecimal(fNumber);
??return * this;
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator +=(double dNumber)
{
??* this = * this + Calculate::LargeDecimal(dNumber);
??return * this;
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator +=(String ^ strNumber)
{
??* this = * this + Calculate::LargeDecimal(strNumber);
??return * this;
}

#pragma endregion

#pragma region 賦值減

Calculate::LargeDecimal Calculate::LargeDecimal::operator -=(Calculate::LargeDecimal & ldSecond)
{
??* this = * this - ldSecond;
??return * this;
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator -=(int iNumber)
{
??* this = * this - Calculate::LargeDecimal(iNumber);
??return * this;
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator -=(long lNumber)
{
??* this = * this - Calculate::LargeDecimal(lNumber);
??return * this;
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator -=(float fNumber)
{
??* this = * this - Calculate::LargeDecimal(fNumber);
??return * this;
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator -=(double dNumber)
{
??* this = * this - Calculate::LargeDecimal(dNumber);
??return * this;
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator -=(String ^ strNumber)
{
??* this = * this - Calculate::LargeDecimal(strNumber);
??return * this;
}

#pragma endregion

#pragma region 賦值乘

Calculate::LargeDecimal Calculate::LargeDecimal::operator *=(Calculate::LargeDecimal & ldSecond)
{
??* this = * this * ldSecond;
??return * this;
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator *=(int iNumber)
{
??* this = * this * Calculate::LargeDecimal(iNumber);
??return * this;
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator *=(long lNumber)
{
??* this = * this * Calculate::LargeDecimal(lNumber);
??return * this;
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator *=(float fNumber)
{
??* this = * this * Calculate::LargeDecimal(fNumber);
??return * this;
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator *=(double dNumber)
{
??* this = * this * Calculate::LargeDecimal(dNumber);
??return * this;
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator *=(String ^ strNumber)
{
??* this = * this * Calculate::LargeDecimal(strNumber);
??return * this;
}

#pragma endregion

#pragma region 賦值除

Calculate::LargeDecimal Calculate::LargeDecimal::operator /=(Calculate::LargeDecimal & ldSecond)
{
??* this = * this / ldSecond;
??return * this;
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator /=(int iNumber)
{
??* this = * this / Calculate::LargeDecimal(iNumber);
??return * this;
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator /=(long lNumber)
{
??* this = * this / Calculate::LargeDecimal(lNumber);
??return * this;
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator /=(float fNumber)
{
??* this = * this / Calculate::LargeDecimal(fNumber);
??return * this;
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator /=(double dNumber)
{
??* this = * this / Calculate::LargeDecimal(dNumber);
??return * this;
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator /=(String ^ strNumber)
{
??* this = * this / Calculate::LargeDecimal(strNumber);
??return * this;
}

#pragma endregion

#pragma region 賦值模

Calculate::LargeDecimal Calculate::LargeDecimal::operator %=(Calculate::LargeDecimal & ldSecond)
{
??* this = * this % ldSecond;
??return * this;
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator %=(int iNumber)
{
??* this = * this % Calculate::LargeDecimal(iNumber);
??return * this;
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator %=(long lNumber)
{
??* this = * this % Calculate::LargeDecimal(lNumber);
??return * this;
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator %=(float fNumber)
{
??* this = * this % Calculate::LargeDecimal(fNumber);
??return * this;
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator %=(double dNumber)
{
??* this = * this % Calculate::LargeDecimal(dNumber);
??return * this;
}

Calculate::LargeDecimal Calculate::LargeDecimal::operator %=(String ^ strNumber)
{
??* this = * this % Calculate::LargeDecimal(strNumber);
??return * this;
}

#pragma endregion

#pragma region 邏輯大于

bool Calculate::LargeDecimal::operator >(Calculate::LargeDecimal & ldSecond) const
{
??bool bFirstNegative = !this->bIsNegative;
??bool bSecondNegative = !ldSecond.bIsNegative;
??int i;
??if(bFirstNegative > bSecondNegative)
??{
????return true;
??}
??else if(bFirstNegative < bSecondNegative)
??{
????return false;
??}
??int iFirstSize = this->Integer.size();
??int iSecondSize = ldSecond.Integer.size();
??if(iFirstSize > iSecondSize)
??{
????if(bFirstNegative)
????{
??????return true;
????}
????else
????{
??????return false;
????}
??}
??else if(iFirstSize < iSecondSize)
??{
????if(bFirstNegative)
????{
??????return false;
????}
????else
????{
??????return true;
????}
??}
??for(i = 0; i < iFirstSize && i < iSecondSize; i ++)
??{
????if(this->Integer[i] > ldSecond.Integer[i])
????{
??????if(bFirstNegative)
??????{
????????return true;
??????}
??????else
??????{
????????return false;
??????}
????}
????else if(this->Integer[i] < ldSecond.Integer[i])
????{
??????if(bFirstNegative)
??????{
????????return false;
??????}
??????else
??????{
????????return true;
??????}
????}
??}
??iFirstSize = this->Decimal.size();
??iSecondSize = ldSecond.Decimal.size();
??for(i = 0; i < iFirstSize && i < iSecondSize; i ++)
??{
????if(this->Decimal[i] > ldSecond.Decimal[i])
????{
??????if(bFirstNegative)
??????{
????????return true;
??????}
??????else
??????{
????????return false;
??????}
????}
????else if(this->Decimal[i] < ldSecond.Decimal[i])
????{
??????if(bFirstNegative)
??????{
????????return false;
??????}
??????else
??????{
????????return true;
??????}
????}
??}
??if(iFirstSize > iSecondSize)
??{
????return true;
??}
??else
??{
????return false;
??}
}

bool Calculate::LargeDecimal::operator >(int iNumber) const
{
??return (* this) > Calculate::LargeDecimal(iNumber);
}

bool Calculate::LargeDecimal::operator >(long lNumber) const
{
??return (* this) > Calculate::LargeDecimal(lNumber);
}

bool Calculate::LargeDecimal::operator >(float fNumber) const
{
??return (* this) > Calculate::LargeDecimal(fNumber);
}

bool Calculate::LargeDecimal::operator >(double dNumber) const
{
??return (* this) > Calculate::LargeDecimal(dNumber);
}

bool Calculate::LargeDecimal::operator >(String ^ strNumber) const
{
??return (* this) > Calculate::LargeDecimal(strNumber);
}

#pragma endregion

#pragma region 邏輯小于

bool Calculate::LargeDecimal::operator <(Calculate::LargeDecimal & ldSecond) const
{
??bool bFirstNegative = !this->bIsNegative;
??bool bSecondNegative = !ldSecond.bIsNegative;
??int i;
??if(bFirstNegative < bSecondNegative)
??{
????return true;
??}
??else if(bFirstNegative > bSecondNegative)
??{
????return false;
??}
??int iFirstSize = this->Integer.size();
??int iSecondSize = ldSecond.Integer.size();
??if(iFirstSize < iSecondSize)
??{
????if(bFirstNegative)
????{
??????return true;
????}
????else
????{
??????return false;
????}
??}
??else if(iFirstSize > iSecondSize)
??{
????if(bFirstNegative)
????{
??????return false;
????}
????else
????{
??????return true;
????}
??}
??for(i = 0; i < iFirstSize && i < iSecondSize; i ++)
??{
????if(this->Integer[i] < ldSecond.Integer[i])
????{
??????if(bFirstNegative)
??????{
????????return true;
??????}
??????else
??????{
????????return false;
??????}
????}
????else if(this->Integer[i] > ldSecond.Integer[i])
????{
??????if(bFirstNegative)
??????{
????????return false;
??????}
??????else
??????{
????????return true;
??????}
????}
??}
??iFirstSize = this->Decimal.size();
??iSecondSize = ldSecond.Decimal.size();
??for(i = 0; i < iFirstSize && i < iSecondSize; i ++)
??{
????if(this->Decimal[i] < ldSecond.Decimal[i])
????{
??????if(bFirstNegative)
??????{
????????return true;
??????}
??????else
??????{
????????return false;
??????}
????}
????else if(this->Decimal[i] > ldSecond.Decimal[i])
????{
??????if(bFirstNegative)
??????{
????????return false;
??????}
??????else
??????{
????????return true;
??????}
????}
??}
??if(iFirstSize < iSecondSize)
??{
????return true;
??}
??else
??{
????return false;
??}
}

bool Calculate::LargeDecimal::operator <(int iNumber) const
{
??return (* this) < Calculate::LargeDecimal(iNumber);
}

bool Calculate::LargeDecimal::operator <(long lNumber) const
{
??return (* this) < Calculate::LargeDecimal(lNumber);
}

bool Calculate::LargeDecimal::operator <(float fNumber) const
{
??return (* this) < Calculate::LargeDecimal(fNumber);
}

bool Calculate::LargeDecimal::operator <(double dNumber) const
{
??return (* this) < Calculate::LargeDecimal(dNumber);
}

bool Calculate::LargeDecimal::operator <(String ^ strNumber) const
{
??return (* this) < Calculate::LargeDecimal(strNumber);
}

#pragma endregion

#pragma region 邏輯大于或等于

bool Calculate::LargeDecimal::operator >=(Calculate::LargeDecimal & ldSecond) const
{
??return (* this) > ldSecond || (* this) == ldSecond;
}

bool Calculate::LargeDecimal::operator >=(int iNumber) const
{
??return (* this) >= Calculate::LargeDecimal(iNumber);
}

bool Calculate::LargeDecimal::operator >=(long lNumber) const
{
??return (* this) >= Calculate::LargeDecimal(lNumber);
}

bool Calculate::LargeDecimal::operator >=(float fNumber) const
{
??return (* this) >= Calculate::LargeDecimal(fNumber);
}

bool Calculate::LargeDecimal::operator >=(double dNumber) const
{
??return (* this) >= Calculate::LargeDecimal(dNumber);
}

bool Calculate::LargeDecimal::operator >=(String ^ strNumber) const
{
??return (* this) >= Calculate::LargeDecimal(strNumber);
}

#pragma endregion

#pragma region 邏輯小于或等于

bool Calculate::LargeDecimal::operator <=(Calculate::LargeDecimal & ldSecond) const
{
??return (* this) < ldSecond || (* this) == ldSecond;
}

bool Calculate::LargeDecimal::operator <=(int iNumber) const
{
??return (* this) <= Calculate::LargeDecimal(iNumber);
}

bool Calculate::LargeDecimal::operator <=(long lNumber) const
{
??return (* this) <= Calculate::LargeDecimal(lNumber);
}

bool Calculate::LargeDecimal::operator <=(float fNumber) const
{
??return (* this) <= Calculate::LargeDecimal(fNumber);
}

bool Calculate::LargeDecimal::operator <=(double dNumber) const
{
??return (* this) <= Calculate::LargeDecimal(dNumber);
}

bool Calculate::LargeDecimal::operator <=(String ^ strNumber) const
{
??return (* this) <= Calculate::LargeDecimal(strNumber);
}
#pragma endregion

#pragma region 邏輯等于

bool Calculate::LargeDecimal::operator ==(Calculate::LargeDecimal & ldSecond) const
{
??bool bFirstNegative = !this->bIsNegative;
??bool bSecondNegative = !ldSecond.bIsNegative;
??int i;
??if(bFirstNegative != bSecondNegative)
??{
????return false;
??}
??int iFirstSize = this->Integer.size();
??int iSecondSize = ldSecond.Integer.size();
??if(iFirstSize != iSecondSize)
??{
????return false;
??}
??for(i = 0; i < iFirstSize; i ++)
??{
????if(this->Integer[i] != ldSecond.Integer[i])
????{
??????return false;
????}
??}
??iFirstSize = this->Decimal.size();
??iSecondSize = ldSecond.Decimal.size();
??if(iFirstSize != iSecondSize)
??{
????return false;
??}
??for(i = 0; i < iFirstSize; i ++)
??{
????if(this->Decimal[i] != ldSecond.Decimal[i])
????{
??????return false;
????}
??}
??return true;
}

bool Calculate::LargeDecimal::operator ==(int iNumber) const
{
??int k = 0;
??if(this->lPoint != -1)
??{
????return false;
??}
??if(this->bIsNegative != (iNumber < 0 ? true : false))
??{
????return false;
??}
??do
??{
????if(this->Integer[this->Integer.size() - k - 1] != iNumber % (long)Math::Pow(10, k))
????{
??????return false;
????}
????k ++;
??}while(iNumber);
??if(this->Integer.size() != 1)
??{
????return false;
??}
??return true;
}

bool Calculate::LargeDecimal::operator ==(long lNumber) const
{
??int k = 0;
??if(this->lPoint != -1)
??{
????return false;
??}
??if(this->bIsNegative != (lNumber < 0 ? true : false))
??{
????return false;
??}
??do
??{
????if(this->Integer[this->Integer.size() - k - 1] != lNumber % (long)Math::Pow(10, k))
????{
??????return false;
????}
????k ++;
??}while(lNumber);
??if(this->Integer.size() != 1)
??{
????return false;
??}
??return true;
}

bool Calculate::LargeDecimal::operator ==(float fNumber) const
{
??return (* this) == Calculate::LargeDecimal(fNumber);
}

bool Calculate::LargeDecimal::operator ==(double dNumber) const
{
??return (* this) == Calculate::LargeDecimal(dNumber);
}

bool Calculate::LargeDecimal::operator ==(String ^ strNumber) const
{
??return (* this) == Calculate::LargeDecimal(strNumber);
}

#pragma endregion

#pragma region 邏輯不等于

bool Calculate::LargeDecimal::operator !=(Calculate::LargeDecimal & ldSecond) const
{
??return !(* this == ldSecond);
}

bool Calculate::LargeDecimal::operator !=(int iNumber) const
{
??return !(* this == iNumber);
}

bool Calculate::LargeDecimal::operator !=(long lNumber) const
{
??return !(* this == lNumber);
}

bool Calculate::LargeDecimal::operator !=(float fNumber) const
{
??return (* this) != Calculate::LargeDecimal(fNumber);
}

bool Calculate::LargeDecimal::operator !=(double dNumber) const
{
??return (* this) != Calculate::LargeDecimal(dNumber);
}

bool Calculate::LargeDecimal::operator !=(String ^ strNumber) const
{
??return (* this) != Calculate::LargeDecimal(strNumber);
}

#pragma endregion

#pragma region 自加運(yùn)算符

// 后置
Calculate::LargeDecimal Calculate::LargeDecimal::operator ++(int)
{
??Calculate::LargeDecimal Data = * this;
??* this = * this + 1;
??return Data;
}

// 前置
Calculate::LargeDecimal Calculate::LargeDecimal::operator ++()
{
??* this = * this + 1;
??return * this;
}

#pragma endregion

#pragma region 自減運(yùn)算符

// 前置
Calculate::LargeDecimal Calculate::LargeDecimal::operator --(int)
{
??Calculate::LargeDecimal Data = * this;
??* this = * this - 1;
??return Data;
}

// 后置
Calculate::LargeDecimal Calculate::LargeDecimal::operator --()
{
??* this = * this - 1;
??return * this;
}

#pragma endregion

#pragma region 負(fù)號(hào)運(yùn)算符

Calculate::LargeDecimal Calculate::LargeDecimal::operator -() const
{
??if(* this == 0)
??{
????return 0;
??}
??Calculate::LargeDecimal Data;
??Data = * this;
??Data.bIsNegative = !this->bIsNegative;//負(fù)號(hào)取反
??return Data;
}

#pragma endregion

#pragma region 屬性函數(shù)

std::vector<long>::size_type Calculate::LargeDecimal::Size()
{
??return this->Integer.size() + this->Decimal.size();
}

#pragma endregion

轉(zhuǎn)載于:https://blog.51cto.com/starry/146250

超強(qiáng)干貨來(lái)襲 云風(fēng)專訪：近40年碼齡，通宵達(dá)旦的技術(shù)人生

總結(jié)

以上是生活随笔為你收集整理的初涉大数运算（下）的全部?jī)?nèi)容，希望文章能夠幫你解決所遇到的問(wèn)題。

如果覺(jué)得生活随笔網(wǎng)站內(nèi)容還不錯(cuò)，歡迎將生活随笔推薦給好友。