首页 > 代码库 > 1001. Elements and MyVector 2016 4 8

1001. Elements and MyVector 2016 4 8

#include<iostream>
#include<string>
using namespace std;

class Elements{

       private:

              int value;

              static int numberOfObjects;

       public:

              Elements();

              Elements(const int &value);//set value

              Elements(const Elements &elem);

              ~Elements();//descructor

 

              Elements & operator=(const Elements &elem);//assignment

              Elements & operator=(const int &value);//assignment

              friend istream& operator>>(istream& is, Elements & elem);

              //input one integer, and set the value


              friend ostream& operator<<(ostream& os, const Elements & elem);

              //output one integer to ostream


              void setValue(const int &value);

              //set value


              int getValue()const;

              //get value

 

              Elements & operator+=(const Elements &elem);

              Elements & operator+=(const int &value);

 

              Elements operator+(const Elements &elem)const;

              Elements operator+(const int &value)const;

 

              bool operator ==(const Elements &elem)const;

              bool operator ==(const int &value)const;

 

              bool operator <(const Elements &elem)const;

              bool operator <(const int &value)const;


              operator int()const;//converts Elementes to int

 

              static int getNumberOfObjects();//return the number of objects

};

 

class MyVector{

       private:

              Elements *elem;

              int _size;

       public:

              MyVector();//default constructor

              MyVector(int n);// constructor an Array of n Elements

              MyVector(const MyVector &vec);//copy constructor

              ~MyVector();//destructor

              const MyVector & operator=(const MyVector &vec);//assignment

              Elements &operator[](int i);//return the references of elem[i]

              Elements operator[](int i) const; //return the copy of elem[i]

 

              int size()const;//return the size

 

              bool operator == (const MyVector &vec)const;//judge if it is equal

              friend istream& operator>>(istream& is, MyVector & vec);

              //first input n as a _size, then input elem[0],elem[1],…,elem[n-1];

 

              friend ostream& operator<<(ostream& os, const MyVector & vec);

//output elem[0],elem[1],elem[2],..,elem[_size-1] in a line, separated by a

 //space. e.g  _size = 2 and elem[0]=5,elem[1]=6, you should output

              //”5 6” in a line

};

 


int Elements::numberOfObjects=0;

Elements::Elements(){
   value=http://www.mamicode.com/0;
   numberOfObjects++;
 
}

Elements::Elements(const int &value){
      this->value = http://www.mamicode.com/value;
   numberOfObjects++;
}//set value

Elements::Elements(const Elements &elem){
   this->value = http://www.mamicode.com/elem.value;
   numberOfObjects++;
}

Elements::~Elements(){
   numberOfObjects--;
   numberOfObjects--;
}


Elements& Elements::operator=(const Elements &elem){
   this->value = http://www.mamicode.com/elem.value;
   return *this;
}

Elements& Elements::operator=(const int &value){
   this->value = http://www.mamicode.com/value;
   return *this;
}

istream& operator>>(istream& is, Elements & elem){
   is>>elem.value;
   return is;
}

              //input one integer, and set the value
ostream& operator<<(ostream& os, const Elements & elem){
   os<<elem.value;
   return os;
}

              //output one integer to ostream

void Elements::setValue(const int &value){
   this->value = http://www.mamicode.com/value;
}

              //set value


int Elements::getValue()const{
     return value;
}


Elements & Elements::operator+=(const Elements &elem){
     this->value = http://www.mamicode.com/this->value + elem.value;
  return *this;
}


Elements & Elements::operator+=(const int &value){
  this->value = http://www.mamicode.com/this->value + value;
  return *this;
}

 
Elements Elements::operator+(const Elements &elem)const{
    
     Elements a(this->value);
     a.value =http://www.mamicode.com/a .value + elem.value;
     return a;
    
}

Elements Elements::operator+(const int &value)const{
  
     Elements a(this->value);
     a.value =http://www.mamicode.com/a .value + value;
     return a;  
  
}

 
bool Elements::operator ==(const Elements &elem)const{
   
     if(this->value=http://www.mamicode.com/=elem.value) return true;
     else return false;
    
}

bool Elements::operator ==(const int &value)const{

     if(this->value=http://www.mamicode.com/=value) return true;
     else return false;
    
}

 

bool Elements::operator <(const Elements &elem)const{
     if(this->value < elem.value) return true;
     else return false;

}

bool Elements::operator <(const int &value)const{
 
     if(this->value < value) return true;
     else return false;

}


Elements::operator int()const{
 
    return value;
   
}
 
int Elements::getNumberOfObjects(){
 
 return numberOfObjects;
}

MyVector::MyVector(){
 
 elem = NULL;
 _size = 0;
 
}

MyVector::MyVector(int n){
 
 _size = n;
 elem = new Elements[_size];
 
}

MyVector::MyVector(const MyVector &vec){
 
 _size = vec._size;
 elem = new Elements[_size];
 for( int i=0;i<_size;i++){
  elem[i].setValue(vec.elem[i].getValue());
 }
 
}

MyVector::~MyVector(){
 
 delete [] elem;
 
}


const MyVector& MyVector::operator=(const MyVector &vec){
 
 _size = vec._size;
 if(this == &vec) return *this;
 delete [] elem;
 elem = new Elements[_size];
 for( int i=0;i<_size;i++){
  elem[i].setValue(vec[i].getValue());
 }
 return *this;
 
}

Elements& MyVector::operator[](int i){
 
 return elem[i];
 
}

Elements MyVector::operator[](int i) const{
  
   return elem[i];
   
}

 

int MyVector::size()const{
  
   return this->_size;
  
}

 

bool MyVector::operator == (const MyVector &vec)const{
 
     if(this->_size != vec._size ) return false;
     else {
      for(int i=0;i<vec._size;i++){
       if(vec.elem[i].getValue()!=this->elem[i].getValue())
       return false;
      }
      return true;
     }
    
}

istream& operator>>(istream& is, MyVector & vec){
 
 is>>vec._size;
 //if(vec._size<=0) exit(1);
 delete [] vec.elem;
 vec.elem = new Elements[vec._size];
 for(int i=0;i<vec._size;i++){
  is>>vec.elem[i];
 }
 return is;
}

              //first input n as a _size, then input elem[0],elem[1],…,elem[n-1];

 

ostream& operator<<(ostream& os, const MyVector & vec){
 
 for(int i=0;i<vec._size-1;i++){
  os<<vec.elem[i]<<" ";
 }
 os<<vec.elem[vec._size-1];
 return os;
}

Elements getSum(const MyVector &vec)

{

       Elements sum = 0;

       for(int i=0;i<vec.size();i++)

       {

              sum += vec[i];

       }

       return sum;

}


void sample()

{

       MyVector vec;

       while( cin >> vec )

       {

              cout << vec << endl;

              MyVector vec2 = vec;

 

              Elements sum = getSum(vec);

              int average = (int)sum / vec.size();

              for(int i=0;i<vec.size();i++)

              {

                     if( vec[i] < average )

                     {

                            vec [i] = average;

                     }

              }

 

              cout << vec << endl;

              if( vec == vec2 )

              {

                     cout << "They are equal" << endl;

              }

       }

}

 

int main()

{

 

sample();

       if(Elements::getNumberOfObjects()!=0)

       {

              cout << "Error: occupied memory" << endl;

              cout << "Too young too simple, sometimes naive!" << endl;

       }

       return 0;

}

 

1001. Elements and MyVector 2016 4 8