これは、大規模な整数C ++用にはお勧めできませんなければならないが、PYおよびJavaサポートがはるかに優れたC ++の言葉です。
大きな整数型（負でありません）
書式#include <iostreamの>
書式#include <ベクトル>
書式#include <文字列>
名前空間stdを使用。
構造体のBigInteger {
静的のconst int型BASE = 100000000;
静的のconst int型WIDTH = 8;
ベクトル<整数>秒;
BigIntegerの（長い長いNUM = 0）{*この= 0} //コンストラクタ
BigIntegerの演算子=（長い長いNUM）{
s.clear（）;
行う{
s.push_back（NUM％の塩基）。
/ =塩基;
}一方（NUM> 0）。
*これを返します。
}
BigIntegerの演算子=（定数ストリング＆STR）{
s.clear（）;
INT Xにおいてlen =（str.length（） - 1）/ WIDTH + 1。
以下のために（INT i = 0; iがLEN <; iは++）{
int型エンド= s.length（） - 私はWIDTH *;
int型= MAX（0、エンドWIDTH）を開始。
sscanf（str.substr（開始、終了）.c_str（）、 "％のD"、＆x）は、
s.push_back（X）。
}
*これを返します。
}
BigIntegerの演算子+（CONSTのBigInteger＆B）のconst {
BigInteger C;
csclear（）;
私はint型、G。
int型のx;
{（I = 0、G = 0 ;; iは++）のために
IF（G == 0 && I> = s.size（）&& I> = bssize（））{//何も伝送しない、2つの例は、完全のBigIntegerを横断してきました
ブレーク;
X = G。
（i）は（s.sizeを<）場合
X + = S [i]は、
（i）は（bssizeを<）場合
X + = BS [I]。
cspush_back（X％の塩基）。
G = X / BASE。
}
Cを返します。
}
BigIntegerのoperater + =（CONSTのBigInteger＆B）{
*この= *この+ B; *これを返します。
}
BigIntegerの演算子 - （CONSTのBigInteger＆B）CONST
{
BigInteger C;
csclear（）;
INT MAX =のstd :: MAX（s.size（）、bssize（））;
（int型I = 0、G = 0 ;;私は++）のために
{
IF（G == 0 && I> = MAX）
ブレーク;
INT X = G。
（i）は（s.sizeを<）場合
X + = S [i]は、
（i）は（bssizeを<）場合
X- = BS [I]。
もし（I == MAX-1）
cspush_back（X％の塩基）。
他
cspush_back（ABS（X％の塩基））。
G = X / BASE。
}
Cを返します。
}
BigIntegerの演算子 - =（CONSTのBigInteger＆B）
{
*これは*この-Bを=。
*これを返します。
}
BigIntegerの演算子*（のconstのBigInteger＆B）
{
std ::にstringstreamのSS。
ための式（I = s.size（）がINT - 1; I> = 0; i--）
SS << S [i]は、
std ::文字列オペランド1 = ss.str（）;
ss.str（ ""）;
ための式（I = bssize（）がINT - 1; I> = 0; i--）
SS << BS [I]。
std ::文字列オペランド2 = ss.str（）;
std ::ベクトル<整数> C、D、一時;
ための式（I = operand1.length（）がINT - 1; I> = 0; i--）
c.push_back（オペランド1 [I] - '0'）。
ための式（I = operand2.length（）がINT - 1; I> = 0; i--）
d.push_back（オペランド2 [I] - '0'）。
INT MAX =のstd :: MAX（c.size（）、d.size（））;
以下のために（; iは<MAX * 2 + 1; iは0 int型I ++）
temp.push_back（0）。
以下のために（int型私= 0; i）は（c.sizeを<;私は++します）
（J ++ int型J = 0; jの<d.size（））について
TEMP [I + J] + = C [I] * D [J]。
以下のために（iは++; iは2 * MAX + 1 <I = 0 INT）
IF（TEMP [I]> 9）
{
TEMP [I + 1] + = TEMP [I] / 10。
TEMP [I]％= 10。
}
INT、M = 2 * MAX。
一方、（TEMP [M] == 0）
M--;
BigIntegerの他;
another.s.clear（）;
INT LEN =（M-1）/ WIDTH + 1。
以下のために（int型私= 0;私がlen <;私は++）
another.s.push_back（0）。
以下のために（int型私= 0;私がlen <;私は++）
{
INT X = 1。
INTのK = 0。
INT端= STD ::分（M + 1、（I + 1）* WIDTH）。
int型開始=私はWIDTHを*;
以下のための（int型J =開始; J <終了; J ++）
{
K + = X * TEMP [J]。
X * = 10。
}
another.s [I] = K。
}
別のものを返します。
}
BigIntegerの演算子* =（CONSTのBigInteger＆B）
{
*この= *この* Bと、
*これを返します。
}
//が自分の部門を書き、あなたはintと同じ効果を得ることができます
BigIntegerのオペレータ/（CONSTのBigInteger＆B）
{
std ::文字列オペランド1、オペランド2、結果;
std ::にstringstreamのSS。
ための式（I = s.size（）がINT - 1; I> = 0; i--）
SS << S [i]は、
オペランド1 = ss.str（）。
ss.str（ ""）;
ための式（I = bssize（）がINT - 1; I> = 0; i--）
SS << BS [I]。
オペランド2 = ss.str（）。
int型LEN1、LEN2。
LEN1 = operand1.length（）。
LEN2 = operand2.length（）。
IF（LEN1 <LEN2）//オペランドが2つの未満のオペランドである場合、0を返します
0を返します。
過負荷であれば（*この== B）//二つの数が等しい場合は、1を返し、以下の本明細書中で使用される、「==」演算子
1を返します。
std ::ベクトル<整数> C、D;
以下のために（int型私= 0;私<LEN1、私は++）
{
c.push_back（オペランド1 [I] - '0'）。
もし（I <LEN2）
d.push_back（オペランド2 [I] - '0'）。
他
d.push_back（0）。
}
int型の時間= LEN1-LEN2。
int型のlen = LEN1。
int型K、L = 0。
以下のために（;私は<=時間; I = 0 int型私は++）
{
[OK]をint型= 1;
K = 0。
行う{
IF（C [L] == 0）
{
L ++;
OK = 0;
len1--;
}
IF（LEN == LEN1）
{
int型J = 0;
しばらく（J <LEN2）
{
（C [iがjは+]> D [J]）//それが最初の大きなオペランド1>オペランド2を表す場合
{
OK = 1;
ブレーク;
}
他（C [iがjは+] <D [J]）//オペランド1を表すことが小さい最初の<オペランド2なら
{
OK = 0;
ブレーク;
}
J ++;
}
}
（OK）の場合
{
以下のための（int型J = 0; jの<LENあり、j ++）
{
C [J + 1] - = D [J]。
（C [j個の+ i]が<0）であれば
{
C [J + I-1] - 。
C [J + I] + = 10。
}
}
K ++;
}
}一方、（OK）。
just--;
結果+ = K + '0'。
}
BigInteger温度;
温度=結果;
温度を返します。
}
BigIntegerの演算子/ =（CONSTのBigInteger＆B）
{
*この= *この/ B;
*これを返します。
}
//以下のオーバーロードされたメソッドは、トップ4の書き込み操作のすべては、もはや導入されていません
BigIntegerの演算子％（CONSTのBigInteger＆B）
{
BigInteger C;
C = *この - （*本/ B）* B。
Cを返します。
}
BigIntegerの演算子％=（CONSTのBigInteger＆B）
{
*この= *この％のB;
*これを返します。
}
ブール演算子<（CONSTのBigInteger＆B）CONST
{
もし（s.size（）！= bssize（））
s.size（）<bssize（）を返します。
ための式（I = s.size（）がINT - 1; I> = 0; i--）
もし（S [i]は！= BS [I]）
リターンS [I] <BS [I]。
falseを返す; //等しいです
}
ブール演算子>（CONSTのBigInteger＆B）CONST
{
B <*これを返します。
}
ブール演算子<=（CONSTのBigInteger＆B）CONST
{
戻る（B <*この）！;
}
ブール演算子> =（CONSTのBigInteger＆B）CONST
{
！返す（*この<b）は、
}
ブール演算子！=（constのBigIntegerを＆B）のconst
{
*この<B || *この> bを返します。
}
ブール演算子==（CONSTのBigInteger＆B）CONST
{
戻る（*この<（B！B）&& *この）！>。
}
友達のstd :: ostreamに＆演算子<<（うちのstd :: ostreamに＆、constのBigIntegerの＆X）
{
アウト<< xsback（）;
ための式（I = xssize（）がINT - 2; I> = 0; i--）
{
チャーBUF [20]。
sprintf（BUF、 "％08D"、XS [I]）。
（INT J = 0; J <strlenを（BUF）; J ++）のために
アウト<< BUF [J]。
}
アウト返します。
}
友達のstd ::はistream＆演算子>>（BigIntegerの＆X、中のstd ::はistream＆）
{
std ::文字列s。
（もし！（）■>>中）
で返します。
X = Sであり;
で返します。
}
}。
IStream＆演算子>>（のIStream＆に、BigIntegerの＆X）{
文字列s;
（もし！（中>> x））がリターンで。
X = Sであり;
で返します。
}
ostream＆演算子<<（アウトのostream＆、CONSTのBigInteger＆X）{
アウト<< xsback（）; //最高レベルの8個未満の予防治療
私はint型。
以下のための（I = xssize（） - 2; I> = 0; I - ）{
チャーBUF [20]。
sprintf（BUF、 "％08D"、XS [I]）; //未満8 0を構成しています
（INT J = 0; J <strlenを（BUF）; J ++）のために
アウト<< BUF [J]。
}
アウト返します。
}
説明：静的のconst int型BASE = 100000000;この定数は、静的メンバ変数として知られているこのタイプに属するタイプのBigInteger、BigIntegerの構造変数に属していません。BigIntegerの:: BASEで、メンバ関数のBigIntegerではなく、他の場所で直接使用することができます