Hàm search với kiểu dữ liệu bất kì theo một yêu cầu bất kì

[chanphat01001]

Bài này còn nhiều thiếu xót, máy bạn xem xong cho nhận xét để rút kinh nghiệm nha!!!!

#include<iostream.h>
#include<stdarg.h>
#pragma warning(disable:4715)
#include<math.h>
/**************************************************************/
//				SEARCH WITH A CONST NUMBER
template<class T>
class SearchConst
{
public:
	virtual void Find(T *a,int na,T b)=0;
};

// LinearFind can find the similar numbers
template<class T>
class LinearFind:public SearchConst<T>
{
public:
	void Find(T *a,int na,T b)
	{
		int *tam;
		int count=0;
		tam=new int[na+1];
		for(int i=1;i<=na;i++)
		{
			if(a[i]==b)
				tam[++count]=i;
		}
		if(count==0)
			cout<<"Don't find The satisfied Object\n";
		else 
		{
			cout<<"The Objects that are equal with it is found in: ";
			for(i=1;i<=count;i++)
				cout<<tam[i]<<"th number  ";
			cout<<"\n";
		}
		delete tam;
	}
};
//	BinaryFind can't find the similar numbers and can't find if array isn't sorted
template<class T>
class BinaryFind:public SearchConst<T>
{
public:
	void Find(T *a,int na,T b)
	{
		int tam=0;
		int left=1;
		int right=na;
		int mid;
		do
		{
			mid=(left+right)/2;
			if(b==a[mid]) tam=mid;
			else
				if(x<a[mid]) right =mid-1;
				else left=mid+1;
		}while(left<=right);
		if(tam!=0)
			cout<<"The satisfied Object is found in: "<<tam<<"th number\n";

		else cout<<"Don't find The satisfied Object\n";
	}
};
/***********************************************************/
//				SEARCH WITH MANY REQUESTES
template<class T>
class SearchRequestes
{
public:
	virtual void Find(T *a,int na,T *b,int nb)=0;
};

template<class T>
class FirstNumber:public SearchRequestes<T>
{
public:
	void Find(T *a,int na,T *b,int nb)
	{
		cout<<"The satisfied Object is in: ";
		for(int i=1;i<=na;i++)
			if(a[i]==b[1])
			{
				cout<<i<<"th number  \n";
				break;
			}
	}
};

template<class T>
class EndNumber:public SearchRequestes<T>
{
public:
	void Find(T *a,int na,T *b,int nb)
	{
		cout<<"The satisfied Object is in: ";
		for(int i=1;i<=na;i++)
			if(a[i]==b[nb])
			{
				cout<<i<<"th number  \n";
				break;
			}
	}
};

template<class T>
class BestNumber:public SearchRequestes<T>
{
public:
	void Find(T *a,int na,T *b,int nb)
	{
		int *tam;
		int count=0;
		tam=new int[na+1];
		T max=b[1];
		for(int i=1;i<=nb;i++)
			if(max<b[i])
				max=b[i];
		for(i=1;i<=na;i++)
			if(a[i]==max)
				tam[++count]=i;
			cout<<"The satisfied Object is in: ";
			for(i=1;i<=count;i++)
				cout<<tam[i]<<"th number  ";
			cout<<"\n";
			delete tam;
	}
};

template<class T>
class LeastNumber:public SearchRequestes<T>
{
public:
	void Find(T *a,int na,T *b,int nb)
	{
		int *tam;
		int count=0;
		tam=new int[na+1];
		T min=b[1];
		for(int i=1;i<=nb;i++)
			if(min>b[i])
				min=b[i];
		for(i=1;i<=na;i++)
			if(a[i]==min)
				tam[++count]=i;
		cout<<"The satisfied Object is in: ";
		for(i=1;i<=count;i++)
			cout<<tam[i]<<"th number  ";
		cout<<"\n";
		delete tam;
	}
};
/**********************************************************/ 
//						 FILTERS
template<class T> 
class Filter 
{ 
public: 
   virtual bool Indentity(T t)=0; 
}; 

template<class T> 
class Positive:public Filter<T> 
{ 
public: 
   bool Indentity(T t) 
   { 
      return (t>0); 
   } 
}; 

template<class T > 
class Negative:public Filter<T> 
{ 
public: 
   bool Indentity(T t) 
   { 
      return (t<0); 
   } 
}; 

template<class T> 
class Prime: public Filter<T> 
{ 
public: 
   bool Indentity(T t) 
   { 
      int i=1; 
      while(i<=t/2) 
      { 
         if((t%i)!=0) 
            i++; 
      } 
      if(i==t/2) return 1; 
      else return 0; 
   } 
}; 

template <class T> 
class Odd:public Filter<T> 
{ 
public: 
   bool Indentity(T t) 
   { 
      if(t%2!=0) 
         return 1; 
      else return 0; 
   } 
}; 

template<class T > 
class Even:public Filter<T> 
{ 
public: 
   bool Indentity(T t) 
   { 
      if(t%2==0) 
         return 1; 
      else return 0; 
   } 
}; 

//************************************************
//					IMPLEMENT 
template<class T>
class ToolSearch
{
private:
	T *a;
	int na;
	T b;
	SearchConst<T> *sc;
	SearchRequestes<T> *sr;
public:
	ToolSearch()
	{
		a=NULL;
		na=0;
		sc=NULL;
		sr=NULL;
	}
	int getna()
	{
		return na;
	}
	void Import()
	{
		cout<<"The number of objects: ";
		cin>>na;
		a=new T[na];
		for(int i=1;i<=na;i++)
		{
			cout<<"a["<<i<<"]= ";
			cin>>a[i];
		}
		cout<<"Object is needed to find: \n"<<"      ";
		cin>>b;
	}

	void Implement(SearchConst<T> *sc1)
	{
		sc=sc1;
		sc->Find(a,na,b);
	}
	void Implement(SearchRequestes<T> *sr1,Filter<T> *first,...)
	{
		T *b;
		int count=0;
		b=new T[na];
		sr=sr1;
		//Filter number by number
		for(int i=1;i<=na;i++)
		{
			va_list paralist;
			va_start(paralist,first);
			Filter<T> *ptrFilter=first;
			while(ptrFilter!=NULL)
			{
				if(ptrFilter->Indentity(a[i])!=0)
					ptrFilter=va_arg(paralist,Filter<T>*);
				else break;
			}
			if(ptrFilter==NULL)
				b[++count]=a[i];
		}
		if(count!=0)
			sr->Find(a,na,b,count);
		else cout<<"Don't find The satisfied Object";
	}
};
/********************************************************************/
//					Support more Fraction,String,Complex Number Type

//								Fraction		
class Fraction
{
public:
	int t;
	int m;
public:
	Fraction()
	{
		t=m=0;
	}
	Fraction(int t1,int m1)
	{
		t=t1;
		m=m1;
	}
	Fraction(Fraction &a)
	{
		t=a.t;
		m=a.m;
	}
	friend ostream& operator<<(ostream &os,Fraction &a)
	{
		cout<<a.t<<"/"<<a.m;
		return os;
	}
	friend istream& operator>>(istream &is,Fraction &a)
	{
		cin>>a.t;cout<<"      --"<<"\n"<<"      ";
		if(a.t<0) cout<<" ";
		cin>>a.m;
		return is;
	}
	Fraction& operator=(Fraction &a)
	{
		t=a.t;
		m=a.m;
		return a;
	}
	friend int operator==(Fraction &a,Fraction &b)
	{
		if(((a.t==b.t)&&(a.m==b.m))||(float(a.t)/float(b.t)==float(a.m)/float(b.m)))
			return 1;
		else return 0;
	}
	friend int operator>(Fraction &a,Fraction &b)
	{
		if(a.t*b.m>b.t*a.m)
			return 1;
		else return 0;
	}
	friend int operator<(Fraction &a,Fraction &b)
	{
		if(a.t*b.m<b.t*a.m)
			return 1;
		else return 0;
	}
	int operator>(int a)
	{
		if(t>m*a)
			return 1;
		else return 0;
	}
	int operator<(int a)
	{
		if(t<m*a)
			return 1;
		else return 0;
	}
};
//				Complex Number
class Complex
{
public:
	int a;
	int b;
public:
	Complex()
	{
		a=b=0;
	}
	Complex(int a1,int b1)
	{
		a=a1;
		b=b1;
	}
	Complex(Complex &p)
	{
		a=p.a;
		b=p.b;
	}
	friend istream &operator>>(istream &is,Complex &p)
	{
		cout<<"Real part: ";cin>>p.a;
		cout<<"Virtual part: ";cin>>p.b;
		return is;
	}
	friend ostream& operator<<(ostream &os,Complex &p)
	{
		cout<<p.a<<".i + "<<p.b;
		return os;
	}
	Complex& operator=(Complex &p)
	{
		a=p.a;
		b=p.b;
		return p;
	}
	friend int operator==(Complex &p,Complex &q)
	{
		if((p.a==q.a)&&(p.b==q.b))
			return 1;
		else return 0;
	}
	friend int operator>(Complex &p,Complex &q)
	{
		if(sqrt(float(p.a)*float(p.a)+float(p.b)*float(p.b))>sqrt(float(q.a)*float(q.a)+float(q.b)*float(q.b)))
			return 1;
		else return 0;
	}
	friend int operator<(Complex &p,Complex &q)
	{
		if(sqrt(float(p.a)*float(p.a)+float(p.b)*float(p.b))<sqrt(float(q.a)*float(q.a)+float(q.b)*float(q.b)))
			return 1;
		else return 0;
	}
};
/*********************************************************************/
void main()
{
	ToolSearch<Fraction> *t;
	t=new ToolSearch<Fraction>;
	t->Import();
	t->Implement(new LinearFind<Fraction>);
	// Search wiht requestes
	SearchRequestes<Fraction> *bn,*ln,*fn,*en;
	bn=new BestNumber<Fraction>;
	ln=new LeastNumber<Fraction>;
	fn=new FirstNumber<Fraction>;
	en=new EndNumber<Fraction>;
	// Filters
	Filter<Fraction> *p;
	p=new Positive<Fraction>;
	//e=new Even<int>;
	////////////////////////////
	t->Implement(ln,p,NULL);	
}

[langman]

đây là c++ mà ko phải C thuần túy

[heliox]

Dài thế này. Xem xong mỏi mắt chết.