请教一下传递const引用赋值给对象问题！

[H_rui]

template<typename T>
class SArray {
public:
	explicit SArray (size_t s)
		: storage(new T[s])
		, storage_size(s)
	{
		init();
	}
	SArray (SArray<T> const& orig)
		: storage(new T[orig.size()] )
		, storage_size(orig.storage_size)
	{
		copy(orig);
	}
	~SArray(){
		delete[] storage;
	}

	SArray<T>& operator= (SArray<T> const& orig) {
		if ( &orig != this )
			copy(orig);

		return *this;
	}

	size_t size() const {
		return storage_size;
	}

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

	T& operator[] (size_t idx) {
		return storage[idx];
	}
protected:
	void init() {
		for ( size_t idx = 0; idx < size(); ++idx )
		{
			storage[idx] = T();
		}
	}
	void copy (SArray<T> const& orig) {
		assert(size() == orig.size() );
		for ( size_t idx = 0; idx < size(); ++idx )
		{
			storage[idx] = orig.storage[idx];
		}
	}
private:
	T* storage; // 元素存储空间
	size_t storage_size;
};

template<typename T>
SArray<T> operator+ (SArray<T> const& a, SArray<T> const& b)
{
	SArray<T> result(a.size());
	for ( size_t k = 0; k < a.size(); ++k)
	{
		result[k] = a[k] + b[k];
	}

	return result;
}

template<typename T>
SArray<T> operator* (SArray<T> const& a, SArray<T> const& b)
{
	SArray<T> result(a.size());
	for ( size_t k = 0; k < a.size(); ++k )
	{
		result[k] = a[k] * b[k];
	}

	return result;
}

template<typename T>
SArray<T> operator* (T const& s, SArray<T> const& a)
{
	SArray<T> result(a.size());
	for ( size_t k = 0; k < a.size(); ++k )
	{
		result[k] = s * a[k];
	}

	return result;
}

int _tmain(int argc, _TCHAR* argv[])
{
	SArray<double> x(1000), y(1000);
	x = 1.2*x + x*y;
	return 0;
}

在SArray<T> result(a.size());
for ( size_t k = 0; k < a.size(); ++k)
{
result[k] = a[k] + b[k];
}中，我传递const&的a赋值给result一个拷贝，我在重载【】时候为什么进的是T&啊，而不是T，
T operator[] (size_t idx) const
T& operator[] (size_t idx)
请详细解释一下，谢谢

[pengzhixi]

你是如何知道你进的是T&而不是T呢

[H_rui]

我跟进去，进了T&而不是T，所以我搞不懂了！忘记Primer上哪里讲过了，发帖子问问

[qscool1987]

template<typename T>
SArray<T> operator* (T const& s, SArray<T> const& a)
{
SArray<T> result(a.size());
for ( size_t k = 0; k < a.size(); ++k )
{
result[k] = s * a[k];
}

return result;
}
参数是常引用，说明函数体类不能修改，那么a[k]这个必然调用的是T operator[] (size_t idx) const
版本，
SArray<T> result(a.size());这么一搞之后，result[k]必然调用的是T& operator[] (size_t idx)这个版本，因为result是一个新的对象没有const修饰，可以被修改

[H_rui]

哎呀，我眼睛又瞎了，没看清楚又发帖乱问，是qscool1987说的这样子的！谢谢啊