duze_liczby2

#include <iostream>
#include <stdio.h>
#include <string.h>
using namespace std;


class Big_number{
protected:
  friend ostream & operator<< (ostream & s1, Big_number & o1);
  friend istream & operator>>(istream & s1, Big_number & o1);
  char* number;
  int length;
public:
  Big_number(){
    number=NULL;
    length=0;
  }

  ~Big_number(){
    if (number!=NULL){
      delete [] number;
      number=NULL;
      length=0;
    }
  }

  Big_number(const char* o1){
    length = strlen(o1);
    number = new char[length];
    for (int i = 0; i < length; i++){
      number[i] = o1[i];
    }
  }

  Big_number(const class Big_number & o1){
    length=o1.length;
    number = new char[o1.length];
    for (int i = 0; i < o1.length; i++){
      number[i] = o1.number[i];
    }
  }

  Big_number & operator=(const Big_number & o1){
  if (this==&o1) return *this;

  if (this->number!=NULL) this->~Big_number();
  this -> length = o1.length;
  this -> number = new char[o1.length];
  for (int i = 0; i<o1.length; i++){
    this->number[i]=o1.number[i];
  }
  return *this;
  }


  Big_number  operator+(const Big_number &o1){
  {
    if (o1.number==NULL) return *this;
    if (this->number==NULL) return o1;
    Big_number result;
    int add1,add2,add=0;
    if (o1.length<this->length) result.length=this->length+1;
    else result.length=o1.length+1;
    int length_o1=o1.length, length_this=this->length;
    result.number=new char [result.length];

    for (int i=result.length-1; i>=0; i--)
    {
      if(length_o1>0) add1=o1.number[length_o1-1]-'0';
      else add1=0;
      if (length_this>0) add2=this->number[length_this-1]-'0';
      else add2=0;
      add1=add1+add2+add;
      add=add1/10;
      result.number[i]=add1%10+'0';
      length_o1--;
      length_this--;
    }
    if (result.number[0]!='0')
      return result;
    Big_number temp;
    temp.length=result.length-1;
    temp.number=new char[temp.length];
    for (int i=0; i<temp.length; i++)
      temp.number[i]=result.number[i+1];
    result.~Big_number();
    return temp;
  }
};

};//koniec Big_number

istream & operator >> (istream & s1, Big_number & o1){
  if (o1.number != NULL) o1.~Big_number();
  string input;
  s1 >> input;
  o1.length=input.size();
  o1.number = new char[o1.length];
  for (int i=0;i<o1.length;i++){
    o1.number[i]=input[i];
  }
  return s1;
}

ostream & operator <<(ostream & s1, Big_number & o1){
  for (int i = 0; i < o1.length; i++){
    s1 << o1.number[i];
  }
  s1 << endl;
  return s1;
}

//początek Big_number2
class Big_number2 : public Big_number
{
public:

  Big_number2() : Big_number(){};
  Big_number2(const class Big_number &o1) : Big_number(o1){};

  Big_number2 & operator=(const Big_number2 & o1){
  if (this==&o1) return *this;
  if (this->number!=NULL) this->~Big_number();
  this -> length = o1.length;
  this -> number = new char[o1.length];
  for (int i = 0; i< o1.length; i++){
    this->number[i]=o1.number[i];
  }
  return *this;
  }

  bool operator ==(const Big_number2 & o1){
    int size1=this->length;
    int size2=o1.length;
    if (size1!=size2) return false;
    else{
      for (int i= size1-1;i>=0;i--){
        if (this->number[i]!=o1.number[i]) return false;
      }
      return true;
    }
  }

  bool operator !=(const Big_number2 & o1){
    int size1=this->length;
    int size2=o1.length;
    if (size1!=size2) return true;
    int ile=0;
    for (int i= size1-1;i>=0;i--){
      if (this->number[i]==o1.number[i]){
        ile++;
      }
    }
    if (ile == size1) return false;
    return true;
  }


  bool operator >(const Big_number2 & o1){
    int size1=this->length;
    int size2=o1.length;
    if (size1>size2) return true;
    if (size1<size2) return false;
    for (int i=0;i<size1;i++){
      if (this->number[i]>o1.number[i]) return true;
    }
    return false;
  }


  bool operator <(const Big_number2 & o1){
    int size1=this->length;
    int size2=o1.length;
    if (size1<size2) return true;
    if (size1>size2) return false;
    for (int i=0;i<size1;i++){
      if (this->number[i]<o1.number[i]) return true;
    }
    return false;
  }



  Big_number2 & operator * (const Big_number2 &o1){
    static Big_number2 result;
    if (o1.number==NULL || this->number==NULL){
      return result;
    }
    result.length=o1.length+this->length+1;
    result.number=new char[result.length];
    int i,j;
    int mltp1,mltp2,add=0,add1;
    for(int a=0;a<result.length;a++) result.number[a]='0';
    if (o1.length>this->length){
      cout <<this->number[0] <<endl;
      for (i=1; i<=this->length;i++){
        mltp1=this->number[this->length-i]-'0';
        for (j=0; j<o1.length; j++){
          mltp2=o1.number[o1.length-1-j]-'0';
          add1=result.number[result.length-i-j]-'0';
          add1=add1+mltp1*mltp2+add;
          add=add1/10;
          result.number[result.length-i-j]=add1%10+'0';
        }
        result.number[result.length-i-j]=add+'0';
        add=0;
      }
    }
    else {
      for (i=1; i<=o1.length;i++){
        mltp1=o1.number[o1.length-i]-'0';
        for (j=0; j<this->length; j++){
          mltp2=this->number[this->length-1-j]-'0';
          add1=result.number[result.length-i-j]-'0';
          add1=add1+mltp2*mltp1+add;
          add=add1/10;
          result.number[result.length-i-j]=add1%10+'0';
        }
        result.number[result.length-i-j]=add+'0';
        add=0;
      }

    }
    int n=0;
    while (true){
      if (result.number[n]=='0') n++;
      else break;
    }
    if (n==0) return result;
    static Big_number2 temp;
    temp.length=result.length-n;
    temp.number=new char[temp.length];
    for (int t=0; t<temp.length;t++){
      temp.number[t]=result.number[t+n];
    }
    result.~Big_number2();
    return temp;

}

};//koniec Big_number2


int main(){
  Big_number2 a, b, c, d;
  cin >> a;
  cin >> b;
  cout <<"a= "<< a <<"b= "  <<b;
  c=a;
  cout <<"c= "<< c;
  c=a+b;
  cout << "c= a+b" <<endl <<"c= " <<c;

  d=a*b;
  cout << "d= a*b" <<endl <<"d= " <<d;
  return 0;
}