表达式模板问题

#include<iostream>

#include<cassert>

using std::cout; 

template<typename T>

class SArray//数组

{

	T* storage;

	size_t storage_size;

public:

	explicit SArray(size_t s):storage(new T[s]),storage_size(s){}

	SArray(SArray<T> const& org):storage(new T[org.storage_size]),storage_size(org.storage_size)

	{ Copy(org); }

	~SArray(){delete [] storage;cout<<"delete [] 操作成功\n";}

	SArray<T>& operator=(SArray<T> const& org)

	{

		if(&org!=this)

		{ Copy(org); }

		return *this;

	}

	size_t size()const{return storage_size;}

	const T& operator[](size_t idx)const{return storage[idx];}

	T& operator[](size_t idx){return storage[idx];}

private:

	void Copy(SArray<T> const& org)

	{

		assert(size()==org.size());

		for(size_t idx(0);idx<storage_size;++idx)

			storage[idx]=org.storage[idx];

	}

};

template<typename T>

class A_Scalar//常数

{

	T const& s;

public:

	A_Scalar(T const& v):s(v){}

	T operator[](size_t){return s;}

	size_t size()const{return 0;}

};

template<typename T>

class A_Traits//特征类

{

public:

	typedef T const& ExprRef;

};

template<typename T>

class A_Traits<A_Scalar<T> >//特征类的偏特化

{

public:

	typedef A_Scalar<T> ExprRef;

};

template<typename T,typename OP1,typename OP2>

class A_Add//储存加关系

{

	typename A_Traits<OP1>::ExprRef op1;

	typename A_Traits<OP2>::ExprRef op2;

public:

	A_Add(OP1 const& a,OP2 const& b):op1(a),op2(b){}

	T operator[](size_t idx)const{return op1[idx]+op2[idx];}

	size_t size()const

	{

		assert(op1.size()==0||op2.size()==0||op1.size()==op2.size());

		return op1.size()!=0?op1.size():op2.size();

	}

};

template<typename T,typename OP1,typename OP2>

class A_Mult//储存乘关系

{

	typename A_Traits<OP1>::ExprRef op1;

	typename A_Traits<OP2>::ExprRef op2;

public:

	A_Mult(OP1 const& a,OP2 const& b):op1(a),op2(b){}

	T operator[](size_t idx)const{return op1[idx]*op2[idx];}

	size_t size()const

	{

		assert(op1.size()==0||op2.size()==0||op1.size()==op2.size());

		return op1.size()!=0?op1.size():op2.size();

	}

};

template<typename T,typename Rep=SArray<T> >

class Array//直接操作的类

{

	Rep expr_rep;

public:

	explicit Array(size_t s):expr_rep(s){}

	Array(Rep const& org):expr_rep(org){}

	Array& operator=(Array const& org)

	{

		size_t num=size();

		assert(num==org.size());

		for(size_t idx(0);idx<num;++idx)

		{

			expr_rep[idx]=org[idx];

		}

		return *this;

	}

	template<typename T2,typename Rep2>

	Array& operator=(Array<T2,Rep2> const & org)

	{

		size_t num=size();

		assert(num==org.size());

		for(size_t idx(0);idx<num;++idx)

		{

			expr_rep[idx]=org[idx];

		}

		return *this;

	}

	size_t size()const{return expr_rep.size();}

	T operator[](size_t idx)const{return expr_rep[idx];}

	T& operator[](size_t idx){return expr_rep[idx];}

	Rep const& rep()const{return expr_rep;}

	Rep& rep(){return expr_rep;}

	friend std::ostream& operator<<(std::ostream& os,Array<T,Rep>const& org)

	{

		size_t num=org.size();

		for(size_t idx=0;idx<num;++idx)

			os<<org.expr_rep[idx]<<' ';

		os<<'\n';

		return os;

	}

};

template<typename T,typename R1,typename R2>//数组加数组

Array<T,A_Add<T,R1,R2> >

operator+(Array<T,R1> const& a,Array<T,R2> const& b)

{

	return Array<T,A_Add<T,R1,R2> >(A_Add<T,R1,R2>(a.rep(),b.rep()));

}

template<typename T,typename R1,typename R2>//数组乘数组

Array<T,A_Mult<T,R1,R2> >

operator*(Array<T,R1> const& a,Array<T,R2> const& b)

{

	return Array<T,A_Mult<T,R1,R2> >(A_Mult<T,R1,R2>(a.rep(),b.rep()));

}

template<typename T,typename R2>//常数乘数组

Array<T,A_Mult<T,A_Scalar<T>,R2> >

operator*(T const& s,Array<T,R2> const& b)

{

	return Array<T,A_Mult<T,A_Scalar<T>,R2> >(A_Mult<T,A_Scalar<T>,R2>(A_Scalar<T>(s),b.rep()));

}

/////////////////////////////

int main()

{;

	Array<int> x(10),y(10);	

	for(size_t idx=0;idx<10;++idx)

		x[idx]=y[idx]=idx;

	cout<<"x=\n"<<x;

	cout<<"y=\n"<<y;

	cout<<"- - - - - - - - - - - - - - -\n";

	x=x+x*y;

//	x=2*x;//为什么这个表达式有错??

	cout<<"x=\n"<<x;

	cout<<"y=\n"<<y;

///////////////////////////////////////////////////

	return 0;

}