Paste code

//                    ‚ҐабЁп 4.0  (25.08.2001)
//                  ** ‹ЁбвЁЈ д ©«  "vect.h" **
//               ¤Ё ¬ЁзҐбЄЁҐ ¬ ббЁўл vect Ё vector

#ifndef __VECT_H
#define __VECT_H

#ifndef __FSTREAM_H
 #include<fstream.h>
#endif
#ifndef __ASSERT_H
 #include<assert.h>
#endif

template<class T>
class v_obj       // гЄ § вҐ«м   ¬ ббЁў
{
public:
 T* p;            // гЄ § вҐ«м   ¬ ббЁў T
 int size;        // а §¬Ґа ¬ ббЁў 
 int refCount;    // бзҐвзЁЄ ббл«®Є
 // Є®бвагЄв®а б гЄ § ЁҐ¬ а §¬Ґа  size
 // бзҐвзЁЄ ббл«®Є ¤«п ®ў®Ј® ®ЎкҐЄв  гбв  ў«Ёў Ґвбп ў 1
 v_obj(int a): size(a),refCount(1)
  { p=new T[size]; assert(p); memset(p,0,sizeof(T)*size); }
 ~v_obj() { delete [] p; p=NULL; size=0; }
};

template<class T>
class vect        // Їа®бвҐ©иЁ© vect
{
protected:
 v_obj<T>* vp;      // гЄ § вҐ«м   ¬ ббЁў
public:
 // Є®бвагЄв®а б гЄ § ЁҐ¬ а §¬Ґа  size
 vect(int a) { vp=new v_obj<T>(a); assert(vp); }
 // Є®бвагЄв®а Є«®Ёа®ў Ёп
 // бзҐвзЁЄ ббл«®Є ¤«п Є®ЇЁагҐ¬®Ј® ®ЎкҐЄв  Ї®«гз Ґв ЇаЁа йҐЁҐ   1
 vect(const vect& a) { vp=a.vp; vp->refCount++; }
 // ¤ҐбвагЄв®а
 // ¤«п Є«®  - г¬ҐмиҐЁҐ бзҐвзЁЄ  ббл«®Є, ¤«п ®ЎкҐЄв  - г¤ «ҐЁҐ
 ~vect() { if(--vp->refCount==0) delete vp; }
 int up() const { return vp->size-1; } // ўҐаепп Ја Ёж 
 int max() const { return vp->size; }  // а §¬Ґа ¬ ббЁў 
 int len() const { return vp->size; }  // а §¬Ґа ¬ ббЁў 
 // ®ЇҐа в®а ў§пвЁп н«Ґ¬Ґв  ¬ ббЁў  б Їа®ўҐаЄ®© Ја Ёж
 T& operator[](int i) { assert(i>=0&&i<vp->size); return vp->p[i]; }
 T operator[](int i) const { assert(i>=0&&i<vp->size); return vp->p[i]; }
 vect& operator=(const vect&); // ®ЇҐа в®а ЇаЁбў®ҐЁп
 friend ostream& operator<<(ostream&,const vect&); // ўлў®¤   Ї®в®Є
 void print() { cout<<(*this); } // зв®Ў Ўл«®
};
// ®ЇҐа в®а ЇаЁбў®ҐЁп
template<class T>
vect<T>& vect<T>::operator=(const vect<T>& a)
{
 if(this==&a) return *this; // ЇаЁбў Ёў ЁҐ б ¬®¬г бҐЎҐ
 int s=vp->size<a.vp->size?vp->size:a.vp->size;
 for(register i=0;i<s;i++) vp->p[i]=a.vp->p[i];
 return *this;
}

template<class T>
ostream& operator<<(ostream& out,const vect<T>& a) // ўлў®¤   Ї®в®Є
{
 for(register i=0;i<a.vp->size;out<<a.vp->p[i++]<<'\t'); out<<endl;
 return out;
}

template<class T>
class vector: public vect<T> // Є« бб vector
{
public:
 vector(int a): vect<T>(a) {} // Є®бвагЄв®а б гЄ § ЁҐ¬ а §¬Ґа  size
 vector(const vector& a): vect<T>(a) {} // Є®бвагЄв®а Є«®Ёа®ў Ёп
 ~vector() {} // ¤ҐбвагЄв®а
 friend T operator*(const vector&,const vector&); // г¬®¦ҐЁҐ vector*vector
 friend vector operator*(const vector&,T);        // г¬®¦ҐЁҐ vector*T
 friend vector operator*(T,const vector&);        // г¬®¦ҐЁҐ T*vector
 friend vector operator+(const vector&,const vector&); // б«®¦ҐЁҐ vector+vector
 friend vector operator-(const vector&,const vector&); // ўлзЁв ЁҐ vector-vector
 vector& operator+=(const vector&);                // б«®¦ҐЁҐ vector+=vector
 vector& operator-=(const vector&);                // ўлзЁв ЁҐ vector-=vector
 friend istream& operator>>(istream&,vector&); // звҐЁҐ Ё§ Ї®в®Є 
 ostream& write_bin(ostream&); // § ЇЁбм ў ЎЁ ал© д ©«
 istream& read_bin(istream&);  // звҐЁҐ Ё§ ЎЁ а®Ј® д ©« 
};

template<class T>
T operator*(const vector<T>& a,const vector<T>& b) // г¬®¦ҐЁҐ vector*vector
{
 assert(a.vp->size==b.vp->size);
 T ret=0;
 for(register i=0;i<a.vp->size;i++) ret+=a.vp->p[i]*b.vp->p[i];
 return ret;
}

template<class T>
vector<T> operator*(const vector<T>& a,T b) // г¬®¦ҐЁҐ vector*T
{
 vector<T> ret(a.vp->size);
 for(register i=0;i<a.vp->size;i++) ret.vp->p[i]=a.vp->p[i]*b;
 return ret;
}

template<class T>
vector<T> operator*(T b,const vector<T>& a) // г¬®¦ҐЁҐ T*vector
{
 vector<T> ret(a.vp->size);
 for(register i=0;i<a.vp->size;i++) ret.vp->p[i]=a.vp->p[i]*b;
 return ret;
}

template<class T>
vector<T> operator+(const vector<T>& a,const vector<T>& b) // б«®¦ҐЁҐ vector+vector
{
 assert(a.vp->size==b.vp->size);
 vector<T> ret(a.vp->size);
 for(register i=0;i<a.vp->size;i++) ret.vp->p[i]=a.vp->p[i]+b.vp->p[i];
 return ret;
}
// ўлзЁв ЁҐ vector-vector
template<class T>
vector<T> operator-(const vector<T>& a,const vector<T>& b)
{
 assert(a.vp->size==b.vp->size);
 vector<T> ret(a.vp->size);
 for(register i=0;i<a.vp->size;i++) ret.vp->p[i]=a.vp->p[i]-b.vp->p[i];
 return ret;
}

template<class T>
vector<T>& vector<T>::operator+=(const vector<T>& a) // б«®¦ҐЁҐ vector+=vector
{
 assert(vp->size==a.vp->size);
 for(register i=0;i<vp->size;i++) vp->p[i]+=a.vp->p[i];
 return *this;
}

template<class T>
vector<T>& vector<T>::operator-=(const vector<T>& a) // ўлзЁв ЁҐ vector-=vector
{
 assert(vp->size==a.vp->size);
 for(register i=0;i<vp->size;i++) vp->p[i]-=a.vp->p[i];
 return *this;
}

template<class T>
istream& operator>>(istream& in,vector<T>& a) // звҐЁҐ Ё§ Ї®в®Є 
{
 for(register i=0;i<a.vp->size;in>>a.vp->p[i++]);
 return in;
}

template<class T>
ostream& vector<T>::write_bin(ostream& out) // § ЇЁбм ў ЎЁ ал© д ©«
{
 int s=sizeof(T);
 for(register i=0;i<vp->size;out.write((char*)&vp;->p[i++],s));
 return out;
}

template<class T>
istream& vector<T>::read_bin(istream& in) // звҐЁҐ Ё§ ЎЁ а®Ј® д ©« 
{
 int s=sizeof(T);
 for(register i=0;i<vp->size;in.read((char*)&vp;->p[i++],s));
 return in;
}

//---------------------------------------------------------------------
template<class T> class QUADR;
// § ЇЁбм ў ЎЁ ал© д ©« ¬ ббЁў  QUADR
template<class T>
ofstream& write_quadr(vector<QUADR<T> >& a,ofstream& out)
{
 for(register i=0;i<a.max();a[i++].write_bin(out));
 return out;
};
// звҐЁҐ Ё§ ЎЁ а®Ј® д ©«  ¬ ббЁў  QUADR
template<class T>
ifstream& read_quadr(vector<QUADR<T> >& a,ifstream& in)
{
 for(register i=0;i<a.max();a[i++].read_bin(in));
 return in;
};

template<class T> class compl;
// § ЇЁбм ў ЎЁ ал© д ©« ¬ ббЁў  compl
template<class T>
ofstream& write_compl(vector<compl<T> >& a,ofstream& out)
{
 for(register i=0;i<a.max();a[i++].write_bin(out));
 return out;
};
// звҐЁҐ Ё§ ЎЁ а®Ј® д ©«  ¬ ббЁў  compl
template<class T>
ifstream& read_compl(vector<compl<T> >& a,ifstream& in)
{
 for(register i=0;i<a.max();a[i++].read_bin(in));
 return in;
};

#endif