svector.h

windows ce 下的3D桌面

#pragma once

#if TRUE
template <class T>
class SVector
{
public:
	SVector(int nMaxSize = 10)
	{
		m_nSize = 0;
		m_nMaxSize = nMaxSize;
		m_tElement = new T[m_nMaxSize];
		//memset(m_tElement, 0, m_nMaxSize * sizeof(T));
	}
	~SVector()
	{
		delete []m_tElement;
	}

	void clear()
	{
		delete []m_tElement;
		m_nSize = 0;
		m_nMaxSize = 10;
		m_tElement = new T[m_nMaxSize];
	}

	UINT size()
	{
		return m_nSize;
	}

	UINT maxsize()
	{
		return m_nMaxSize;
	}

	void push_back(const T& Val);
	T &operator [](UINT nIndex);
	SVector<T> & operator=(SVector<T> &svSource);
private:
	UINT m_nSize;
	UINT m_nMaxSize;
	T *m_tElement;
};

template <class T>
void SVector<T>::push_back(const T& Val)
{
	if(m_nSize >= m_nMaxSize)
	{
		int nMaxSize = (m_nMaxSize<<1);
		T *tElement = new T[nMaxSize];
		//memset(tElement, 0, nMaxSize * sizeof(T));
		for(UINT i=0; i<m_nMaxSize; i++)
		{
			*(tElement + i) = *(m_tElement + i);
		}
		//memcpy(tElement, m_tElement, m_nMaxSize * sizeof(T));
		delete []m_tElement;
		m_tElement = tElement;
		m_nMaxSize = nMaxSize;
	}
	*(m_tElement + m_nSize) = (T)Val;
	m_nSize++;
}

template <class T>
T &SVector<T>::operator[](UINT nIndex)
{
	return m_tElement[nIndex];
}

template <class T>
SVector<T> &SVector<T>::operator=(SVector<T> &svSource)
{
	delete []m_tElement;
	m_nSize = svSource.size();
	m_nMaxSize = svSource.maxsize();
	m_tElement = new T[m_nMaxSize];
	for(UINT i=0; i<m_nSize; i++)
	{
		*(m_tElement + i) = svSource[i];
	}
	return *this;
}
#else

template <class T>
class SVector
{
public:
	struct Element
	{
		Element *pNext;
		T m_tData;
	};
	SVector(int nMaxSize = 10)
	{
		m_nSize = 0;
		m_pHead = NULL;
	}
	~SVector()
	{
		clear();
	}

	void clear()
	{
		Element *pTemp;
		while(m_pHead)
		{
			pTemp = m_pHead;
			m_pHead = m_pHead->pNext;
			delete pTemp;
		}
		m_nSize = 0;
	}

	UINT size()
	{
		return m_nSize;
	}

	void push_back(const T& Val)
	{
		Element *pNew = new Element;
		pNew->m_tData = Val;
		m_nSize++;
		if(m_pHead)
		{
			Element *pTemp = m_pHead;
			Element *pSave = m_pHead;
			while(pTemp)
			{
				pSave = pTemp;
				pTemp = pTemp->pNext;
			}
			pSave->pNext = pNew;
		}
		else
		{
			m_pHead = pNew;
		}
	}

	T &operator [](UINT nIndex)
	{
		if(m_pHead)
		{
			if(nIndex > m_nSize)
			{
				return m_pHead->m_tData;
			}
			else
			{
				UINT nNum = 0;
				Element *pTemp = m_pHead;
				while(nNum < nIndex)
				{
					pTemp = pTemp->pNext;
					nNum++;
				}
				return pTemp->m_tData;
			}
		}
		else
		{
			m_pHead = new Element;
			m_nSize = 1;
			return m_pHead->m_tData;
		}
	}
private:
	UINT m_nSize;
	Element *m_pHead;
};
#endif

//template <class T>
//void SVector<T>::push_back(const T& Val)
//{
//	if(m_nSize >= m_nMaxSize)
//	{
//		int nMaxSize = (m_nMaxSize<<1);
//		T *tElement = new T[nMaxSize];
//		memset(tElement, 0, nMaxSize * sizeof(T));
//		memcpy(tElement, m_tElement, m_nMaxSize * sizeof(T));
//		delete []m_tElement;
//		m_tElement = tElement;
//	}
//	m_tElement[m_nSize] = Val;
//	m_nSize++;
//}
//
//template <class T>
//T &SVector<T>::operator[](UINT nIndex)
//{
//	return m_tElement[nIndex];
//}