HugeInt.h:

#ifndef HUGEINT_H
#define HUGEINT_H

#include <iostream>

using std::ostream;

class HugeInt {
	friend ostream &operator << ( ostream &, const HugeInt & );

public:
	HugeInt( long = 0 );
	HugeInt( constchar * );

	HugeInt operator + ( const HugeInt & );
	HugeInt operator + ( int );
	HugeInt operator + ( constchar * );

	HugeInt operator * ( int );
	HugeInt operator * ( const HugeInt & );

private:
	short integer[ 30 ];

};

#endif

HugeInt.cpp:

#include <cctype>
#include <cstring>

#include "hugeint.h"

HugeInt::HugeInt( longvalue )
{
	for ( int i = 0; i <= 29; i++ )
		integer[ i ] = 0;

	for ( int j = 29; value != 0 && j >= 0; j-- ){
		integer[ j ] = value % 10;
		value /= 10;

	}

}

HugeInt::HugeInt( constchar *string )
{
	for ( int i = 0; i <= 29; i++ )
		integer[ i ] = 0;

	int length = strlen( string );

	for ( int j = 30 - length, k = 0; j <= 29; j++, k++ )

		if ( isdigit( string[ k ] ) )
			integer[ j ] = string[ k ] - '0';

}

HugeInt HugeInt::operator + ( const HugeInt &op2 )
{
	HugeInt temp;
	int carry = 0;

	for ( int i = 29; i >= 0; i-- ){
		temp.integer[ i ] = integer[ i ] + op2.integer[ i ] + carry;

		if ( temp.integer[ i ] > 9 ) {
			temp.integer[ i ] %= 10;
			carry = 1;

		}

		else
			carry = 0;

	}

	return temp;

}

HugeInt HugeInt::operator + ( int op2 )
{
	return *this + HugeInt( op2 );

}

HugeInt HugeInt::operator + ( constchar *op2 )
{
	return *this + HugeInt( op2 );

}

HugeInt HugeInt::operator * ( const HugeInt &mul )
{
	HugeInt temp;
	HugeInt tempT;
	HugeInt tempN;
	int carry = 0;
	int n = 0;

	for ( int i = 29; i >= 0; i-- ){
		
		for ( int t = 0; t <= 29; t++ ){
			tempT.integer[ t ] = 0;
			tempN.integer[ t ] = 0;

		}

		for ( int j = 29; j >= 0; j-- ){
			tempT.integer[ j ] = integer[ j ] * mul.integer[ i ] + carry;

			if ( tempT.integer[ j ] > 9 ){
				carry = tempT.integer[ j ] / 10;
				tempT.integer[ j ] %= 10;				

			}

 			else
				carry = 0;

		}
		
		for ( int y = 29; y >= 0; y-- )
			tempN.integer[ y - n ] = tempT.integer[ y ];

		++n;

		temp = temp + tempN;

	}

	return temp;

}

HugeInt HugeInt::operator * ( int mul )
{
	return *this * HugeInt( mul );

}

ostream &operator << ( ostream &output, const HugeInt &num )
{
	int i;

	for ( i = 0; ( num.integer[ i ] == 0 ) && ( i <= 29 ); i++ )
		;

	if ( i == 30 )
		output << 0;
	elsefor ( ; i <= 29; i++ )
			output << num.integer[ i ];

	return output;

}

main.cpp:

#include <iostream>

using std::cout;
using std::endl;

#include "hugeint1.h"

int main()
{
	HugeInt n1( 7654321 );
	HugeInt n2( 7891234 );
	HugeInt n3( "9999999999999999999999999" );
	HugeInt n4( "1" );
	HugeInt n5;
	HugeInt n6( 1234 );
	HugeInt n7( 3478 );

	cout << "n1 is " << n1 << "\nn2 is " << n2
		 << "\nn3 is " << n3 << "\nn4 is " << n4
		 << "\nn5 is " << n5 << "\nn6 is " << n6
		 << "\nn7 is " << n7 << "\n\n";

	n5 = n1 + n2;
	cout << n1 << " + " << n2 << " = " << n5 << "\n\n";

	cout << n3 << " + " << n4 << "\n= " << ( n3 + n4 )
		 << "\n\n";

	n5 = n1 + 9;
	cout << n1 << " + " << 9 << " = " << n5 << "\n\n";

	n5 = n2 + "10000";
	cout << n2 << " + " << "10000" << " = " << n5 << endl;

	n5 = n7 * n6;
	cout << n7 << " * " << n6 << " = " << n5 << endl;

	return 0;

}

输出结果为：

HugeInt HugeInt::operator * ( const HugeInt &mul )
{
	HugeInt temp;
	HugeInt tempT;
	HugeInt tempN;
	int carry = 0;
	int n = 0;

	for ( int i = 29; i >= 0; i-- ){
		
		for ( int t = 0; t <= 29; t++ ){
			tempT.integer[ t ] = 0;
			tempN.integer[ t ] = 0;

		}

		for ( int j = 29; j >= 0; j-- ){
			tempT.integer[ j ] = integer[ j ] * mul.integer[ i ] + carry;

			if ( tempT.integer[ j ] > 9 ){
				carry = tempT.integer[ j ] / 10;
				tempT.integer[ j ] %= 10;				

			}

 			else
				carry = 0;

		}
		
		for ( int y = 29; y >= 0; y-- )            // 移位处理
			tempN.integer[ y - n ] = tempT.integer[ y ];

		++n;

		temp = temp + tempN;

	}

	return temp;

}

       考虑到乘法运算，比如12 * 34，那么4先和12做乘法，然后3和12做乘法，之后两数相加得出结果，但是需要注意的是：3与12的乘积要左移一位后再与4和12的乘积做加法。依此类推，推之更大的数。

       主要是这个移位处理，费了我好多时间，终于搞定了~

typedef

typedef type-declaration synonym ;

The typedef keyword defines a synonym for the specified type-declaration. The identifier in the type-declaration becomes another name for the type, instead of naming an instance of the type. You cannot use the typedef specifier inside a function definition.

A typedef declaration introduces a name that, within its scope, becomes a synonym for the type given by the decl-specifiers portion of the declaration. In contrast to the class, struct, union, and enum declarations, typedef declarations do not introduce new types — they introduce new names for existing types.

Example

//  Example of the typedef keyword
typedef unsigned  long   ulong ;

ulong  ul;      //  Equivalent to "unsigned long ul;"

typedef  struct  mystructtag
{
    int    i;
    float  f;
    char   c;
}  mystruct;

mystruct ms;    //  Equivalent to "struct mystructtag ms;"

typedef  int  ( * funcptr)();   //  funcptr is synonym for "pointer
                            //     to function returning int"

funcptr table[ 10 ];    //  Equivalent to "int (*table[10])();"

1.在你学习C++的过程中,你首先需要扎实的实践一本C++基础教程,这个教程不在深而在全.使你能够全览之.最好结合基本数据结构来练习.不要整天Hello World~~Hello MM的.

2.再下来你需要《(More)Effective C++》,它使你可以对C++也多了份思考,也了解到一些技巧和误区,不过,你需要同步实践,不然可能一时你并不能真正掌握这些技巧、避开误区.

3.提高,你需要：(下面的书可能已经讲烂了:))

  《Design Pattern》 ：个人感觉,设计模式虽说是一种思维方式,具体实现上,只是
                        对OOP语言的发掘和巧妙组合而已.而且这里组合是主要的,
                        特性是有限的,这本书中有几个模式没用虚特性的?
   C++ Standard Document: 在你用它来做专项研究的时候,就会体会到什么才叫真正的
                                          全而深 (自然指在语法和语义的阐述上). 
  《STL源码剖析》 ：没有深厚的功底,想来个闭门造车独挑STL源码是不可能的.
                                  不过,这本说也重在关键技术的讲解和引导罢了~~
                                   这里关于GP和STL的名著不少，本人没看过。不做品评。
  《 Inside The C++ Object Model》：最具价值的一本书,没了它,C++永远是个迷,哪怕
                                    你浸淫之N载~~
  《Moden In C++ Design》 ：这里的很多思路是你自己的思维很难接触到的~~：)
                            我不得不佩服Andrei Alexandrescu.

  市面上其它的C++书籍可牛车载,我感觉除了《The Design And Evolution Of C++》是异品,值得一读.其它的不建议花太多的时间,哪怕是Bjarne Stroustrup、Stanley B.Lippman等的作品.自然,你有时间读更好,反正我现在有点后悔,当初只顾多,不顾深读,反复读.经典的书不在本数多,在于每本读的遍数多.一经验之谈,BBS上经常有人,在介绍COM技术书籍时,想也不想的指出,入门级<<Inside The COM>>.是这样的吗?我想,正如Dale Rogerson所说,将这本书完全看懂,你就是COM专家了~~书中,作者很多话可能你没有注意到,因为你还不懂之,对之没感觉,一遍翻下来,感觉 哦~~简单~全看了 :) 这些书,跟国内的很多书籍最大的不同就是
国内书籍的作者写的出,可能自己还不懂:)Copy什么资料上的:)??

4.浸淫一门语言本身的语法语义再久,你不一定能够深入它的精妙之处.
  你需要学习应用这门语言的实作品(技术),你可以研究一些FrameWork或是一些具体的技术 如CORBA、COM等.就个人而已,有心接触C++十个月左右,对于Virtual的认识有过几次较大的的改变.在《 Inside The C++ Object Model》中算第一次,在《COM本质论》中关于COM对二进制兼容布局需求而用虚机制来解决是第二次,到目前为止,使我对virtual流下最深刻印象的是在Automation技术中组件由于环境是否有能力分析virtual结构而导致是否需要分发接口的问题.如果,整天抱着《C++语法语义深入》这样的书,我不知你何时才能真正了解C++很多的特性.
  即使你可以对别人说上一大套,这行啊~那不行啊~~云云~~:)

在这整个的过程中,我喜欢这样对学弟说,你需要经常将C++的各种特性在脑中反复混合酝踉,这也是我强调学基础时,要求教材知识点全的原因.经常的,为了研究某些特性而自由的写、修改、增加UseCase,是我自认为很好的一个习惯.整天记他人的经验之言,不知几个月后还记得几层:)?

   也许上面的叙述是概括了些:)?

   总之,我认为学习C++,需要多思考(譬如你想想为什么模板类继承不支持virtual、模板
                                   类继承,基类实例和继承类实例产生的关系是什么样的)、
                      多写usecase、
                      多将一堆特性混合酝晾（譬如模板类
                                  成员签名、多种嵌套模板类成员签名、嵌套类与包裹类生命期
                                 控制等等)
                     
                      要尽早选择应用方向(这点很重要,附加个人观点：大多数人认为理论很
                                         难，可是我要说：应用一样是有难度的:)).

                      将00工程学中的理论适时的来对照自己的行为.
    

后话：
    上面提到,就应用而已,比较语言的是没有什么意义的.然而我想说的是,不敢想象
没有经过C++锤炼的人,可以深入的研究C#(事实上，我一直也不人为C#比C++好学，只是他们的深入点是不同的，冒昧说一句，C++中很多难度是人为制造出来的),就目前的情况来说,还有就是由于C++历史、
社团、资源等因素.