Từ 1 tới 5 trên tổng số 5 kết quả

Đề tài: Lớp số nguyên lớn trên C++ | Cộng, trừ, nhân và so sánh số nguyên lớn??

  1. #1
    Ngày gia nhập
    04 2009
    Nơi ở
    Hà Nội
    Bài viết
    42

    Wink Lớp số nguyên lớn trên C++ | Cộng, trừ, nhân và so sánh số nguyên lớn??

    Mình có đoạn code sau thực hiên tính toán cộng, trừ, nhân và các toán tử so sánh <, >, <=, >=, ==, != .
    Do gặp khó khăn trong việc chuẩn hoá để cho 2 số trước khi tính toán có độ dài bằng nhau nên mình có mượn code của coder_gate xài tạm. Có một vài chỗ mình không hiểu các bạn cùng mình nghiên cứu nhé.

    Đoạn này trong operator +. Mình không hiểu -'0' hay +'0' là để làm gì. Cái bước này có phải là nghịch đảo xâu rồi thực hiên tính toán không?
    Code:
    			for(int i=max-1;i>=max-min;i--)
    			{
    				C.value[j]=(B.value[i]-'0'+this->value[i+min-max]-'0'+temp)%10;	
    				temp=(B.value[i]-'0'+this->value[i+min-max]-'0'+temp)/10;
    				C.value[j]=(C.value[j]+'0');
    				cout<<C.value[j];
    				j--;
    			}
    Còn đoạn này thì bỏ đi không ảnh hưởng gì đến phép + nhưng lại làm sai kết quả ở phép nhân:
    Code:
    			for(i=max-min-1;i>=0;i--)
    			{
    				C.value[j]=(B.value[i]-'0'+temp)%10;
    				temp=(B.value[i]-'0'+temp)/10;
    				C.value[j]=(C.value[j]+'0');
    				int i=1;
    				cout<<C.value[j]+i;
    				j--;
    			}
    Còn đây là code chạy chương trình khá hoàn chỉnh. Nói chung vẫn thiếu rất nhiều để hoàn thiện lớp số nguyên lớn.
    Code:
    #include <iostream.h>
    #include <string.h>
    #include <iomanip.h>
    #include <math.h>
    
    class Verylong
    {
    private:
    	char value[50];
    	int size;
    	int sign;
    public:
    	Verylong(char giatri[50])
    	{
    		strcpy(this->value,giatri);
    		this->sign =0;
    		this->size = strlen(giatri);
    	}
    	Verylong()
    	{cout<<"A";}
    	void Input(char *t);
    	void Output();
    	friend istream& operator>>(istream& input,Verylong &BI);
    	friend ostream& operator<<(ostream& output,Verylong &BI);
    	//--------------------------------------------------------------
    	int Verylong::operator < (Verylong B);
    	int Verylong::operator <=(Verylong B);
    	int Verylong::operator > (Verylong B);
    	int Verylong::operator >=(Verylong B);
    	int Verylong::operator ==(Verylong B);
    	int Verylong::operator !=(Verylong B);
    	//--------------------------------------------------------------
    	int Verylong::operator +=(Verylong B);
    	int Verylong::operator -=(Verylong B);
    	int Verylong::operator *=(Verylong B);
    	int Verylong::operator /=(Verylong B);
    	int Verylong::operator %=(Verylong B);
    	//--------------------------------------------------------------
    	Verylong operator +(Verylong B);
    	Verylong operator -(Verylong B);
    	Verylong operator *(Verylong B);
    	Verylong operator /(Verylong B);
    	Verylong operator %(Verylong B);
    	Verylong operator++();
    	Verylong operator++(int i);
    	Verylong operator--();
    	Verylong operator--(int i);
    	//--------------------------------------------------------------
    	//--------------------------------------------------------------
    	operator int();
    	operator float();
    	operator double();
    };
    //====================================================================================
    	istream& operator>>(istream& input,Verylong &BI)
    	{
    		cout<<"\nNhap so nguyen lon : "; cin.get(BI.value,50);cin.ignore();
    		return input;
    	}
    //====================================================================================	
    	ostream& operator<<(ostream& output,Verylong &BI)
    	{
    		output<<BI.value<<endl;
    		return output;
    	}
    //====================================================================================
    void Verylong::Input(char *t)
    {
    	int j=0;
    	bool flag;
    	int dd=strlen(this->value);
    	do
    	{
    		flag =true;
    		j++;
    		if(j>1)
    		{	cout<<"\nINPUT ERROR! INPUT AGAIN:\n";	}
    		cout<<"Input value Verylong "<<t<<":";
    		cin>>value;
    		size=strlen(value);
    		if(this->value[0]=='-')
    		{
    			for(int i=1;i<size;i++)
    			{
    				if(value[i]<'0'||value[i]>'9')
    				{	flag=false;	break;	}
    			}
    			this->sign =-1;
    			for(i=0;i<size;i++)
    			{	this->value[i]= this->value[i+1];	}
    		}
    		else 
    			if(this->value[0]>='0'&&this->value[0]<='9')
    		{
    			this->sign=0;
    			for(int i=1;i<size;i++)
    			{
    				if (value[i]<'0'||value[i]>'9')
    				{	flag = false; break;	}
    			}
    			size=strlen(this->value);
    		}
    	} 
    	while(flag == false);
    
    	//sau khi nhap dung,gio phai truyen gia tri la sign,size,value cho class BigINT 
    	//voi so la so duong thi can chuan hoa neu 0000001 -> =1 
    	while(this->value[0]=='0')
    	{
    		for(int i=0;i<=dd;i++)
    		{	this->value[i]= this->value[i+1];	}
    	}
    	if(this->value[0]>='0'&&this->value[0]<='9')
    	{	size=strlen(this->value);	}
    	if(this->value[0]==NULL)//sau khi xoa neu la NULL -> =0
    	{	this->value[0]='0';size=1;	}
    	if(this->value[0]=='-')     //VD nhu -0000001 <->  -1
    	{
    		while(this->value[1]=='0')
    		{
    			for(int i=1;i<=dd;i++)
    			{	this->value[i]= this->value[i+1];	}
    		}
    		sign=-1;
    		if(this->value[1]==NULL)
    		{	this->value[0]='0';size=1;sign =0;	}
    	}
    }
    //====================================================================================
    void Verylong::Output()
    	{
    		if (this->sign==0)
    		{	cout<<" "<<value;	}
    		else
    		{	cout<<"-"<<value;	}
    	}
    //====================================================================================
    int Verylong::operator < (Verylong B)
    {
    	if(this->sign==0 && B.sign==0)
    	{
    		if(strlen(this->value)<strlen(B.value))
    			{	return -1;	}
    		if(strlen(this->value)==strlen(B.value))
    			{
    				int dd=strlen(this->value);
    				for(int i=0;i<dd;i++ )
    					if(this->value[i]<B.value[i])
    						return -1;
    			}
    	}
    	if(this->sign==-1 && B.sign==0)
    		return -1;
    	return 0;
    }
    //====================================================================================
    int Verylong::operator > (Verylong B)
    {
    	if((*this)<B==0)
    		return -1;
    	return 0;
    }
    //====================================================================================
    int Verylong::operator ==(Verylong B)
    {
    	if(this->sign==0 && B.sign==0 || this->sign==-1 && B.sign==-1)
    	{
    		if(strlen(this->value)==strlen(B.value))
    		{
    			int dd=strlen(this->value);
    			for(int i=0;i<dd;i++)
    				if(this->value[i]!=B.value[i])
    					return 0;
    				return -1;
    		}
    	}
    	return 0;
    }
    //====================================================================================
    int Verylong::operator !=(Verylong B)
    {
    	if((*this)==B==0)
    		return -1;
    	return 0;
    }
    //====================================================================================
    int Verylong::operator <=(Verylong B)
    {
    		if((*this)<B==-1||(*this)==B==-1)
    			return -1;
    		return 0;
    }
    //====================================================================================
    int Verylong::operator >=(Verylong B)
    {
    	if((*this)>B==-1||(*this)==B==-1)
    		return -1;
    	return 0;
    }
    //====================================================================================
    Verylong Verylong::operator +(Verylong B)
    {
        Verylong C("0");
    	int temp =0;
    	int max,min;
    	int j;
    	if (this->sign == 0 && B.sign == 0)		//neu A>0 va B>0
    	{
    		if ((*this)<=B==-1)					//neu A<=B		
    		{
    			max = strlen(B.value);			
    			min = strlen(this->value);		
    			j=max-1;						
    			for(int i=max-1;i>=max-min;i--)
    			{
    				C.value[j]=(B.value[i]-'0'+this->value[i+min-max]-'0'+temp)%10;
    	
    				temp=(B.value[i]-'0'+this->value[i+min-max]-'0'+temp)/10;
    		
    				C.value[j]=(C.value[j]+'0');
    		
    				cout<<C.value[j];
    				j--;
    			}
    			for(i=max-min-1;i>=0;i--)
    			{
    				C.value[j]=(B.value[i]-'0'+temp)%10;
    				temp=(B.value[i]-'0'+temp)/10;
    				C.value[j]=(C.value[j]+'0');
    				int i=1;
    				cout<<C.value[j]+i;
    				j--;
    			}
    			if(temp==1)
    			{
    				char tmp[51];
    				tmp[0]='1';
    				for(int i= 1;i<=max;i++)
    				{
    					tmp[i]=C.value[i-1];
    				}
    				tmp[max+1]='\0';
    				strcpy(C.value,tmp);
    				C.sign=B.sign;
    			}
    			C.sign=B.sign;
    			C.value[max]='\0';
    		}
    		else  //A > B => B + A
    			return B + (*this);
    	}
    	else if(this->sign == -1 && B.sign == -1)    //A<0 va B<0 
    	{
    		Verylong D("0"),E("0");
    		D= B;
    		E = (*this);
    		D.sign = 0;
    		E.sign = 0;
    		C = D + E;
    		C.sign = -1;
    	}
    	else
    	{
    		if (this->sign == -1 && B.sign ==0)  // A<0 va B>0
    		{
    			Verylong C("0"), D("0"), E("0");
    			D = B;
    			E = (*this);
    			D.sign = 0;
    			E.sign = 0;
    			C = D - E;
    		}
    		else if (this->sign == 0 && B.sign ==-1)
    		{
    			Verylong C("0"), D("0"), E("0"); // A>0 va B<0
    			D = B;
    			E = (*this);
    			D.sign = 0;
    			E.sign = 0;
    			C = D  - E ;
    			C.sign = 0;
    		}
    	}
    	return C;
    }
    //====================================================================================
    Verylong Verylong::operator -(Verylong B)
    {
    	Verylong C("0");
    	int max,min,temp =0,z=0;
    	if (this->sign==0 && B.sign == 0 )		//A>0 va B>0
    	{
    		if((*this)>=B==-1)
    		{
    			max = strlen(this->value);		//A>= B nen Max = A 
    			min = strlen(B.value);			//			Min =B
    			for(int i=max-1;i>=max-min;i--)
    			{
    				if(this->value[i]-temp>=B.value[i+min-max])
    				{
    					C.value[i] = (this->value[i]-'0')-(B.value[i+min-max]-'0');
    					C.value[i] = C.value[i]+'0';
    				}
    				else
    				{
    					C.value[i] = 10+(this->value[i]-'0')-(B.value[i+min-max]-'0')-temp;
    					C.value[i] = C.value[i] + '0';
    					temp = 1;
    				}
    			}
    			if(temp==0)
    			{
    				for(i=max-min-1;i>=0;i--)
    					C.value[i] = this->value[i];
    				C.value[max] = '\0';
    				C.sign = 0;	
    				int dd=strlen(C.value)-1;	
    				while(C.value[0]=='0' && z<dd) z++;					
    						strcpy(&C.value[0],&C.value[z]);
    			}
    			for(i=max-min-1;i>=0;i--)
    			{
    				if(temp ==0)
    					C.value[i] = this->value[i];
    				if(this->value[i]-temp-'0'>=0)
    				{
    					C.value[i] = (this->value[i]-'0')-temp;
    					C.value[i] = C.value[i]+'0';
    					temp =0;
    				}
    				else if(this->value[i]-temp-'0'<0)
    				{
    					C.value[i] = 10+(this->value[i]-'0')-temp;
    					C.value[i] = C.value[i]+'0';
    					temp = 1;
    				}
    			}
    			if(temp==1)
    				C.value[0] = '0';
    			C.value[max] = '\0';
    			C.sign = 0;
    			int dd=strlen(C.value)-1;
    			while(C.value[0]=='0' && z<dd) z++;					
    				strcpy(&C.value[0],&C.value[z]);
    		}
    		else   //neu A<B 
    		{
    			C = B-(*this);		//goi lai ham tru de tinh
    			C.sign = -1;		// vi so A<B nen A-B <0				
    			int dd=strlen(C.value)-1;
    			while(C.value[0]=='0' && z<dd) z++;					
    				strcpy(&C.value[0],&C.value[z]);
    		}
    	}
    	if((this->sign==-1&& B.sign==-1))   //A<0 va B<0 -> A-B = |B| - |A|
    	{
    		Verylong C("0"), E("0"), D("0");
    		E = B;
    		D = (*this);
    		D.sign = 0;
    		E.sign = 0;
    		C = D - E;
    	}
    	else
    	{
    		if(this->sign==0 && B.sign ==-1)		//A>0 va B<0 -> A-B = |A| + |B|
    		{
    			Verylong C(""), D("0");
    			D = B;		//gan D = B
    			D.sign =0;	//lay |B|
    			C = (*this)+D;
    			C.sign = 0;
    
    		}
    		if(this->sign==-1 && B.sign ==0)		//A<0 va B>0 -> A-B = -(|A| + |B|)
    		{
    			Verylong C("0"), D("0");
    			D = (*this); //gan D = A(*this)
    			D.sign =0;   //lay |A|
    			C = B+D;
    			C.sign = -1;
    		}
    	}
    return C;
    }
    //====================================================================================
    Verylong Verylong::operator *(Verylong B)
    {
    	int max, min, temp=0;
    	Verylong C("0"),D("0");
    	if((this->sign==0 && B.sign==0 )||( this->sign==-1 && B.sign==-1))
    	{
    		if (strlen(this->value)>=strlen(B.value))
    		{
    			max=strlen(this->value);
    			min=strlen(B.value);
    			for(int i=min-1;i>=0;i--)
    			{
    			    temp=0;
    				for(int j= max-1;j>=0;j--)
    				{
    					C.value[j]=((B.value[i]-'0')*(this->value[j]-'0')+temp)%10;//chi lay phan thap phan cua phep nhan 2 chu so
    					temp=((B.value[i]-'0')*(this->value[j]-'0')+temp)/10;      //lay du
    					C.value[j]=C.value[j]+'0';
    				}
    				if (temp>0)//tuc la co du sau phep nhan VD nhu 9 * 2  thi co them 1 chu so
    				{
    					char tmp[100];
    					strcpy(tmp,C.value);
    					C.value[0]=temp+'0';   // dua them nho vao dang truoc
    					for(int j=1;j<=max;j++)
    					{
    						C.value[j]=tmp[j-1];
    					}
    					if(i!=min -1)
    					{
    						for (int j=max+1;j<max+min-i;j++)//them so 0 vao sau cac so
    						{
    							C.value[j]='0';
    						}
    						C.value[max+min-i]=NULL;
    					}
    					else
    					{  C.value[max+1]=NULL;  }
    					C.sign = 0;
    				}
    				else   //neu ko co du,thi so chu so van duoc giu nguyen
    				{
    					C.sign =0;  // A>B>0 -> A*B >0 -> la so duong
    					if (i<min -1)
    					{
    						for (int j=max;j<max + min -1 - i;j++)//them so 0 vao sau cac so
    						{
    							C.value[j]='0';
    						}
    					}
    					C.value[max+min-1-i]=NULL;
    					C.sign=0;
    				}
    				D.sign=0;
    				D=C+D;
    			}	
    			return D;
    		}
    		else
    			return B* (*this);
    	}
    	else
    	{
    		Verylong E("0");
    		E=(*this);  //lay bien ra (*this)
    		E.sign=0;   //dua ve gia tri tuyet doi
    		B.sign=0;
    		D=E*B;      //tinh tich 2 so duong quay lai buoc truoc
    		D.sign=-1;  //neu 2 so trai dau voi nhau thi tich am
    		return D;
    	}
    }
    //====================================================================================
    /*Verylong Verylong::operator ++ ()
     {
    	return *this = *this + 1;
     }
    //====================================================================================
    Verylong Verylong::operator ++ (int)
    {
    	Verylong result(*this);
    	*this = *this + 1;
    	return result;
    }*/
    //====================================================================================
    /*Verylong Verylong::operator /(Verylong B)
    {
    	int temp=0;
    	Verylong C("0"),D("0");
    	if((this->sign==0 && B.sign==0 )||( this->sign==-1 && B.sign==-1))
    		if(
    }*/
    //====================================================================================
    class Menu
    {
    	Verylong A,B;
    public:
    	Menu():A(""),B("")
    	{cout<<"\n........ CHUONG TRINH QUAN LY SO NGUYEN LON.........";}
    	int Show()
    	{
    		int k;
    		   cout<<"\n	1.Thuc hien nhap va hien so nguyen lon.";
    		   cout<<"\n	2.Thuc hien tinh toan tren so nguyen lon.";
    		   cout<<"\n	3.Thuc hien gan so nguyen lon.";
    		   cout<<"\n	4.Thuc hien thay doi so nguyen lon.";
    		   cout<<"\n	5.Thuc hien so sanh so nguyen lon.";
    		   cout<<"\n	6.Thuc hien chuyen doi so nguyen lon.";
    		   cout<<"\n	7.Thuc hien ham toan hoc tren so nguyen lon.";
    		   cout<<"\n	8.Thoat chuong trinh.";
    		   cout<<"\n=======================================================";
    		   cout<<endl<<"Chon muc thao tac:";
    		   cin>>k;
    		   return k;
    	}
    	void process()
    	{
    		Verylong kq;
    		int k;
    		do
    		{
    			k=Show();
    			switch(k)
    			{
    				case 1 : 
    					{	A.Input("A");B.Input("B");
    						cout<<endl<<"So nguyen lon A:";A.Output();
    						cout<<endl<<"So nguyen lon B:";B.Output();
    						break;
    					}
    				case 2 : 
    					{	
    						cout<<"\nTong hai so nguyen lon A + B = ";(A+B).Output();
    						cout<<"\nHieu hai so nguyen lon A - B = ";(A-B).Output();
    						cout<<"\nTich hai so nguyen lon A * B = ";(A*B).Output();
    						break;
    					}
    				case 3 :{cout<<"A = B = ";}
    				case 4 :
    				case 5 :
    					{
    						if(A<B==0)	cout<<"\n A <  B : FALSE => A > B";
    						else		cout<<"\n A <  B : TRUE";
    						if(A>B==0)	cout<<"\n A >  B : FALSE => A < B";
    						else		cout<<"\n A >  B : TRUE";
    						if(A<=B==0)	cout<<"\n A <= B : FALSE => A >= B";
    						else		cout<<"\n A <= B : TRUE";
    						if(A>=B==0)	cout<<"\n A >= B : FALSE => A <= B:";
    						else		cout<<"\n A >= B : TRUE";
    						if(A==B==0)	cout<<"\n A == B : FALSE => A != B:";
    						else		cout<<"\n A == B : TRUE";								
    						if(A!=B==0)	cout<<"\n A != B : FALSE => A == B:";
    						else		cout<<"\n A != B : TRUE";
    						break;
    					}
    				case 6 :{}
    				case 7 :{}
    			}
    		}
    		while(k!=8);
    	}
    };
    //====================================================================================
    
    void main()
    {
    	Menu f;
    	f.process();
    }
    Các bạn giúp mình nhé. Thanks trước nhé.
    Đã được chỉnh sửa lần cuối bởi chocolate1146 : 16-05-2009 lúc 02:28 PM.

  2. #2
    Ngày gia nhập
    03 2009
    Nơi ở
    Tứ xứ trên đất sài thành
    Bài viết
    60

    theo mình nghĩ -'0' hay +'0' là -48 hay+48 thì phải trong bảng mã ASCII 48='0'!!!
    ký tự cũng là một số nguyên mà đúng không?

    Càng Học Càng Ngu!!!Kiến thức thì vô tận con người thì vô biên thời gian thì vô đối????...

  3. #3
    Ngày gia nhập
    04 2009
    Nơi ở
    Hà Nội
    Bài viết
    42

    Mình cũng không rõ lắm. Mình thử chặn code và cho cout xem các thao tac nhưng -'0' hoặc số khác thì được, độ lệch mỗi hàng kết quả tăng tùy thuộc vào giá trị trong ' '. Nhưng khi chuyển qua +'0' hay số khác thì ra kí tự rất đẹp. Cũng không rõ nó dùng để làm gì nữa.
    Avata - Định Công - Giáp Bát mùa lũ

  4. #4
    Ngày gia nhập
    10 2009
    Bài viết
    18

    -'0' tương đương với -48 (mã ASCII của kí tự 0)
    char cũng là kiểu số nguyên 1 byte
    khi bạn nhập vào từ bàn phím thì sẽ là kí tự 0 ,1 ,2, 3 ..... có mã ascii là 48,49,50,51,...
    vd :
    nhập kí tự 0 vào sẽ lấy (kí tự)0 - '0' <=> 48 - 48 =0( 0 này là số nguyên)
    nhập kí tự 1 vào sẽ lấy (kí tự)1 - '0' <=> 50 - 48 =1( 1 này là số nguyên)

    ở đây mình sẽ lưu số nguyên vào mảng char để tiện cho tính toán

  5. #5
    Ngày gia nhập
    12 2009
    Bài viết
    15

    híc mình cũng đang làm bài này nhưng. không viết băng class. cung có ý tưởng như của bạn. là ghép các chử số '0' vào trước số nào bé hơn để chuẩn hóa. sau đó se tách từng chử số 1 trong chuổi số và cộng chúng lại với nhau. bằng cách chử số +48 = số(bảng mã ACSII) được kết quả lại đưa lại về chử số. và gán vào 1 mang kết quả

Các đề tài tương tự

  1. Bài tập C giải thuật nhập vào số nguyên n in ra n số nguyên tố đầu tiên?
    Gửi bởi LTC trong diễn đàn Thắc mắc lập trình C/C++/C++0x
    Trả lời: 48
    Bài viết cuối: 25-04-2013, 07:40 PM
  2. Viết chương trình nhập số nguyên dương n, liệt kê n số nguyên tố đầu tiên.
    Gửi bởi maiit trong diễn đàn Thắc mắc lập trình C/C++/C++0x
    Trả lời: 11
    Bài viết cuối: 19-06-2011, 01:05 PM
  3. Game Viết chương trình nhập số nguyên dương n, liệt kê n số nguyên tố đầu tiên trên C#?
    Gửi bởi maiit trong diễn đàn Thắc mắc lập trình C#
    Trả lời: 18
    Bài viết cuối: 08-06-2011, 11:12 PM
  4. Bài tập C++ chương trình đổi 1 số nguyên trong hệ thập phân sang hệ fibo và cộng 2 số nguyên được
    Gửi bởi nghiapro512 trong diễn đàn Thắc mắc lập trình C/C++/C++0x
    Trả lời: 3
    Bài viết cuối: 23-01-2011, 02:14 PM
  5. Số nguyên lớn, thực hiện các phép toán trên số nguyên lớn?
    Gửi bởi superhot2008 trong diễn đàn Thắc mắc lập trình C/C++/C++0x
    Trả lời: 2
    Bài viết cuối: 17-03-2009, 10:02 PM

Quyền hạn của bạn

  • Bạn không thể gửi đề tài mới
  • Bạn không thể gửi bài trả lời
  • Bạn không thể gửi các đính kèm
  • Bạn không thể chỉnh sửa bài viết của bạn